顺序表

顺序表的表中元素存储方式：

顺序表完整信息包含两部分：
1. 表中的元素集合
2. 有关表的整体情况的信息

顺序表两种实现方式：

图a为一体式结构：表信息和元素存储区在内存连续存放。结构整体性强，易于管理，但元素存储区在创建顺序表后固定。
图b为分离式结构：表对象只有整个表有关的信息，元素存储区通过链接与基本表对象关联。
元素存储区替换时：一体式结构更换数据区需要整个表改变。分离式则只需改变数据区指针
元素存储区扩充时：分离式可以不改变表对象前提下扩充数据区（这种实现方式称为动态顺序表）
扩充的两种策略：
- 每次扩充增加固定数目的存储位置（线性增长）。特点：节省空间，若扩充操作频繁，则操作次数多。
- 每次扩充容量加倍。特点：减少扩充操作次数，以空间换时间，推荐。

顺序表操作复杂度
增加元素：
a. 尾端加入元素，时间复杂度为O(1)
b. 非保序的加入元素（元素加入目标位置，目标位置所在元素移至表尾），时间复杂度为O(1)
c. 保序的元素加入，时间复杂度为O(n)

删除元素：
a. 删除表尾元素，时间复杂度为O(1)
b. 非保序的元素删除（不常见，类似增加元素b），时间复杂度为O(1)
c. 保序的元素删除，时间复杂度为O(n)

Python中的顺序表

list和tuple两种类型采用顺序表的实现

list的基本实现

list就是一种采用分离式技术实现的动态顺序表
Python的官方实现：
1. list建立空表（或者很小的表），系统分配一块能容纳8个元素的存储区；
2. 元素存储区满则一块4倍大的存储区。碰到阈值（阀值为50000）则改为加一倍的方法（避免太多空闲区）

链表

单链表操作

is_empty() 链表是否为空
length() 链表长度
travel() 遍历整个链表
add(item) 链表头部添加元素
append(item) 链表尾部添加元素
insert(pos, item) 指定位置添加元素
remove(item) 删除节点
search(item) 查找节点是否存在

单链表实现

class SingleNode(object):"""单链表的结点"""def __init__(self, item):# _item存放数据元素self.item = item# _next是下一个节点的标识self.next = None
class SingleLinkList(object):"单链表"def __init__(self):self._head = Nonedef is_empty(self):"判断链表是否为空"return self._head == Nonedef length(self):"链表长度"p = self._headcount = 0while p!=None:count+=1p = p.nextreturn countdef travel(self):"遍历链表,以列表形式返回所有值"p = self._headitems = []while p!=None:items.append(p.item)p = p.nextreturn itemsdef add(self,item):"头插法插入元素"node = SingleNode(item)node.next = self._headself._head = nodedef append(self,item):node = SingleNode(item)p = self._headif p != None:while p.next!=None:p = p.nextelse:print("error")return Nonep.next = nodedef 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._headwhile count < (pos - 1):count += 1pre = pre.next# 先将新节点node的next指向插入位置的节点node.next = pre.next# 将插入位置的前一个节点的next指向新节点pre.next = nodedef remove(self,item):"""删除节点"""cur = self._headpre = Nonewhile cur != None:# 找到了指定元素if cur.item == item:# 如果第一个就是删除的节点if not pre:# 将头指针指向头节点的后一个节点self._head = cur.nextelse:# 将删除位置前一个节点的next指向删除位置的后一个节点pre.next = cur.nextbreakelse:# 继续按链表后移节点pre = curcur = cur.nextdef search(self,item):p = self._headwhile p!=None:if p.item == item:return Truep = p.nextreturn Falseif __name__ == "__main__":ll = SingleLinkList()ll.add(1)ll.add(2)ll.append(3)ll.insert(2, 4)print("length:",ll.length())print(ll.travel())print(ll.search(3))print (ll.search(5))ll.remove(1)print ("length:",ll.length())print(ll.travel())

单向循环链表

操作
is_empty() 判断链表是否为空
length() 返回链表的长度
travel() 遍历
add(value) 在头部添加一个节点
append(value) 在尾部添加一个节点
insert(pos, value) 在指定位置pos添加节点
remove(item) 删除一个节点
search(item) 查找节点是否存在
实现
不带头结点
技巧：循环链表使用do while进行遍历比较方便

class SignleNode(object):def __init__(self,value):self._next = Noneself._value = valueclass SingleCirleList(object):def __init__(self):self._head = Noneself._tail = Nonedef is_empty(self):"判断是否为空"return self._head == Nonedef length(self):"求表长"p = self._headcount = 0while True:if p==None:breakp = p._nextcount+=1if p == self._head:breakreturn countdef travel(self):"遍历循环单链表"p = self._headvalues = []if self.is_empty():return valueswhile True:values.append(p._value)p = p._nextif p == self._head:breakreturn valuesdef add(self,value):"在循环单链表头部插入节点"item = SignleNode(value)if self.is_empty():self._head = itemself._tail = itemitem._next = self._headelse:item._next = self._headself._head = itemself._tail._next = itemdef append(self,value):"在循环单链表尾部插入节点"item = SignleNode(value)if self.is_empty():self._head = itemself._tail = itemitem._next = self._headelse:item._next = self._tail._nextself._tail._next = itemself._tail = itemdef insert(self,pos,value):"在指定位置pos添加节点"if pos<=0:self.add(value)elif pos >= self.length():self.append(value)else:p = self._headwhile True:pos -= 1p = p._nextif p == self._head or pos == 0:breakitem = SignleNode(value)item._next = p._nextp._next = itemdef remove(self,item):"删除一个节点，没有则什么都不做"p = self._headpre = self._tailwhile True:if p._value == item:pre._next = p._nextbreakpre = pp = p._nextif p == self._head:#实现do whilebreakdef search(self,item):"查找节点是否存在"p = self._headwhile True:if p._value == item:return Truep = p._nextif p == self._head:breakreturn False
if  __name__ == "__main__":ll = SingleCirleList()ll.add(1)ll.add(2)print(ll.travel())ll.append(4)ll.insert(1,5)print("length:",ll.length())print(ll.travel())print(ll.search(2))print(ll.search(6))ll.remove(1)print(ll.travel())

