链表
为什么需要链表
顺序表的构建需要预先知道数据大小来申请连续的存储空间,而在进行扩充时又需要进行数据的搬迁,所以使用起来并不是很灵活。
链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。
链表的定义
链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是不像顺序表一样连续存储数据,而是在每一个节点(数据存储单元)里存放下一个节点的位置信息(即地址)。
一、单向链表
单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值。
- 表元素域elem用来存放具体的数据。
- 链接域next用来存放下一个节点的位置(python中的标识)
- 变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点。
注:
在其他语言中,比如C语言,定义int a = 10,指的是整数10的别名为a,a的值(内容)就是10;而在python中定义a=10,指的是a的值(内容)就是10的地址(10存在内存中)
节点实现
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,node=None): self.__head = node 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, end = ' ') 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) if self.is_empty(): self.__head = node 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()
总结:
class Node(object): """单链表的结点""" def __init__(self,elem): # _item存放数据元素 self.elem = elem # _next是下一个节点的标识 self.next = None class SingleLinkList(object): """单链表""" def __init__(self,node=None): self.__head = node 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.elem,end=' ') cur = cur.next def add(self,item): '''链表头部添加元素,头插法''' node=Node(item) node.next=self.__head self.__head=node def append(self,item): '''链表尾部添加元素,尾插法''' node=Node(item) if self.is_empty(): self.__head=node else: cur=self.__head while cur.next!=None: cur=cur.next cur.next=node def insert(self,pos,item): '''指定位置添加元素 :param pos 从0开始 ''' pre=self.__head if pos <= 0: self.add(item) elif pos > (self.length()-1): self.append(item) else: pre=self.__head count=0 while count < (pos-1): count+=1 pre=pre.next #当循环退出后,pre指向pos-1位置 node=Node(item) node.next=pre.next pre.next=node def remove(self,item): '''删除节点''' cur = self.__head pre = None while cur!= None: if cur.elem == item: #先判断此结点是否是头节点 if cur == self.__head: self.__head= cur.next else: pre.next= cur.next break else: pre = cur cur = cur.next def searh(self,item): '''查找节点是否存在''' cur =self.__head while cur != None: if cur.elem == item: return True else: cur = cur.next return False #验证 if __name__=='__main__': ll=SingleLinkList() print(ll.is_empty()) print('长度:',ll.length()) ll.append(1) print(ll.is_empty()) print('长度:',ll.length()) ll.append(2) ll.add(8) ll.append(3) ll.append(4) ll.append(5) #8 1 2 3 4 5 ll.insert(-1,9)#9 8 1 2 3 4 5 ll.insert(2,100)#9 8 100 1 2 3 4 5 ll.travel() print('-------------') ll.remove(100) ll.travel() print('-------------') ll.remove(9) ll.travel() print('-------------') ll.remove(5) ll.travel()
结果:
True
长度: 0
False
长度: 1
9 8 100 1 2 3 4 5 -------------
9 8 1 2 3 4 5 -------------
8 1 2 3 4 5 -------------
8 1 2 3 4
链表与顺序表的对比
链表失去了顺序表随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大,但对存储空间的使用要相对灵活。
链表与顺序表的各种操作复杂度如下所示:
操作 | 链表 | 顺序表 |
---|---|---|
访问元素 | O(n) | O(1) |
在头部插入/删除 | O(1) | O(n) |
在尾部插入/删除 | O(n) | O(1) |
在中间插入/删除 | O(n) | O(n) |
注意虽然表面看起来复杂度都是 O(n),但是链表和顺序表在插入和删除时进行的是完全不同的操作。链表的主要耗时操作是遍历查找,删除和插入操作本身的复杂度是O(1)。顺序表查找很快,主要耗时的操作是拷贝覆盖。因为除了目标元素在尾部的特殊情况,顺序表进行插入和删除时需要对操作点之后的所有元素进行前后移位操作,只能通过拷贝和覆盖的方法进行。
二、双向链表
一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向空值;而另一个指向下一个节点,当此节点为最后一个节点时,指向空值。
概念:
前驱节点记录的是该节点的上一个节点的位置
后继节点记录的是该节点的下一个节点的位置
操作
- is_empty() 链表是否为空
- length() 链表长度
- travel() 遍历链表
- add(item) 链表头部添加
- append(item) 链表尾部添加
- insert(pos, item) 指定位置添加
- remove(item) 删除节点
- search(item) 查找节点是否存在
实现
class Node(object): """双向链表节点""" def __init__(self, elem): self.elem = elem self.next = None self.prev = None
class DoubleLinkList(object): """双链表""" def __init__(self,node=None): self.__head = node def is_empty(self):#过程同单向链表 """判断链表是否为空""" return self.__head is 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.elem,end=' ') cur = cur.next print(" ") def add(self,item): '''链表头部添加元素,头插法''' node=Node(item) node.next=self.__head self.__head=node node.next.prev=node#相比单向链表只需添加本步 #也可以将上述两步转换为以下两步 # self.__head.prev=node # self.__head=node def append(self,item): '''链表尾部添加元素,尾插法''' node=Node(item) if self.is_empty(): self.__head=node else: cur=self.__head while cur.next!=None: cur=cur.next cur.next=node node.prev=cur#相比单向链表只需添加本步
指定位置插入节点:
def insert(self,pos,item): '''指定位置添加元素 :param pos 从0开始 ''' pre=self.__head if pos <= 0: self.add(item) elif pos > (self.length()-1): self.append(item) else: cur = self.__head count = 0 while count < pos: count += 1 cur = cur.next #当循环退出后,cur指向pos位置 node=Node(item) node.next=cur node.prev=cur.prev cur.prev.next=node cur.prev=node # 也可以将上述两步转换为以下两步 # cur.prev=node # node.prev.next=node
删除节点:
def remove(self,item): '''删除节点''' cur = self.__head while cur!= None: if cur.elem == item: #先判断此结点是否是头节点 if cur == self.__head: self.__head= cur.next if cur.next: #判断链表是否只有一个节点 cur.next.prev = None else: cur.prev.next = cur.next if cur.next: cur.next.prev = cur.prev break else: cur = cur.next def searh(self,item):#过程同单向链表 '''查找节点是否存在''' cur =self.__head while cur != None: if cur.elem == item: return True else: cur = cur.next return False #验证 if __name__=='__main__': dll=DoubleLinkList() print(dll.is_empty()) print('长度:', dll.length()) dll.append(1) print(dll.is_empty()) print('长度:', dll.length()) dll.append(2) dll.add(8) dll.append(3) dll.append(4) dll.append(5) # 8 1 2 3 4 5 dll.insert(-1, 9) # 9 8 1 2 3 4 5 dll.insert(2, 100) # 9 8 100 1 2 3 4 5 dll.travel() dll.remove(100) dll.travel() dll.remove(9) dll.travel() dll.remove(5) dll.travel()
三、单向循环链表
单链表的一个变形是单向循环链表,链表中最后一个节点的next域不再为None,而是指向链表的头节点。
操作
- is_empty() 判断链表是否为空
- length() 返回链表的长度
- travel() 遍历
- add(item) 在头部添加一个节点
- append(item) 在尾部添加一个节点
- insert(pos, item) 在指定位置pos添加节点
- remove(item) 删除一个节点
- search(item) 查找节点是否存在
实现
class Node(object): """单向循环链表的结点""" def __init__(self,elem): # _item存放数据元素 self.elem = elem # _next是下一个节点的标识 self.next = None class SingleCycleLinkList(object): """单向循环链表""" def __init__(self,node=None): self.__head = node if node: node.next=node#相比单向链表需添加本步 def is_empty(self):#过程同单向链表 """判断链表是否为空""" return self.__head == None def length(self): """链表长度""" if self.is_empty():#相比单向链表需添加本步 return 0 # cur初始时指向头节点,cur游标,用来遍历节点 cur = self.__head count = 1#相比单向链表count=0,本步count=1 # 尾节点指向None,当未到达尾部时 while cur.next != self.__head:#相比单向链表不同 count += 1 # 将cur后移一个节点 cur = cur.next return count def travel(self): """遍历链表""" cur = self.__head if self.is_empty():#相比单向链表不同 return while cur.next != self.__head:#相比单向链表不同 print(cur.elem,end=' ') cur = cur.next #退出循环,cur指向尾节点,但尾节点的元素未打印 print(cur.elem)#相比单向链表不同 def add(self,item):#相比单向链表不同 '''链表头部添加元素,头插法''' node = Node(item) if self.is_empty(): self.__head = node node.next = node else: cur = self.__head while cur.next != self.__head: cur = cur.next #退出循环,cur指向尾节点 node.next = self.__head self.__head = node cur.next = node#也可以写成 cur.next = self.__head def append(self,item): '''链表尾部添加元素,尾插法''' node=Node(item) if self.is_empty(): self.__head=node node.next = node#相比单向链表不同 else: cur=self.__head while cur.next!= self.__head:#相比单向链表不同 cur = cur.next cur.next = node node.next = self.__head #上两句可以更换为下两句 # node.next = cur.next # cur.next = node def insert(self,pos,item):#同单向链表操作 '''指定位置添加元素 :param pos 从0开始 ''' pre=self.__head if pos <= 0: self.add(item) elif pos > (self.length()-1): self.append(item) else: pre=self.__head count=0 while count < (pos-1): count+=1 pre=pre.next #当循环退出后,pre指向pos-1位置 node=Node(item) node.next=pre.next pre.next=node def remove(self,item):#不同于单链表操作 '''删除节点''' if self.is_empty(): return #返回空 cur = self.__head pre = None while cur.next != self.__head: if cur.elem == item: #先判断此结点是否是头节点 if cur == self.__head: #头节点的情况,需要找尾节点 rear = self.__head while rear.next != self.__head: rear = rear.next self.__head = cur.next rear.next = self.__head else: #中间节点 pre.next= cur.next return else: pre = cur cur = cur.next # 退出循环,cur指向尾节点 if cur.elem == item: if cur == self.__head: #链表只有一个节点 self.__head = None else: pre.next = cur.next def searh(self,item):#不同于单链表操作 '''查找节点是否存在''' if self.is_empty(): return False cur =self.__head while cur.next != self.__head: if cur.elem == item: return True else: cur = cur.next #退出循环,cur指向尾节点 if cur.elem == item: return True return False #验证 if __name__=='__main__': ll=SingleCycleLinkList() print(ll.is_empty()) print('长度:',ll.length()) ll.append(1) print(ll.is_empty()) print('长度:',ll.length()) ll.append(2) ll.add(8) ll.append(3) ll.append(4) ll.append(5) #8 1 2 3 4 5 ll.insert(-1,9)#9 8 1 2 3 4 5 ll.insert(2,100)#9 8 100 1 2 3 4 5 ll.travel() ll.remove(100) ll.travel() ll.remove(9) ll.travel() ll.remove(5) ll.travel()