Python程序设计教程第8章课件.ppt

1、第第8章章 Python 数据结构数据结构数据结构是计算机存储数据结构是计算机存储和组织数据的方式，指和组织数据的方式，指相互之间存在一种或多相互之间存在一种或多种特定关系的数据元素种特定关系的数据元素的集合。数据结构往往的集合。数据结构往往与高效的检索算法和索与高效的检索算法和索引技术有关。本节介绍引技术有关。本节介绍PythonPython中的一些常用数中的一些常用数据结构的用法，包括栈、据结构的用法，包括栈、队列、树、链表、队列、树、链表、bitmapbitmap和图。和图。本章知识点本章知识点p数据结构基础数据结构基础p队列队列pbitmapbitmapp栈栈p链表链表p图图8.1 P

2、ython数据结构概述数据结构概述8.1.1 8.1.1 什么是数据结构什么是数据结构8.1.2 8.1.2 数据结构和算法的关系数据结构和算法的关系8.1.1 什么是数据结构什么是数据结构p 一个程序里面必然会有数据存在，同样的一个或几个数据要组织一个程序里面必然会有数据存在，同样的一个或几个数据要组织起来，可以有不同的组织方式，也就是不同的存储方式。不同的起来，可以有不同的组织方式，也就是不同的存储方式。不同的组织方式就是不同的结构，我们把这些数据组织在一起的结构称组织方式就是不同的结构，我们把这些数据组织在一起的结构称之为数据的结构，也叫做数据结构。比如，有一个字符串是之为数据的结构，也

3、叫做数据结构。比如，有一个字符串是abcabc，我们将其重新组织一下，比如通过，我们将其重新组织一下，比如通过list()list()函数将函数将abcabc变成变成a,b,ca,b,c，那么这个时候数据就发生了重组，重组之后数据，那么这个时候数据就发生了重组，重组之后数据的结构就变了。的结构就变了。a,b,ca,b,c这种形式的数据的结构被称为列表这种形式的数据的结构被称为列表。也就是说列表是一种数据结构，除此之外，还有元组、字典、。也就是说列表是一种数据结构，除此之外，还有元组、字典、栈、树等数据结构。栈、树等数据结构。p PythonPython的数据结构有很多类型。其中有的数据结构有很

4、多类型。其中有PythonPython系统自己定义好的系统自己定义好的，不需要我们自己去定义。这种数据结构被称为，不需要我们自己去定义。这种数据结构被称为PythonPython的内置数的内置数据结构，比如列表、元组、字典等。而有些数据组织方式，据结构，比如列表、元组、字典等。而有些数据组织方式，PythonPython系统里面没有直接定义，需要我们自己去定义实现，这些系统里面没有直接定义，需要我们自己去定义实现，这些数据组织方式称为数据组织方式称为PythonPython扩展数据结构，比如栈和队列。扩展数据结构，比如栈和队列。8.1.1 弹出消息框弹出消息框使用使用showinfo()sho

5、winfo()函数可以弹出提示消息框，方法函数可以弹出提示消息框，方法如下如下showinfo(title=showinfo(title=标题标题,message=,message=内容内容) )8.1.2 数据结构和算法的关系数据结构和算法的关系数据结构和算法有着密切的联系。因为数据结构数据结构和算法有着密切的联系。因为数据结构是数据的组织方式，也就是数据的存储方式。算是数据的组织方式，也就是数据的存储方式。算法是指运算方法，通俗地讲，算法就是思维。数法是指运算方法，通俗地讲，算法就是思维。数据结构是静态的，我们编写的程序是动态的。程据结构是静态的，我们编写的程序是动态的。程序要对数据进行运

6、算，运算的方法很多，不同的序要对数据进行运算，运算的方法很多，不同的运算方法就是不同的算法。当然算法不是凭空出运算方法就是不同的算法。当然算法不是凭空出来的，它必须建立在数据的基础上，所以数据结来的，它必须建立在数据的基础上，所以数据结构是算法的基础，但同一个数据结构运用不同算构是算法的基础，但同一个数据结构运用不同算法的效率是不同的。法的效率是不同的。8.2 栈栈p8.2.1 8.2.1 栈的工作原理栈的工作原理p8.2.2 8.2.2 利用利用PythonPython列表实现栈的数据结列表实现栈的数据结构构8.2.1 栈的工作原理栈的工作原理栈是一种经典的数据结构，但它并不是栈是一种经典的