双向链表

操作
is_empty() 链表是否为空
length() 链表长度
travel() 遍历链表
add(item) 链表头部添加
append(item) 链表尾部添加
insert(pos, item) 指定位置添加
remove(item) 删除节点
search(item) 查找节点是否存在
实现

class Node(object):"""双向链表节点"""def __init__(self, item):self.item = itemself.next = Noneself.prev = None
class DLinkList(object):"""双向链表"""def __init__(self):self._head = Nonedef is_empty(self):"""判断链表是否为空"""return self._head == Nonedef length(self):"""返回链表的长度"""cur = self._headcount = 0while cur != None:count += 1cur = cur.nextreturn countdef travel(self):"""遍历链表"""cur = self._headwhile cur != None:print cur.item,cur = cur.nextprint ""def add(self, item):"""头部插入元素"""node = Node(item)if self.is_empty():# 如果是空链表，将_head指向nodeself._head = nodeelse:# 将node的next指向_head的头节点node.next = self._head# 将_head的头节点的prev指向nodeself._head.prev = node# 将_head 指向nodeself._head = nodedef append(self, item):"""尾部插入元素"""node = Node(item)if self.is_empty():# 如果是空链表，将_head指向nodeself._head = nodeelse:# 移动到链表尾部cur = self._headwhile cur.next != None:cur = cur.next# 将尾节点cur的next指向nodecur.next = node# 将node的prev指向curnode.prev = curdef search(self, item):"""查找元素是否存在"""cur = self._headwhile cur != None:if cur.item == item:return Truecur = cur.nextreturn Falsedef remove(self, item):"""删除元素"""if self.is_empty():returnelse:cur = self._headif cur.item == item:# 如果首节点的元素即是要删除的元素if cur.next == None:# 如果链表只有这一个节点self._head = Noneelse:# 将第二个节点的prev设置为Nonecur.next.prev = None# 将_head指向第二个节点self._head = cur.nextreturnwhile cur != None:if cur.item == item:# 将cur的前一个节点的next指向cur的后一个节点cur.prev.next = cur.next# 将cur的后一个节点的prev指向cur的前一个节点cur.next.prev = cur.prevbreakcur = cur.next
if __name__ == "__main__":ll = DLinkList()ll.add(1)ll.add(2)ll.append(3)ll.insert(2, 4)ll.insert(4, 5)ll.insert(0, 6)print "length:",ll.length()ll.travel()print ll.search(3)print ll.search(4)ll.remove(1)print "length:",ll.length()ll.travel()

Python数据结构02-顺序表、链表相关推荐

数据结构顺序表的查找_数据结构1|顺序表+链表
数据结构学习笔记1 进度:静态分配顺序表+单链表参考资料:b站王道考研+小甲鱼 < 判断一个算法的效率时,函数中的常数和其他次要项常常可以忽略,而更应该关注最高项目.的阶数. 推导大O阶方法 ...
python列表是顺序表还是链表_顺序表与链表
Python中的顺序表 Python中的list和tuple两种类型采用了顺序表的实现技术,具有前面讨论的顺序表的所有性质. tuple是不可变类型,即不变的顺序表,因此不支持改变其内部状态的任何操作 ...
python线性表和队列_[笔记]python数据结构之线性表：linkedlist链表,stack栈,queue队列...
python数据结构之线性表 python内置了很多高级数据结构,list,dict,tuple,string,set等,在使用的时候十分舒心.但是,如果从一个初学者的角度利用python学习数据结构 ...
算法与数据结构(part4)--顺序表
学习笔记,仅供参考,有错必纠文章目录算法与数据结构–基于python 顺序表什么是线性表什么是顺序表顺序表的基本形式顺序表的结构与实现顺序表的结构顺序表的两种基本实现方式扩容策略顺 ...
Python中的顺序表介绍
Python中的顺序表介绍在 Python 中,列表是一种基本的数据类型,列表的数据组成了一个序列,序列里的数据是有序的(索引),可以快速地找到指定的数据. 在开发中,经常需要将一组数据作为一个整体 ...
python数据结构基础（单链表，多链表，二叉树）
python数据结构基础(单链表,多链表,二叉树) 数据结构指数据对象中数据元素之间的关系 Python 给我们提供了很多现成的数据结构类型,这些系统自己定义好的,不需要我们自己去定义的数据结构叫做 ...
Python中的顺序表
Python中的顺序表 Python中的list和tuple两种类型采用了顺序表的实现技术,具有顺序表的所有性质. tuple是不可变类型,即不变的顺序表,因此不支持改变其内部状态的任何操作,而其他方 ...
数据结构_顺序表SeqList（C++
数据结构_SeqList顺序表(C++实现文章目录数据结构_SeqList顺序表(C++实现前言&注意事项顺序表实现方法总结结束前言&注意事项有些函数没有修改成员数据的 ...
能带你起飞的【数据结构】成王第一篇：数据结构的顺序表
目录前言一.什么是顺序表 1.顺序表的概念及结构创建顺序表打印顺序表获取顺序表长度在pos位置新增元素判定是否包含某个元素查找某个元素对应的位置获取 pos 位置的元素给 pos ...

Python数据结构02-顺序表、链表

Python数据结构

顺序表