一、实验目的
1．掌握用Python定义线性表的链式存储类型；
2．掌握用Python调试链表的基本方法；
3．掌握链表的基本操作，插入、删除、查找、以及有序链表的合并等算法的实现；
二、实验环境
1．Windows操作系统的计算机
2．Python3.7环境平台和PyCharm编辑器
三、实验说明
1．实现线性表的链式存储结构的基本操作。
2．实验中如无特别说明，均要求使用脚本（.py）方式编写代码。
3．自主编写程序，必要时参考相关资料。
4．实验学时：2学时
四、实验内容和步骤
1．实验内容
（1） 基础实验题
设计整数单链表的基本运算程序，并用相关数据进行测试。
参考框架：
class LinkNode: #单链表结点类
def __init__(self, data=None): #构造函数
……
class LinkList: #单链表类
def __init__(self): #构造函数
……
def CreateListF(self, a): #头插法：由数组a整体建立单链表
……
def CreateListR(self, a): #尾插法：由数组a整体建立单链表
……
def Add(self, e): #在线性表的末尾添加一个元素e
……
def getsize(self): #返回长度
……
def __getitem__(self,i): #求序号为i的元素
……
def __setitem__(self, i, x): #设置序号为i的元素
……
def GetNo(self,e): #查找第一个为e的元素的序号
……
def Insert(self, i, e): #在线性表中序号i位置插入元素e
……
def Delete(self,i): #在线性表中删除序号i位置的元素
……
def display(self): #输出线性表
……
if __name__ == '__main__': #主程序
L=LinkList()
……
（2） 应用实验题
由1~ n（例如n =10 000 000）的n个整数建立顺序表a（采用列表表示）和带头结点的单链表h，编写一个实验程序输出分别将所有元素逆置的时间。
参考框架：
import time
class LinkNode: #单链表结点类
def __init__(self, data=None): #构造方法
……
def create1(n): #建立顺序表
a=[]
……
def create2(n): #尾插法建立单链表
h=LinkNode() #建立头结点
……
def reverse1(a): #求顺序表逆置的时间
t1=time.time() #获取开始时间
……
t2=time.time() #获取结束时间
return t2-t1
def reverse2(h): #求单链表表逆置的时间
t1=time.time() #获取开始时间
……
t2=time.time() #获取结束时间
return t2-t1
n=10000000 #主程序
a=create1(n)
h=create2(n)
print()
print(" 求解结果")
print(" 顺序表逆置时间: %.2f" %(reverse1(a)))
print(" 单链表逆置时间: %.2f" %(reverse2(h)))
print()
2．实验步骤
（1）分析实验内容，写出程序大致框架或完整的程序代码。
（2）进入Python集成环境。
（3）编辑程序并进行保存。
（4）运行程序，若有错误，修改错误后再次运行，如此反复进行到不显示出错为止。
（5）检查程序输出结果。
五、实验代码与结果（程序运行代码及其结果）
1． （1）给出算法的基本设计思想。
（2）根据设计思想，采用Python语言描述算法，关键之处给出注释。
class LinkNode: #单链表节点
def __init__(self,data=None):
self.data=data
self.next=None
class LinkList: #单链表
def __init__(self):
self.head=LinkNode()
self.head.next=None #头节点
def CreateListF(self,a): #头插法
for i in range(self,a):
s=LinkNode(a[i])
s.next=self.head.next
self.head.next=s
def CreateListR(self,a): #尾插法
t=self.head
for i in range(0,len(a)):
s=LinkNode(a[i])
t.next=s
t=s
t.next=None
def geti(self,i): #返回序号为i的结点
p=self.head
j=-1
while(j<i and p is not None):
j+=1
p=p.next
return p
def Add(self,e): #在线性表末尾添加元素e
s=LinkNode(e)
p=self.head
while p.next is not None:
p=p.next
p.next=s
def getsize(self): #获取线性表长度
p=self.head
cnt=0
while p.next is not None:
cnt+=1
p=p.next
return cnt
def __getitem__(self,i): #求序号为i的元素
assert i>=0
p=self.geti(i)
assert p is not None
return p.data
def __setitem__(self,i,x): #设置序号为i的元素
assert i>=0
p=self.geti(i)
assert p is not None
p.data=e
def GetNo(self,e): #查找第一个元素为e的序号
j=0
p=self.head.next
while p is not None and p.data!=e:
j+=1
p=p.next
if p is None:
return -1
else:
return j
def Insert(self,i,e): #将元素e插入序号为i的位置
assert i >=0
s=LinkNode(e)
p=self.geti(i-1)
assert p is not None
s.next=p.next
p.next=s
def Delete(self,i):
assert i>=0
p=self.geti(i-1)
assert p!=None and p.next!=None
p.next=p.next.next
def display(self): #打印单链表
p=self.head.next
while p is not None:
print(p.data,end=' ')
p=p.next
print()
if __name__ == '__main__':
L=LinkList()
L.Add('a'),L.Add('b'),L.Add('c'),L.Add('d'),L.Add('e')
print("L:",end=''),L.display()
print("链表长度=%d"%(L.getsize()))
a=int(input('请输入要查找的序号：'))
print("第 %d 个元素为：%s"%(a,L.__getitem__(a)))
b=str(input('请输入要查找的元素：'))
print(" %s 元素的序号为：%d"%(b,L.GetNo(b)))
c=int(input('请输入要插入元素的位置：'))
d=str(input('请输入要插入的元素：'))
L.Insert(c,d)
print("L: ",end=''),L.display()
e=int(input('请输入要删除元素的序号：'))
L.Delete(e)
print("L:",end=''),L.display()
2． （1）给出算法的基本设计思想。
（2）根据设计思想，采用Python语言描述算法，关键之处给出注释。
import time
class LinkNode: #单链表结点
def __init__(self, data=None):
self.data=data
self.next=None
class LinkList: #单链表
def __init__(self):
self.head=LinkNode()
self.head.next=None #头节点
def CreateListR(self,a): #尾插法
t=self.head
for i in range(0,len(a)):
s=LinkNode(a[i])
t.next=s
t=s
t.next=None
def Reverse(L): #置换
p=L.head.next
L.head.next=None
while p!=None:
q=p.next
p.next=L.head.next
L.head.next=p
p=q
class SqList: #顺序表
def __init__(self,capacity = 0): #最大容量
self.capacity = capacity #用于存储数据
self.data = [None] * self.capacity
self.size = 0
def getsize(self): #获取顺序表长度
return self.size
def createSqList(self,a): #创建顺序表
for i in range(len(a)):
if self.size == self.capacity:
self.resize(self,size * 2)
self.data[self.size] = a[i]
self.size += 1
def resize(self,newcapacity): #修改线性表的最大容量
if newcapacity >= self.capacity:
self.data = self.data + [None] * (newcapacity - self.capacity)
else:
self.data = self.data[:newcapacity]
self.capacity = newcapacity
def reverse(self): #置换函数
i,j = 0, self.getsize()-1
while i<j:
self.data[i], self.data[j] = self.data[j], self.data[i]
i += 1
j -= 1
if __name__ =='__main__':
a=SqList(10000001)
a.createSqList(list(range(10000001)))
t1=time.time()
a.reverse()
t2=time.time()
t=t2-t1
print("顺序表置换时间：",t)
h=LinkList()
h.CreateListR(range(1,10000001))
t1=time.time()
h.Reverse()
t2=time.time()
t=t2-t1
print("单链表置换时间：",t)
扫一扫
2293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