7、数据结构，但它并不是PythonPython的内置数据结构，而是属于扩展数据的内置数据结构，而是属于扩展数据结构。栈相当于一端开口、一端封闭的容器结构。栈相当于一端开口、一端封闭的容器。栈支持出栈和进栈。栈支持出栈和进栈2 2种操作。数据移动到栈种操作。数据移动到栈里面的过程叫做进栈，也叫做压栈、入栈；里面的过程叫做进栈，也叫做压栈、入栈；数据进入到栈里面后，就到了栈顶，同时占数据进入到栈里面后，就到了栈顶，同时占了栈的一个位置。当再进入一个数据时，新了栈的一个位置。当再进入一个数据时，新的数据就占据了栈顶的位置，原来的数据就的数据就占据了栈顶的位置，原来的数据就被新的数据压入到栈顶的下一个位

8、置里。栈被新的数据压入到栈顶的下一个位置里。栈只能对其栈顶的数据进行操作，所以这个时只能对其栈顶的数据进行操作，所以这个时候原来的数据就不能被操作。候原来的数据就不能被操作。 初始化时的栈初始化时的栈将数据将数据A执行进栈操作执行进栈操作再将数据再将数据B执行进栈操作执行进栈操作8.2.2 利用利用Python列表实现栈的数据结构列表实现栈的数据结构1. 1. 构造函数构造函数首先，在构造函数中定义一个列表首先，在构造函数中定义一个列表itemsitems用用于实现栈的容器，代码如下：于实现栈的容器，代码如下：#coding:utf8#coding:utf8class Stack:class

9、Stack: 模拟栈模拟栈 defdef _ _initinit_(self):_(self): self.itemsself.items = = 2. isEmpty()函数函数defdef isEmptyisEmpty(self):(self): return return lenlen( (self.itemsself.items)=0 )=0 3. push()函数函数def push(self, item):def push(self, item): self.items.append(item) self.items.append(item)4. pop()函数函数 def pop

10、(self): def pop(self): return self.items.pop() return self.items.pop() 5. peek()函数函数 def pop(self): def pop(self): return self.items.pop() return self.items.pop() 6. size()函数函数 def size(self): def size(self): return len(self.items) return len(self.items) 【例例8-1】s=Stack() #s=Stack() #创建栈对象创建栈对象print(

11、s.isEmpty() #print(s.isEmpty() #打印栈是否为空打印栈是否为空s.push(DataA) #s.push(DataA) #进栈进栈DataADataAs.push(DataB)#s.push(DataB)#进栈进栈DataADataAprint(s.peek()#print(s.peek()#打印栈顶元素打印栈顶元素s.push(DataC)#s.push(DataC)#进栈进栈DataCDataCprint(s.size()#print(s.size()#打印栈的大小打印栈的大小print(s.isEmpty() #print(s.isEmpty() #打印栈是

12、否为空打印栈是否为空s.push(DataD)#s.push(DataD)#进栈进栈DataDDataDprint(s.pop()#print(s.pop()#出栈出栈print(s.pop()#print(s.pop()#出栈出栈print(s.size()#print(s.size()#打印栈的大小打印栈的大小) )8.3 队列队列队列是一种经典的数据结构，它也不是队列是一种经典的数据结构，它也不是PythonPython的的内置数据结构，而是属于扩展数据结构。队列相内置数据结构，而是属于扩展数据结构。队列相当于两边都开口的容器。但是一边只能进行删除当于两边都开口的容器。但是一边只能进行删

13、除操作，而不能进行插入操作；另一边只能进行插操作，而不能进行插入操作；另一边只能进行插入操作，而不能进行删除操作。进行插入操作的入操作，而不能进行删除操作。进行插入操作的这一端叫做队尾，进行删除操作的这一端叫做队这一端叫做队尾，进行删除操作的这一端叫做队首。所以，队列中的数据是从队尾进队首出的。首。所以，队列中的数据是从队尾进队首出的。队列的数据元素又称为队列元素。在队列中插入队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列一个队列元素称为入队，从队列中删除一个队列元素成为出队。元素成为出队。初始化时的队列初始化时的队列将数据将数据A执行入队操作执行入队操作

