鏈表
爲什麼需要鏈表
順序表的構建需要預先知道數據大小來申請連續的存儲空間,而在進行擴充時又需要進行數據的搬遷,所以使用起來並不是很靈活。
鏈表結構可以充分利用計算機內存空間,實現靈活的內存動態管理。
鏈表的定義
鏈表(Linked list)是一種常見的基礎數據結構,是一種線性表,但是不像順序表一樣連續存儲數據,而是在每一個節點(數據存儲單元)裏存放下一個節點的位置信息(即地址)。
單向鏈表圖示
單向鏈表
單向鏈表也叫單鏈表,是鏈表中最簡單的一種形式,它的每個節點包含兩個域,一個信息域(元素域)和一個鏈接域。這個鏈接指向鏈表中的下一個節點,而最後一個節點的鏈接域則指向一個空值。
- 表元素域elem用來存放具體的數據。
- 鏈接域next用來存放下一個節點的位置(python中的標識)
- 變量p指向鏈表的頭節點(首節點)的位置,從p出發能找到表中的任意節點。
節點實現
python實現,在最後會附上java實現的代碼
class SingleNode(object):
"""單鏈表的結點"""
def __init__(self,item):
# _item存放數據元素
self.item = item
# _next是下一個節點的標識
self.next = None
單鏈表的操作
- is_empty() 鏈表是否爲空
- length() 鏈表長度
- travel() 遍歷整個鏈表
- add(item) 鏈表頭部添加元素
- append(item) 鏈表尾部添加元素
- insert(pos, item) 指定位置添加元素
- remove(item) 刪除節點
- search(item) 查找節點是否存在
單鏈表的實現
class SingleLinkList(object):
"""單鏈表"""
def __init__(self):
self._head = None
def is_empty(self):
"""判斷鏈表是否爲空"""
return self._head == None
def length(self):
"""鏈表長度"""
# cur初始時指向頭節點
cur = self._head
count = 0
# 尾節點指向None,當未到達尾部時
while cur != None:
count += 1
# 將cur後移一個節點
cur = cur.next
return count
def travel(self):
"""遍歷鏈表"""
cur = self._head
while cur != None:
print cur.item,
cur = cur.next
print ""
頭部添加元素
def add(self, item):
"""頭部添加元素"""
# 先創建一個保存item值的節點
node = SingleNode(item)
# 將新節點的鏈接域next指向頭節點,即_head指向的位置
node.next = self._head
# 將鏈表的頭_head指向新節點
self._head = node
尾部添加元素
def append(self, item):
"""尾部添加元素"""
node = SingleNode(item)
# 先判斷鏈表是否爲空,若是空鏈表,則將_head指向新節點
if self.is_empty():
self._head = node
# 若不爲空,則找到尾部,將尾節點的next指向新節點
else:
cur = self._head
while cur.next != None:
cur = cur.next
cur.next = node
指定位置添加元素
def insert(self, pos, item):
"""指定位置添加元素"""
# 若指定位置pos爲第一個元素之前,則執行頭部插入
if pos <= 0:
self.add(item)
# 若指定位置超過鏈表尾部,則執行尾部插入
elif pos > (self.length()-1):
self.append(item)
# 找到指定位置
else:
node = SingleNode(item)
count = 0
# pre用來指向指定位置pos的前一個位置pos-1,初始從頭節點開始移動到指定位置
pre = self._head
while count < (pos-1):
count += 1
pre = pre.next
# 先將新節點node的next指向插入位置的節點
node.next = pre.next
# 將插入位置的前一個節點的next指向新節點
pre.next = node
刪除節點
def remove(self,item):
"""刪除節點"""
cur = self._head
pre = None
while cur != None:
# 找到了指定元素
if cur.item == item:
# 如果第一個就是刪除的節點
if not pre:
# 將頭指針指向頭節點的後一個節點
self._head = cur.next
else:
# 將刪除位置前一個節點的next指向刪除位置的後一個節點
pre.next = cur.next
break
else:
# 繼續按鏈表後移節點
pre = cur
cur = cur.next
查找節點是否存在
def search(self,item):
"""鏈表查找節點是否存在,並返回True或者False"""
cur = self._head
while cur != None:
if cur.item == item:
return True
cur = cur.next
return False
測試
if __name__ == "__main__":
ll = SingleLinkList()
ll.add(1)
ll.add(2)
ll.append(3)
ll.insert(2, 4)
print "length:",ll.length()
ll.travel()
print ll.search(3)
print ll.search(5)
ll.remove(1)
print "length:",ll.length()
ll.travel()
使用Java語言實現的代碼
package linkList;
/**
* @class: linkList.SingleLinkList
* @description: 單鏈表
* @author: ylg
* @date: 2018-01-24 14:01
*/
public class SingleLinkList {
private Node head;
/**
* @class: linkList.Node
* @description: 節點
*/
class Node {
private int item;
private Node next;
public Node(int item) {
this.item = item;
}
}
/**
* @return 單鏈表是否爲空
*/
public boolean is_empty() {
return head == null;
}
/**
* @return 單鏈表的長度
*/
public int length() {
Node cur = head;
int count = 0;
while (cur != null) {
count++;
cur = cur.next;
}
return count;
}
public void travel() {
Node cur = head;
System.out.print("[ ");
while (cur != null) {
System.out.print(cur.item + " ");
cur = cur.next;
}
System.out.println("]");
}
/**
* 在單鏈表末尾添加元素
*
* @param item
* 添加的元素
*/
public void append(int item) {
Node node = new Node(item);
if (head == null) {
head = node;
} else {
Node cur = head;
while (cur.next != null) {
cur = cur.next;
}
cur.next = node;
}
}
/**
* 在頭部添加
*
* @param item
* 添加的元素
*/
public void add(int item) {
Node node = new Node(item);
if (head == null) {
head = node;
} else {
Node temp = head;
head = node;
node.next = temp;
}
}
/**
* 在指定的位置添加元素
*
* @param pos
* 添加的元素位置
* @param item
* 元素
*/
public void insert(int pos, int item) {
if (pos < 0) {
add(item);
} else if (pos > length() - 1) {
append(item);
} else {
Node node = new Node(item);
Node cur = head;
int count = 0;
while (count < pos - 1) {
count++;
cur = cur.next;
}
node.next = cur.next;
cur.next = node;
}
}
/**
* 刪除元素
*
* @param item
* 刪除的元素
*/
public void remove(int item) {
Node cur = head;
Node pre = null;
while (cur != null) {
if (cur.item == item) {
if (pre == null) {
head = cur.next;
} else {
pre.next = cur.next;
}
break;
} else {
pre = cur;
cur = cur.next;
}
}
}
/**
* 查找
*
* @param item
* 查找的值
* @return 找到返回 TRUE 沒有找到返回FALSE
*/
public boolean search(int item) {
Node cur = head;
while (cur != null) {
if (cur.item == item) {
return true;
}
cur = cur.next;
}
return false;
}
public static void main(String[] args) {
SingleLinkList slink = new SingleLinkList();
slink.append(1);
slink.append(2);
slink.append(3);
slink.add(4);
slink.insert(2, 5);
System.out.println("單鏈表的長度:" + slink.length());
slink.travel();
slink.remove(3);
System.out.println("單鏈表的長度:" + slink.length());
slink.travel();
System.out.println(slink.search(2));
}
}
鏈表與順序表的對比
鏈表失去了順序表隨機讀取的優點,同時鏈表由於增加了結點的指針域,空間開銷比較大,但對存儲空間的使用要相對靈活。
鏈表與順序表的各種操作複雜度如下所示:
操作 | 鏈表 | 順序表 |
---|---|---|
訪問元素 | O(n) | O(1) |
在頭部插入/刪除 | O(1) | O(n) |
在尾部插入/刪除 | O(n) | O(1) |
在中間插入/刪除 | O(n) | O(n) |
注意雖然表面看起來複雜度都是 O(n),但是鏈表和順序表在插入和刪除時進行的是完全不同的操作。鏈表的主要耗時操作是遍歷查找,刪除和插入操作本身的複雜度是O(1)。順序表查找很快,主要耗時的操作是拷貝覆蓋。因爲除了目標元素在尾部的特殊情況,順序表進行插入和刪除時需要對操作點之後的所有元素進行前後移位操作,只能通過拷貝和覆蓋的方法進行。