8.基本数据结构-顺序表和链表
一.内存
- 计算机的作用：对数据进行存储和运算。首先我们需要知道我们目前使用的计算机都是二进制的计算机，就以为着计算机只可以存储和运算二进制的数据。例如下载好的一部电影，该电影可以存储到计算机中，计算机中存储的是基于二进制的电影数据，然后我们可以通过相关的视频播放软件结合相关的硬件对电影的二进制数据进行相关的运算操作，所产生的结果就是我们可以看到电影的画面和听到音频的声音。
- 问题：阐述计算机如何计算1+2的结果？
- 阐述：简单理解为,首先可以将1和2输入到计算机中，然后计算机会将1和2转换成二进制的数据进行数据存储，然后通过加法器进行两个二进制数值的计算并返回结果。
- 分析：上述的阐述中提到，计算机首先需要存储1和2这两个数值，那么计算机如何进行数据的存储呢？那么毫无疑问，计算机可以将数据直接存储到内存中。
- 变量：我们在编程世界中，可以将某个数值直接赋值给一个变量，但是最终数值会被存储到计算机的内存中，因此我们可以理解为，变量表示的就是计算机中进行数据存储的某一块内存。
- 如何形象化的理解计算机的内存？
- 举例：将计算机的内存空间映射到我们现实生活中的话，内存就好比是我们在现实生活中三维立体的空间。生活在北京的北漂们，几乎都居住的是一个独立的公寓或者合租在一个几居室的某一个房间中，那么北漂甲就好比是数据，而他所居住的房间则就是存储数据的一块内存空间。
- 分析：从上述案例中，我们可以得知北漂甲居住的房间会有两个基本的属性，其一就是房间空间的大小，其二就是房间的一个位置标识（门牌号）。那么计算机中存储数据的内存空间也会有这两个最基本的属性：内存空间大小和内存空间的地址。内存空间的大小可以表示该空间可以存储数据值的大小范围，内存空间的地址（用十六进制数值表示）可以用来通过寻址定位、查找到该内存空间中所存储的数据值。
- 如何理解 a = 10 这条赋值语句对应的内存图呢？
- 分析：从上述案例中，我们可以得知北漂甲居住的房间会有两个基本的属性，其一就是房间空间的大小，其二就是房间的一个位置标识（门牌号）。那么计算机中存储数据的内存空间也会有这两个最基本的属性：内存空间大小和内存空间的地址。内存空间的大小可以表示该空间可以存储数据值的大小范围，内存空间的地址（用十六进制数值表示）可以用来通过寻址定位、查找到该内存空间中所存储的数据值。
- 举例：将计算机的内存空间映射到我们现实生活中的话，内存就好比是我们在现实生活中三维立体的空间。生活在北京的北漂们，几乎都居住的是一个独立的公寓或者合租在一个几居室的某一个房间中，那么北漂甲就好比是数据，而他所居住的房间则就是存储数据的一块内存空间。
- 引用：当一个变量中存储的是某一块内存空间的地址，则该变量即可成为那块内存空间的引用。a=10，a就是10所在内存空间的一个引用。
- 指向：当一个变量中存储了一块内存空间的地址，则称该变量（引用）指向了那块内存。
- 不同类型数据占用内存空间的大小：整形（4字节），浮点型（8字节），字符型（1字节）
二.顺序表
顺序表:集合中存储的元素是有顺序的。
顺序表的结构可以分为两种形式：单数据类型和多数据类型。
1、单数据类型
单数据类型：在内存中如何存储 int a = 10，20，30,如何取得每一个数据值呢？
2、多数据类型
多数据类型：在内存中如何存储 li = 10,'a',96.5,如何获取每一个数据值呢？
- 不同类型数据占用内存空间的大小：整形（4字节），浮点型（8字节），字符型（1字节）
- 顺序表的弊端：顺序表的结构需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁。
- Python中的 list 和 tuple 两种类型采用了顺序表的实现技术。
三.链表
链表：相对于顺序表，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。
- 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是每一个结点（数据存储单元）里存放下一个结点的信息（即地址）：
1、单向链表
单向链表也叫单链表，是表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。
- 表中元素elem用来存放具体的数据。
- 链接域next用来存放下一个节点的位置。
- 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。
- 链接域next用来存放下一个节点的位置。
- 单向链表的抽象数据类型定义：
. is_empty()：链表是否为空
. length()：链表长度
. travel()：遍历整个链表
. add(item)：链表头部添加元素
. append(item)：链表尾部添加元素
. insert(pos, item)：指定位置添加元素
. remove(item)：删除节点
. search(item)：查找节点是否存在
- 代码实现：
class Node():
def __init__(self,item):
self.item = item
self.next = None
def __str__(self):
return str(self.item)
class Link():
def __init__(self):
#永远指向链表中第一个节点
self._head = None
def isEmpty(self):
return self._head is None
def add(self,item):
node = Node(item)
node.next = self._head
self._head = node
def length(self):
count = 0
if self.isEmpty():
return count
else:
cur = self._head
while cur is not None:
count += 1
cur = cur.next
return count
def travel(self):
cur = self._head
while cur is not None:
print(cur)
cur = cur.next
def append(self,item):
node = Node(item)
cur = self._head
if self.isEmpty():
self._head = node
else:
while cur is not None:
#因为循环遍历结束后cur会指向空并非最后一个节点
pre_cur = cur
cur = cur.next
pre_cur.next = node
def search(self,item):
ex = False
cur = self._head
while cur is not None:
if cur.item == item:
ex = True
break
cur = cur.next
return ex
def insertTo(self,item,index):
cur = self._head
ex = 0
node = Node(item)
#插入到第一个节点位置
if index <= 0:
self.add(item)
#插入到最后一个节点位置
elif index >= self.length():
self.append(item)
else:
while cur is not None:
pre = cur
cur = cur.next
#此处插入的一定不是第一个节点和最后一个节点位置，因此index要减1
if ex == index-1:
node.next = cur
pre.next = node
break
ex += 1
def remove(self,item):
pre = None
cur = self._head
#删除的是第一个节点
if cur.item == item:
self._head = cur.next
else:
while cur is not None:
pre = cur
cur = cur.next
if cur.item == item:
pre.next = cur.next
cur.next = None
cur = cur.next
#测试代码
link = Link()
link.add('bobo')
link.add('jay')
link.add('tom')
link.add('jerry')
# print(link.search('tom'))
# link.insertTo('haha',1)
link.remove('bobo')
link.travel()
思路二：
class Node():
def __init__(self, item):
self.item = item
self.next = None
# n1 = Node(3)
class Linck():
def __init__(self): # 是用来构建一个空的链表
# _head 永远指向第一个结点的地址
self._head = None
def isEmpty(self):
return self._head is None
def add(self, item):
# 1. item 就是结点中的item
node = Node(item) # 1. 构建了一个结点 (item = item)
node.next = self._head
# 4. 但是此步骤应该放到 self._head = node 前面执行，因为现在只有head指向node，只有通过head找到该结点
# 5. 现在的head指向的是第一个节点的node，所以指向head也就是指向了第一个节点node, 也就是把next和node的item连接上了
# 5. 连接上以后再把head断开 指向第二个的node
self._head = node # 2. 现在_head就不是空了，指向了第一个结点的地址
# node.next = None # 2. 插入第一次的时候next为空,因为只有一个结点
# node.next = self._head
# 3. 插入第二次的时候next不能为空,应该为self._head，
# 3. 因为现在的head指向的是第一个节点的node，所以指向head也就是指向了第一个节点node,也就是把next和node的item连接上了
# 4. 但是此步骤应该放到 self._head = node 前面执行，因为现在只有head指向node，只有通过head找到该结点
def travel(self):
cur = self._head # 指向了第一个节点
# cur.item
# cur.next.item
while cur: # cur 最后是空的时候结束
print(cur.item)
cur = cur.next # 移动到下一个节点
def length(self):
count = 0
cur = self._head
while cur:
count += 1
cur = cur.next
return count
def append(self, item):
node = Node(item) # 建立一个新结点
cur = self._head # cur 是指向第一个节点
# 链表为空
if self.isEmpty():
self._head = node # 如果为空 直接指向新节点
return
# 链表为非空
else:
while cur:
# 因为循环遍历结束后cur会指向空并非最后一个节点
pre = cur # 先让pre保留cur的位置
cur = cur.next # cur 往后走 最后cur会走到空,现在的pre指向的是最后的节点
pre.next = node # 让现在的pre的next指向新加的node节点
# search(item)：查找节点是否存在
def search(self, item):
find = False
cur = self._head
while cur:
if cur.item == item:
find = True
break
else:
cur = cur.next # 不成立就往后找
return find
# insert(pos, item)：指定位置添加元素
def insert(self, pos, item):
# pos 添加的位置 规定从1开始
node = Node(item)
cur = self._head
pre = None
# 思路1 提示报错
lengent = self.length() # 计算长度
if pos <= 0 or pos > lengent:
print('pos错误！')
return
for i in range(1, pos):
pre = cur
cur = cur.next
pre.next = node
node.next = cur
# remove(item)：删除节点
def remove(self, item):
cur = self._head
pre = None
if self._head == None:
return
# 删除的是第一个节点的情况
if self._head.item == item:
self._head = self._head.next
return
# 删除的是非第一个节点
while cur:
if cur.item == item:
pre.next = cur.next
break
else:
pre = cur
cur = cur.next
link = Linck()
# link.add(1)
# link.add(2)
link.append(1)
link.append(2)
link.append(3)
link.travel()
2.单向循环链表
单向循环链表：单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头结点。
- 基本操作和单链表基本一样，实现代码如下：
# coding=utf-8
# 单向循环链表
class Node:
"""节点"""
def __init__(self, item):
self.item = item
self.next = None
def __str__(self):
return str(self.item)
class SinCycLinkedList:
"""单向循环链表"""
def __init__(self):
self._head = None
def is_empty(self):
"""判断链表是否为空"""
return self._head is None
def length(self):
"""链表长度"""
if self.is_empty():
return 0
count = 1
cur = self._head
while cur.next != self._head:
# print("cur", cur.item)
count += 1
cur = cur.next
return count
def travel(self):
"""遍历"""
if self.is_empty():
return
cur = self._head
print(cur.item)
while cur.next != self._head:
cur = cur.next
print(cur.item)
def add(self, item):
"""在头部添加一个节点"""
node = Node(item)
if self.is_empty():
self._head = node
node.next = self._head
else:
node.next = self._head
cur = self._head
while cur.next != self._head:
cur = cur.next
cur.next = 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
# print(type(cur), cur.item, cur.next)
while cur.next != self._head:
cur = cur.next
# print(cur.item)
cur.next = node
node.next = self._head
def insert(self, pos, item):
"""指定位置pos添加节点"""
if pos <= 0:
self.add(item)
elif pos > (self.length() - 1):
self.append(item)
else:
node = Node(item)
cur = self._head
cur_pos = 0
while cur.next != self._head:
if (pos - 1) == cur_pos:
node.next = cur.next
cur.next = node
break
cur_pos += 1
cur = cur.next
def remove(self, item):
"""删除一个节点"""
if self.is_empty():
return
pre = self._head
# 删除首节点
if pre.item == item:
cur = pre
while cur.next != self._head:
cur = cur.next
cur.next = pre.next # 删除首节点（跳过该节点）
self._head = pre.next # 重新指定首节点
# 删除其他的节点
else:
cur = pre
while cur.next != self._head:
if cur.next.item == item:
cur.next = cur.next.next
cur = cur.next
def search(self, item):
"""查找节点是否存在"""
if self.is_empty():
return -1
cur_pos = 0
cur = self._head
if cur.item == item:
return cur_pos
while cur.next != self._head:
if cur.item == item:
return cur_pos
cur_pos += 1
cur = cur.next
if cur_pos == self.length() - 1:
return -1
if __name__ == "__main__":
ll = SinCycLinkedList()
ll.add(1) # 1
ll.add(2) # 2 1
# ll.travel()
ll.append(3) # 2 1 3
ll.insert(2, 4) # 2 1 4 3
ll.insert(4, 5) # 2 1 4 3 5
ll.insert(0, 6) # 6 2 1 4 3 5
print("length:", ll.length()) # 6
ll.travel() # 6 2 1 4 3 5
print("search(3)", ll.search(3)) # 4
print("search(7)", ll.search(7)) # -1
print("search(6)", ll.search(6)) # 0
print("remove(1)")
ll.remove(1)
print("length:", ll.length()) # 6 2 4 3 5
print("remove(6)")
ll.remove(6)
ll.travel()
3.双向链表
双向链表：一种更复杂的链表是 "双向链表" 或 "双面链表"。每个节点有两个链接：一个指向前一个节点，当次节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。
- 代码实现：
# coding=utf-8
# 双向链表
class Node:
"""节点"""
def __init__(self, item):
self.item = item
self.prev = None
self.next = None
class DLinkList:
"""双向链表"""
def __init__(self):
self._head = None
def is_empty(self):
"""判断链表是否为空"""
return self._head is None
def length(self):
"""获取链表长度"""
if self.is_empty():
return 0
else:
cur = self._head
count = 1
while cur.next is not None:
count += 1
cur = cur.next
return count
def travel(self):
"""遍历链表"""
print("↓↓" * 10)
if self.is_empty():
print("")
else:
cur = self._head
print(cur.item)
while cur.next is not None:
cur = cur.next
print(cur.item)
print("↑↑" * 10)
def add(self, item):
"""链表头部添加节点"""
node = Node(item)
if self.is_empty():
self._head = node
else:
cur = self._head
node.next = cur
cur.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 is not None:
cur = cur.next
# 在尾节点添加新的节点
cur.next = node
node.prev = cur
def insert(self, pos, item):
"""指定位置添加"""
# 头部添加
if pos <= 0:
self.add(item)
# 尾部添加
elif pos > (self.length() - 1):
self.append(item)
# 其他位置添加
else:
node = Node(item)
cur = self._head
cur_pos = 0
while cur.next is not None:
if cur_pos == (pos - 1):
# 与下一个节点互相指向
node.next = cur.next
cur.next.prev = node
# 与上一个节点互相指向
cur.next = node
node.prev = cur
cur_pos += 1
cur = cur.next
def remove(self, item):
"""删除节点"""
if self.is_empty():
return
else:
cur = self._head
# 删除首节点
if cur.item == item:
self._head = cur.next
cur.next.prev = None
# 删除其他节点
else:
while cur.next is not None:
if cur.item == item:
# 删除之前：1 ←→ [2] ←→ 3
# 删除之后：1 ←→ 3
cur.prev.next = cur.next
cur.next.prev = cur.prev
cur = cur.next
# 删除尾节点
if cur.item == item:
cur.prev.next = None
def search(self, item):
"""查找节点是否存在"""
if self.is_empty():
return -1
else:
cur = self._head
cur_pos = 0
while cur.next is not None:
if cur.item == item:
return cur_pos
cur_pos += 1
cur = cur.next
if cur_pos == (self.length() - 1):
return -1
if __name__ == "__main__":
ll = DLinkList()
ll.add(1) # 1
ll.add(2) # 2 1
ll.append(3) # 2 1 3
ll.insert(2, 4) # 2 1 4 3
ll.insert(4, 5) # 2 1 4 3 5
ll.insert(0, 6) # 6 2 1 4 3 5
print("length:", ll.length()) # 6
ll.travel() # 6 2 1 4 3 5
print("search(3)", ll.search(3))
print("search(4)", ll.search(4))
print("search(10)", ll.search(10))
ll.remove(1)
print("length:", ll.length())
ll.travel()
print("删除首节点 remove(6)：")
ll.remove(6)
ll.travel()
print("删除尾节点 remove(5)：")
ll.remove(5)
ll.travel()
浙公网安备 33010602011771号