14、将数据将数据B执行入队操作执行入队操作再将数据再将数据C执行进栈操作执行进栈操作再将数据再将数据C执行进栈操作执行进栈操作将数据将数据A执行出队操作执行出队操作8.3.2 利用利用Python列表实现队列的数列表实现队列的数据结构据结构本节介绍一个本节介绍一个PythonPython自定义类自定义类QueueQueue，它的功能，它的功能是利用是利用PythonPython列表实现队列的数据结构。列表实现队列的数据结构。1. 构造函数构造函数#coding:utf8#coding:utf8class Queue(object) :class Queue(object) : def _init_

15、(self) : def _init_(self) : self.queue = self.queue = 2. isempty()函数函数isemptyisempty()()函数用于判断队列是否为空。如果函数用于判断队列是否为空。如果队列为空，则队列为空，则isemptyisempty()()函数返回函数返回TrueTrue，否则，否则返回返回FalseFalse。isemptyisempty()()函数的代码如下：函数的代码如下： defdef isemptyisempty(self) :(self) : return return self.queueself.queue = = 3.

16、enqueue()函数函数 def enqueue(self, item) : def enqueue(self, item) : self.queue.append(item) self.queue.append(item)4. dequeue()函数函数 def dequeue(self) : def dequeue(self) : if self.queue != : if self.queue != : return self.queue.pop(0) return self.queue.pop(0) else : else : return None return None5. he

17、ad ()函数函数head ()head ()函数用于返回队首元素，但并不删函数用于返回队首元素，但并不删除该元素。代码如下：除该元素。代码如下： defdef head(self) : head(self) : if if self.queueself.queue != : != : return return self.queueself.queue00 else : else : return None return None 6. tail ()函数函数tail ()tail ()函数用于返回队尾元素，但并不删除该函数用于返回队尾元素，但并不删除该元素。代码如下：元素。代码如下： de

18、fdef tail(self) : tail(self) : if if self.queueself.queue != : != : return return self.queueself.queue-1-1 else : else : return None return None7. length()函数函数length()length()函数用于返回队列的大小。代码如下：函数用于返回队列的大小。代码如下： defdef length(self) : length(self) : return return lenlen( (self.queueself.queue) ) 【例【例8-

19、2】q=Queue() #q=Queue() #创建队列对象创建队列对象print(print(q.isemptyq.isempty() #() #打印队列是否为空打印队列是否为空q.enqueueq.enqueue(DataADataA) #) #入队入队DataADataAq.enqueueq.enqueue(DataBDataB)#)#入队入队DataADataAprint(print(q.headq.head()#()#打印对首元素打印对首元素print(print(q.tailq.tail()#()#打印队尾元素打印队尾元素q.enqueueq.enqueue(DataCDataC)

20、#)#入队入队DataCDataCprint(print(q.lengthq.length()#()#打印队列的大小打印队列的大小print(print(q.isemptyq.isempty() #() #打印队列是否为空打印队列是否为空q.enqueueq.enqueue(DataDDataD)#)#入队入队DataDDataDprint(print(q.dequeueq.dequeue()#()#出队出队print(print(q.dequeueq.dequeue()#()#出队出队print(print(q.lengthq.length()#()#打印队列的大小打印队列的大小) )运行结

21、果如下：运行结果如下：TrueTrueDataADataADataBDataB3 3FalseFalseDataADataADataBDataB2 28.4 树树p8.4.1 8.4.1 树的工作原理树的工作原理p8.4.2 8.4.2 遍历二叉树遍历二叉树p8.4.3 8.4.3 在在PythonPython程序中实现树的数据结程序中实现树的数据结构构8.4.1 树的工作原理树的工作原理p树的定义首先有且只有一个根节点，另树的定义首先有且只有一个根节点，另外他有个不相交的子集，每个子集都外他有个不相交的子集，每个子集都是一个子树。是一个子树。空树空树只有一个根结点的二叉树只有一个根结点的二叉

