一、链表
1、基于顺序表的构建需要预先知道数据大小来申请连续的存储空间,而在进行空充时又需要进行数据的搬迁,所以使用起来并不是很灵活。
引出链表结构,可以充分利用计算机内存空间,实现灵活的内存动态管理
2、链表的定义
链表(Linked List)是一种常见的基础数据结构,是一只种类线性表,但是不像顺序表一样连续存储数据,而是在每一个节点(数据存储单元)里存放下一个节点的位置信息(即地址)。
3、顺序表与链表
二、单链表
1、单向链表也叫单链表,每个节点包含两个域,一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值。
表元素域elem用来存放具体的数据。
链接域next用来存放下一个节点的位置(python中的标识)
变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点。
2、单链表节点实现
3、单链表的操作
单链表的头部添加元素与尾部添加元素
指定位置添加元素
删除节点
链表与顺序表的对比
#单链表的封装
class Node(object):
"""
单链表节点的封装
"""
def __init__(self, element):
self.element = element
self.next = None
class SingleLink(object):
"""
单链表的封装
"""
def __init__(self):
# 默认情况下链表为空, 没有任何元素
self.head = None
def is_empty(self):
"""判断链表是否为空"""
return self.head == None
def __len__(self):
"""
链表长度:
1. 如果当前链表为空, 直接返回0;
1. 如果当前链表不为空, 依次遍历链表的每一个元素,计算长度
"""
if self.is_empty():
return 0
else:
cur = self.head
length = 0
while cur != None:
length += 1
cur = cur.next
return length
def trvel(self):
"""遍历链表"""
if not self.is_empty():
cur = self.head
while cur.next != None:
print(cur.element, end=',')
cur = cur.next
print(cur.element)
else:
print("空链表")
def append(self, item):
"""
尾部添加元素
1. 先判断链表是否为空,若是空链表,则将head指向新节点
2. 若不为空,则找到尾部,将尾节点的next指向新节点
"""
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 add(self, item):
"""
头部添加元素
1. 先创建一个保存item值的节点
2. 将新节点的链接域next指向头节点,即head指向的位置
3. 将链表的头head指向新节点
"""
node = Node(item)
node.next = self.head
self.head = node
def insert(self, index, item):
"""
指定位置添加元素
1. 若指定位置index为第一个元素之前,则执行头部插入
2. 若指定位置超过链表尾部,则执行尾部插入
3. 否则, 找到指定位置
"""
if index <= 0:
self.add(item)
elif index >= len(self):
self.append(item)
else:
node = Node(item)
count = 0 # 当前位置
cur = self.head
while count < index - 1:
count += 1
cur = cur.next
node.next = cur.next
cur.next = node
def remove(self, item):
"""
删除指定元素的节点:
1 2 3 4 5
1. 如果删除的是头结点, 指针直接指向头结点的下一个节点;
2. 如果删除的不是头结点, 一直循环, 知道找到要删除的节点元素;
"""
pre = None
cur = self.head
if cur.element == item:
self.head = self.head.next
else:
while cur:
if cur.element != item:
pre = cur
cur = cur.next
else:
pre.next = pre.next.next
break
def search(self, item):
"""
判断查找的元素在节点中是否存在, 返回Bool类型
"""
cur = self.head
while cur:
if item == cur.item:
return True
cur = cur.next
return False
三、单向循环链表
1、单链表的一个变形是单向循环链表,链表中最后一个节点的next域不再为None,而是指向链表的头节点。
2、单向循环链表的操作及代码实现
class Node(object):
"""节点"""
def __init__(self,item):
self.item =item
self.next =None
class SinCycLinkedList(object):
"""单循环链表"""
def __init__(self):
self.head =None
def is_empty(self):
"""判断链表是否为空"""
return self.head == None
def lenght(self):
"""返回链表的长度
如果链表长度为空,返回长度为0"""
if self.is_empty():
return 0
count=1
cur = self.head
while cur.next!= self.head:
count += 1
cur =cur.next
return count
def travel(self):
"""遍历列表"""
if self.is_empty():
return
cur =self.head
print(cur.item,end=',')
while cur.next != self.head:
cur =cur.next
print(cur.item,end=',')
print()
def add(self,item):
"""头部添加节点"""
node =Node(item)
if self.is_empty():
self.head=node
node.next=self.head
else:
#添加的节点指向head
node.next =self.head
#移到链表尾部,将尾部节点的next 指向node
cur =self.head
while cur.next != self.head:
cur =self.next
cur.next =node
#head 指向添加node
self.head = node
def append(self,item):
"""尾部添加节点"""
node =Node(item)
if self.is_empty():
self.head =node
node.next =self.head
else:
#移动链表尾部
cur = self.head
while cur.next != self.head:
cur =cur.next
#将尾节点指向node
cur.next =node
#将node指向头节点
node.next =self.head
def insert(self,pos,item):
"""在指定的位置添加节点"""
if pos <=0:
self.add(item)
elif pos> (self.lenght() - 1):
self.append(item)
else:
node =Node(item)
cur =self.head
count =0
#移动到指定位置的前一个位置
while count < (pos -1):
count +=1
cur =cur.next
node.next =cur.next
cur.next = node
def remove(self,item):
"""删除一个节点"""
#若链表为空,则直接返回
if self.is_empty():
return
#将cur指向头节点
cur =self.head
pre =None
#若头节点的元素就是要查找的元素item
if cur.item == item:
#如果链表不止一个节点
if cur.next !=self.head:
#先找到尾节点,将尾节点的next指向第二个节点
while cur.next != self.head:
cur =cur.next
#cur 指向了尾节点
cur.next =self.head.next
self.head =self.head.next
else:
#链表只有一个节点
self.head =None
else:
pre= self.head
#第一个节点不是要删除的
while cur.next !=self.head:
#找到了要删掉的元素
if cur.item ==item:
#删除
pre.next =cur.next
return
else:
pre =cur
cur =cur.next
#cur指向尾节点
if cur.item ==item:
#删除尾部
pre.next =cur.next
def search(self,item):
"""查找节点是否存在"""
if self.is_empty():
return False
cur =self.head
if cur.item ==item:
return True
while cur.next != self.head:
cur=cur.next
if cur.item ==item:
return True
return False
四、双向链表
1、每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向空值;而另一个指向下一个节点,当此节点为最后一个节点时,指向空值。
2、头部添加节点
3、中间位置添加节点
4、尾部添加节点
5、删除元素
代码实现
class Node(object):
"""
双向链表节点的封装
"""
def __init__(self, element):
self.element = element # 数据域
# 指针域
self.next = None # 指向后继节点的指针
self.prev = None # 指向前驱节点的指针
def __str__(self):
return self.element
class DuLinkList(object):
"""
双向链表的封装
"""
def __init__(self):
self.head = None
def is_empty(self):
"""判断双向链表是否为空"""
return self.head == None
def __len__(self):
"""获取双向链表的长度"""
if self.is_empty():
return 0
cur = self.head
linkLen = 0
while cur:
cur = cur.next
linkLen += 1
return linkLen
def travel(self):
"""遍历链表元素"""
if not self.is_empty():
cur = self.head
while cur.next != None:
print(cur.element, end=',')
cur = cur.next
print(cur.element)
else:
print("空链表")
def add(self, item):
"""
头部添加元素
1. 先创建一个保存item值的节点
2. 将新节点的链接域next指向头节点,即head指向的位置
3. 将链表的头head指向新节点
"""
node = Node(item)
if self.is_empty():
self.head = node
else:
node.next = self.head
self.head.prev = node
self.head = node
def append(self, item):
"""
尾部添加元素
1. 先判断链表是否为空,若是空链表,则将head指向新节点
2. 若不为空,则找到尾部,将尾节点的next指向新节点
"""
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, index, item):
"""
指定位置添加元素
1. 若指定位置index为第一个元素之前,则执行头部插入
2. 若指定位置超过链表尾部,则执行尾部插入
3. 否则, 找到指定位置
"""
if index <= 0:
self.add(item)
elif index >= len(self):
self.append(item)
else:
node = Node(item)
count = 0 # 当前位置
cur = self.head
while count < index - 1:
count += 1
cur = cur.next
node.next = cur.next
cur.next = node
node.prev = cur
cur.next.prev = node
def remove(self, item):
"""
删除指定元素的节点:
1 2 3 4 5
1. 如果删除的是头结点, 指针直接指向头结点的下一个节点;
2. 如果删除的不是头结点, 一直循环, 知道找到要删除的节点元素;
"""
if self.is_empty():
return
pre = None
cur = self.head
# 如果删除的是头结点, 指针直接指向头结点的下一个节点;
if cur.element == item:
self.head = self.head.next
else:
while cur:
if cur.element != item:
pre = cur
cur = cur.next
else:
# 判断删除的是否为尾部节点, 如果是, 则直接让pre.next指向为None;
if not cur.next:
pre.next = None
break
else:
# pre.next = pre.next.next
pre.next = cur.next
cur.next.prev = pre
break
def search(self, item):
cur = self.head
while cur:
if cur.element == item:
return True
cur = cur.next
else:
return False