22、树 有左子树的二叉树有左子树的二叉树只有右子树的二叉树只有右子树的二叉树2完全二叉树完全二叉树8.4.2 遍历二叉树遍历二叉树p “遍历遍历”是二叉树各种操作的基础。二叉树是一种非是二叉树各种操作的基础。二叉树是一种非线性结构，遍历二叉树不像遍历线性链表那样容易，线性结构，遍历二叉树不像遍历线性链表那样容易，无法通过简单的循环实现。无法通过简单的循环实现。p 遍历二叉树就是要让树中的所有节点被且仅被遍历二叉树就是要让树中的所有节点被且仅被访问一次，即按一定规律排列成一个线性队列。二叉访问一次，即按一定规律排列成一个线性队列。二叉树包含树包含3 3个部分，即根结点、左子树和右子树。根据这个部分，

23、即根结点、左子树和右子树。根据这3 3个部分的访问次序对二叉树的遍历进行分类，可以将个部分的访问次序对二叉树的遍历进行分类，可以将遍历二叉树的方法分为遍历二叉树的方法分为3 3种类型，分别称为种类型，分别称为“先序遍历先序遍历”、“中序遍历中序遍历”和和“后序遍历后序遍历”。先序遍历指先访。先序遍历指先访问根节点，然后再访问左子树，最后访问右子树；中问根节点，然后再访问左子树，最后访问右子树；中序遍历指访问左子树，然后再访问根节点，最后访问序遍历指访问左子树，然后再访问根节点，最后访问右子树；中序遍历指先访问根节点，然后访问左子树右子树；中序遍历指先访问根节点，然后访问左子树，最后访问右子树；

24、后序遍历指访问左子树，然后再，最后访问右子树；后序遍历指访问左子树，然后再访问右子树，最后访问根节点。访问右子树，最后访问根节点。8.4.3 在在Python程序中实现树的数据结构程序中实现树的数据结构本节介绍一个本节介绍一个PythonPython自定义类自定义类BinaryTreeBinaryTree，它的功能是在，它的功能是在PythonPython程序中实现树的数据结构。程序中实现树的数据结构。1. 定义树节点类定义树节点类Node首先，定义一个树节点类首先，定义一个树节点类NodeNode，代码如下：，代码如下：class Node(object):class Node(object

25、): def _init_(self, data = -1, lchild = None, def _init_(self, data = -1, lchild = None, rchild = None):rchild = None): self.data = data self.data = data self.lchild = lchild self.lchild = lchild self.rchild = rchild self.rchild = rchild2. BinaryTree 类的构造函数类的构造函数p class BinaryTree(object): class Bin

26、aryTree(object):p def _init_(self): def _init_(self):p self.root = Node() self.root = Node()3. BinaryTree 类的类的add()函数函数 def add(self, data): #data def add(self, data): #data为新节点的数据为新节点的数据 node = Node(data) #node = Node(data) #创建新节点创建新节点 if self.isEmpty(): #if self.isEmpty(): #如果二叉树为空，则将新节点作为二叉树如果二叉树

27、为空，则将新节点作为二叉树的根节点的根节点 self.root = nodeself.root = node else: else: tree_node = self.root tree_node = self.root queue = # queue = #以列表存储二叉树以列表存储二叉树 queue.append(self.root)queue.append(self.root) while queue: # while queue: # 遍历二叉树遍历二叉树 tree_node = queue.pop(0)tree_node = queue.pop(0) if tree_node.lch

28、ild = None: #if tree_node.lchild = None: #如果当前节点的左孩子为空，则如果当前节点的左孩子为空，则将新节点作为当前节点的左孩子将新节点作为当前节点的左孩子 tree_node.lchild = nodetree_node.lchild = node return return elif tree_node.rchild = None: # elif tree_node.rchild = None: #如果当前节如果当前节点的右孩子为空，则将新节点作为当前节点的右孩子点的右孩子为空，则将新节点作为当前节点的右孩子 tree_node.rchild = n

29、odetree_node.rchild = node return return else: else: queue.append(tree_node.lchild) queue.append(tree_node.lchild) queue.append(tree_node.rchild) queue.append(tree_node.rchild)4. BinaryTree 类的类的pre_order ()函数函数 def pre_order(self, start): # start def pre_order(self, start): # start是开始遍历的节点是开始遍历的节点 n

30、ode = startnode = start if node = None: # if node = None: # 如果当前节点为空，则返回如果当前节点为空，则返回 returnreturn print node.data, # print node.data, #打印当前节点的数据打印当前节点的数据 # #如果当前节点的左右子树都为空，则返回如果当前节点的左右子树都为空，则返回 if node.lchild = None and node.rchild = None:if node.lchild = None and node.rchild = None: return return s

31、elf.pre_order(node.lchild) # self.pre_order(node.lchild) #从当前节点的左子树开始先序遍从当前节点的左子树开始先序遍历历 self.pre_order(node.rchild) #self.pre_order(node.rchild) #从当前节点的右子树开始先序遍从当前节点的右子树开始先序遍历历5. BinaryTree 类的类的in_order()函数函数 def in_order(self, start): # start def in_order(self, start): # start是开始遍历的节是开始遍历的节点点 node

32、 = start node = start if node = None: if node = None: return return self.in_order(node.lchild) # self.in_order(node.lchild) #从当前节点的从当前节点的左子树开始中序遍历左子树开始中序遍历 print node.data, #print node.data, #打印当前节点的数据打印当前节点的数据 self.in_order(node.rchild) #self.in_order(node.rchild) #从当前节点的从当前节点的右子树开始中序遍历右子树开始中序遍历6.

33、post_order()函数函数 def post_order(self, start): # start def post_order(self, start): # start是开是开始遍历的节点始遍历的节点 node = startnode = start if node = None: if node = None: return return self.post_order(node.lchild) # self.post_order(node.lchild) #从当从当前节点的左子树开始后序遍历前节点的左子树开始后序遍历 self.post_order(node.rchild) #

34、self.post_order(node.rchild) #从当从当前节点的右子树开始后序遍历前节点的右子树开始后序遍历 print node.data, #print node.data, #打印当前节点的数打印当前节点的数据据 7. isEmpty ()函数函数from tkinter import from tkinter import * *root = Tk()root = Tk()cv = Canvas(root, bg = red, width = cv = Canvas(root, bg = red, width = 200, height = 100) 200, height

35、 = 100) cv.pack()cv.pack()root.mainloop()root.mainloop()8. length()函数函数 def length(self) : def length(self) : return len(self.queue) return len(self.queue) 【例例8-3】if _name_ = _main_:if _name_ = _main_: arr = arr = for i in range(10): for i in range(10): arr.append(i) arr.append(i) print arr print ar

36、r tree = BinaryTree() tree = BinaryTree() for i in arr: for i in arr: tree.add(i) tree.add(i) print pre order:print pre order: tree.pre_ordertree.pre_order( (tree.roottree.root) ) print print nin_ordernin_order: tree.in_ordertree.in_order( (tree.roottree.root) ) print print npost_ordernpost_order: t

37、ree.post_ordertree.post_order( (tree.roottree.root) )运行结果如下：运行结果如下：0, 1, 2, 3, 4, 5, 6, 7, 8, 90, 1, 2, 3, 4, 5, 6, 7, 8, 9pre order:pre order:0 1 3 7 8 4 9 2 5 6 0 1 3 7 8 4 9 2 5 6 in_orderin_order: :7 3 8 1 9 4 0 5 2 6 7 3 8 1 9 4 0 5 2 6 post_orderpost_order: :7 8 3 9 4 1 5 6 2 07 8 3 9 4 1 5 6

38、2 0【例例8-3】使用的二叉树使用的二叉树8.5 链表链表8.5.1 8.5.1 链表的工作原理链表的工作原理8.5.2 8.5.2 利用利用PythonPython实现单向链表的数据结实现单向链表的数据结构构8.5.1 链表的工作原理链表的工作原理p 链表是一种非连续、非顺序的存储方式。链表由一系列结点组成链表是一种非连续、非顺序的存储方式。链表由一系列结点组成，每个结点包括两个部分，一部分是数据域，另一部分是指向下，每个结点包括两个部分，一部分是数据域，另一部分是指向下一个结点的指针域。链表可以分为单向链表、单向循环链表、双一个结点的指针域。链表可以分为单向链表、单向循环链表、双向链表、

39、双向循环链表。向链表、双向循环链表。p 单向链表是链表的一种，其特点是链表的链接方向是单向的，对单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。链表的访问要通过顺序读取从头部开始。 通过指针连接起来，但通过指针连接起来，但是只能单向遍历的内存块。，如图是只能单向遍历的内存块。，如图8-168-16所示。所示。单向循环链表单向循环链表单向循环链表的特点是表中最后一个结点单向循环链表的特点是表中最后一个结点的指针域指向头结点的指针域指向头结点, ,整个链表形成一个环整个链表形成一个环双向链表双向链表双向链表的每个数据结点中都有两个指针，分别指向直接双向链

40、表的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。始，都可以很方便地访问它的前驱结点和后继结点。双向循环链表双向循环链表from from tkintertkinter import import * *root = root = TkTk()()cv = Canvas(root, cv = Canvas(root, bgbg = white, width = = white, width = 200, height = 100) 200, height

41、= 100) cv.create_rectanglecv.create_rectangle(10,10,100,80,outline = (10,10,100,80,outline = blue, fill = red, width=2, stipple = blue, fill = red, width=2, stipple = gray12,)gray12,)cv.packcv.pack()()root.mainlooproot.mainloop()()8.5.2 利用利用Python实现单向链表的数实现单向链表的数据结构据结构p 首先，定义一个链表节点类首先，定义一个链表节点类NodeN

42、ode，代码如下：，代码如下：class Node():class Node(): _slots_=_ _slots_=_item,_nextitem,_next # #限定限定NodeNode实例的属性实例的属性 defdef _ _initinit_(_(self,itemself,item):): self._itemself._item=item=item self._nextself._next=None #Node=None #Node的指针部分默认指向的指针部分默认指向NoneNone defdef getItemgetItem(self):(self): return retu

43、rn self._itemself._item defdef getNextgetNext(self):(self): return return self._nextself._next defdef setItemsetItem( (self,newitemself,newitem):): self._itemself._item= =newitemnewitem defdef setNextsetNext( (self,newnextself,newnext):): self._nextself._next= =newnextnewnext2. 类类SinglelinkedList的初始

44、函数的初始函数class class SingleLinkedListSingleLinkedList(): (): defdef _ _initinit_(self):_(self): self._headself._head=None #=None #初始化链初始化链表为空表表为空表 self._sizeself._size=0 =0 3. 类类SinglelinkedList的的isEmpty()函数函数def isEmpty(self):def isEmpty(self): return self._head=None return self._head=None 4. 类类Singl

45、elinkedList的的add ()函数函数 def add(self,item): def add(self,item): temp=Node(item) temp=Node(item) temp.setNext(self._head) temp.setNext(self._head) self._head=temp self._head=temp 5. 类类SinglelinkedList的的append ()函数函数 def append(self,item): def append(self,item): temp=Node(item) temp=Node(item) if self

46、.isEmpty(): if self.isEmpty(): self._head=temp # self._head=temp #若为空表，将添加的元素若为空表，将添加的元素设为第一个元素设为第一个元素 else:else: current=self._head current=self._head while current.getNext()!=None: while current.getNext()!=None: current=current.getNext() # current=current.getNext() #遍历链表遍历链表 current.setNext(temp)

47、#current.setNext(temp) #此时此时currentcurrent为链为链表最后的元素表最后的元素6. 类类SinglelinkedList的的index ()函数函数defdef index( index(self,itemself,item):): current= current=self._headself._head count=0 count=0 found=None found=None while current!=None and not found: while current!=None and not found: count+=1 count+=1

48、if if current.getItemcurrent.getItem()=item:()=item: found=True found=True else: else: current= current=current.getNextcurrent.getNext()() if found: if found: return count return count else: else: raise raise ValueErrorValueError,%s is not in ,%s is not in linkedlistlinkedlist%item %item 7. 类类Single

49、linkedList的的remove()函数函数defdef remove( remove(self,itemself,item):): current= current=self._headself._head pre=None pre=None while current!=None: while current!=None: if if current.getItemcurrent.getItem()=item:()=item: if not pre: if not pre: self._headself._head= =current.getNextcurrent.getNext()(

50、) else: else: pre.setNextpre.setNext( (current.getNextcurrent.getNext()() break break else: else: pre=current pre=current current= current=current.getNextcurrent.getNext() () 8. 类类SinglelinkedList的的insert ()函数函数 defdef insert( insert(self,pos,itemself,pos,item):): if if pospos=1: self.sizeself.size(