数据结构代码学习笔记（持续更新中）
code_1：冒泡排序
1 def bubble_sort(alist): 2 """冒泡排序""" 3 n = len(alist) 4 for j in range(n-1): 5 for i in range(0,n-1-j): 6 if alist[i] > alist[i+1]: 7 alist[i], alist[i+1] = alist[i+1], alist[i] 8 print(alist) 9 return alist 10 11 12 if __name__ == "__main__": 13 list_01 = [1,4,2,7,3,9,6,5,8,0] 14 print(list_01) 15 print(bubble_sort(list_01))
code_2：链表逆序（插入法）
1 #-*- coding:utf-8 -*- 2 # username:MR 3 # 使用插入法实现链表的逆序 4 #主要思路是：从链表的第二个节点开始，把遍历到的节点插入到头节点的后面，直到遍历结束 5 6 class LNode: 7 """定义节点类""" 8 def __init__(self, x): 9 self.data = x 10 self.next = None 11 12 def Reverse(head): # head 表示头节点 13 # 判断链表是否为空 14 if head == None or head.next == None : 15 return 16 17 cur = None # 初始化当前节点 18 next = None # 初始化后继节点 19 cur = head.next.next # 设置第二个节点是当前节点 20 head.next.next = None #设置链表的第一个节点为尾节点 21 22 #把遍历到的节点插入到头节点的后面 23 while cur is not None: 24 next = cur.next #定义临时变量存储当前n节点的链接区地址 25 cur.next = head.next #把n节点的链接区指向新的地址，即第一个节点 26 head.next = cur #把头节点的链接区指向n节点，此时第n个节点已经被放到的第一个节点的位置 27 cur = next #定义新的cur位置，即n+1个节点 28 29 if __name__ == "__main__": 30 i = 1 31 #链表头节点 32 head = LNode(i) #定义头节点，数据区为i，链接区为None 33 head.next = None 34 tmp = None 35 cur = head #将头节点设置为当前节点 36 #构造单链表 37 while i<8: 38 tmp = LNode(i) #定义一个tmp节点 39 tmp.next = None #节点的链接区为空 40 cur.next = tmp #将当前节点的链接区指向tmp节点 41 cur = tmp #将tmp节点设置为当前节点，即游标向后移动一位 42 i += 1 43 print("逆序前的链表为：") 44 cur = head.next #重新设置第一个节点为当前节点 45 while cur!=None: 46 print(cur.data, end=" ") 47 cur = cur.next 48 print("\n逆序后的链表为：") 49 Reverse(head) #逆序链表 50 cur = head.next #重新设置第一个节点为当前节点 51 while cur!=None: 52 print(cur.data, end=" ") 53 cur = cur.next
code_3 ： 从无序的链表中删除重复项
1 #-*- coding:utf-8 -*- 2 # username:MR 3 # 给定一个无序的链表，去掉其中的重复项 4 5 6 # 定义节点类 7 class LNode: 8 def __init__(self, x): 9 self.data = x 10 self.next = None 11 12 13 # 方法一：递归法 14 # 主要思路：对于节点cur，首先递归地删除以cur.next为首的子链表中重复的节点，然后以cur.next为首的子链表中找到与cur有相同数据域的节点并删除 15 def removeDupRecursion(head): 16 if head.next == None: 17 return head 18 19 pointer = None 20 cur = head 21 22 # 对以head.next为首的子链表删除重复的节点 23 head.next = removeDupRecursion(head.next) 24 pointer = head.next 25 26 # 找出以head.next为首的子链表中与head节点相同的节点并删除 27 while pointer is not None: 28 if head.data == pointer.data: 29 cur.next = pointer.next 30 pointer = cur.next 31 else: 32 pointer = pointer.next 33 cur = cur.next 34 return head 35 36 """对带头节点的单链表删除重复的节点 37 输入参数： head：链表头节点""" 38 def removeDup_1(head): 39 if (head is None): 40 return 41 head.next = removeDupRecursion(head.next) 42 43 44 # 方法二：顺序删除 45 """ 主要思路：通过双重循环直接在链表上进行删除操作。外层循环用一个指针从第一个节点开始遍历整个链表，然后内层循环用另一个指针遍历其余节点, 46 将与外层循环遍历的指针所指节点的数据域相同的节点删除。 47 """ 48 def removeDup_2(head): 49 if head==None or head.next==None: 50 return 51 52 outerCur = head.next # 用于外层循环，指向链表的第一个节点 53 innerCur = None # 用于内层循环，用来遍历outerCur后面的节点 54 innerPre = None # innerCur的前驱节点 55 56 while outerCur != None: 57 innerCur = outerCur.next 58 innerPre = outerCur 59 while innerCur != None: 60 # 找到重复的节点并删除 61 if outerCur.data == innerCur.data: 62 innerPre.next = innerCur.next 63 innerCur = innerCur.next 64 else: 65 innerPre = innerCur 66 innerCur = innerCur.next 67 outerCur = outerCur.next 68 69 70 71 72 if __name__ == "__main__": 73 i = 1 74 head = LNode(i) 75 head.next = None 76 tmp = None 77 cur = head 78 while i<7: 79 tmp = LNode(i) 80 if i%2==0: 81 tmp.data = i+1 82 elif i%3==0: 83 tmp.data = i-2 84 else: 85 tmp.data = i 86 tmp.next = None 87 cur.next = tmp 88 cur = tmp 89 i += 1 90 print("逆序前的链表为：") 91 cur = head.next # 重新设置第一个节点为当前节点 92 while cur != None: 93 print(cur.data, end=" ") 94 cur = cur.next 95 print("\n删除重复节点后的链表为：") 96 removeDup_1(head) # 逆序链表 97 # removeDup_2(head) # 逆序链表 98 cur = head.next # 重新设置第一个节点为当前节点 99 while cur != None: 100 print(cur.data, end=" ") 101 cur = cur.next
code_4：用有序的列表模拟一个栈
1 #-*- coding:utf-8 -*- 2 # username:MR 3 4 class MyStack: 5 """利用有序列表模拟栈""" 6 # 定义一个空的栈 7 def __init__(self): 8 self.items = [] 9 # 判断栈是否为空 10 def isEmpty(self): 11 return len(self.items)==0 12 # 返回栈的大小 13 def size(self): 14 return len(self.items) 15 # 返回栈顶元素，把列表最后一个元素作为栈顶元素，这里只是返回，不删除 16 def top(self): 17 if not self.isEmpty(): 18 return self.items[len(self.items)-1] 19 else: 20 return None 21 # 弹栈，弹出列表中最后一个元素 22 def pop(self): 23 if len(self.items)>0: 24 return self.items.pop() 25 else: 26 print("栈已经为空") 27 return None 28 # 压栈，在列表的最后加入一个元素 29 def push(self,item): 30 self.items.append(item) 31 32 if __name__ == "__main__": 33 s = MyStack() 34 s.push(4) 35 s.push(5) 36 print("栈顶元素为:%s" % str(s.top())) 37 print("栈的大小为:%s" % str(s.size())) 38 s.pop() 39 print("弹栈成功") 40 s.pop()
code_5：用链表模拟一个栈
1 #-*- coding:utf-8 -*- 2 # username:MR 3 4 class LNode: 5 def __init__(self,x): 6 self.data = x 7 self.next = None 8 9 class MyStack: 10 def __init__(self): 11 # pHead = LNode() 12 self.data = None 13 self.next = None 14 # 判断stack是否为空，如果为空返回true，否则返回false 15 def empty(self): 16 if self.next == None: 17 return True 18 else: 19 return False 20 # 获取栈中的元素个数 21 def size(self): 22 size = 0 23 p = self.next 24 while p != None: 25 p = p.next 26 size += 1 27 return size 28 # 入栈：把e放到栈顶 29 def push(self,e): 30 p = LNode(e) 31 # p.data = e 32 p.next = self.next 33 self.next = p 34 # 出栈，同时返回该元素 35 def pop(self): 36 tmp = self.next 37 if tmp != None: 38 self.next = tmp.next 39 return tmp.data 40 # 取得栈顶元素 41 def top(self): 42 if self.next != None: 43 return self.next.data 44 print("栈已空") 45 return None 46 47 if __name__ == "__main__": 48 stack = MyStack() 49 stack.push(1) 50 stack.push(3) 51 print("栈顶元素为：%s" % str(stack.top())) 52 print("栈大小为：%s" % str(stack.size())) 53 stack.pop() 54 print("出栈成功") 55 stack.pop()
code_6：用数组实现一个队列
#-*- coding:utf-8 -*- # username:MR """队列：先入先出 用front记录首元素的位置，用rear记录尾元素后一个位置， 入列时只要将待入列的元素放入数组下标为rear的位置，同时将rear+1， 出列时只需要将front+1即可 """ class MyQueue: def __init__(self): self.arr = [] self.front = 0 self.rear = 0 # 判断队列是否为空 def isEmpty(self): return self.front==self.rear # 返回队列的大小 def size(self): return self.rear-self.front # 返回队列的首元素 def getFront(self): if self.isEmpty(): return None return self.arr[self.front] # 返回队列的尾元素 def getBack(self): if self.isEmpty(): return None return self.arr[self.rear-1] # 删除队列头元素（出列） def deQueue(self): if self.rear>self.front: self.front+=1 else: print("队列已经为空") # 把新元素加入到队列尾部（入列） def enQueue(self, item): self.arr.append(item) self.rear+=1 if __name__ == "__main__": queue = MyQueue() queue.enQueue(1) queue.enQueue(2) print("队列头元素为： %s" % str(queue.getFront())) print("队列尾元素为： %s" % str(queue.getBack())) print("队列的大小为： %s" % str(queue.size()))
code_7：翻转栈
#-*- coding:utf-8 -*- # username:MR # 先定义一个栈 class Stack: def __init__(self): self.items = [] # 判断栈是否为空 def empty(self): return len(self.items)==0 # 返回栈的大小 def size(self): return len(self.items) # 返回栈顶元素，把列表最后一个元素作为栈顶元素，这里只是返回，不删除 def peek(self): if not self.empty(): return self.items[len(self.items)-1] else: return None # 弹栈，弹出列表中最后一个元素 def pop(self): if len(self.items)>0: return self.items.pop() else: print("栈已经为空") return None # 压栈，在列表的最后加入一个元素 def push(self,item): self.items.append(item) """ 方法功能：把栈底元素移动到栈顶 参数：s栈的引用 """ def moveBottomToTop(s): if s.empty(): return top1 = s.peek() s.pop() # 弹出栈顶元素 if not s.empty(): # 递归处理不包含栈顶元素的子栈 moveBottomToTop(s) top2=s.peek() s.pop() # 交换栈顶元素与子栈栈顶元素 s.push(top1) s.push(top2) else: s.push(top1) def reverse_stack(s): if s.empty(): return # 把栈底元素移动到栈顶 moveBottomToTop(s) top=s.peek() s.pop() # 递归处理子栈 reverse_stack(s) s.push(top) if __name__ == "__main__": s=Stack() s.push(5) s.push(4) s.push(3) s.push(2) s.push(1) reverse_stack(s) print("翻转后出栈顺序为：") while not s.empty(): print(s.peek()) s.pop()
code_8：栈排序
1 #-*- coding:utf-8 -*- 2 # username:MR 3 4 # 先定义一个栈 5 class Stack: 6 def __init__(self): 7 self.items = [] 8 # 判断栈是否为空 9 def empty(self): 10 return len(self.items)==0 11 # 返回栈的大小 12 def size(self): 13 return len(self.items) 14 # 返回栈顶元素，把列表最后一个元素作为栈顶元素，这里只是返回，不删除 15 def peek(self): 16 if not self.empty(): 17 return self.items[len(self.items)-1] 18 else: 19 return None 20 # 弹栈，弹出列表中最后一个元素 21 def pop(self): 22 if len(self.items)>0: 23 return self.items.pop() 24 else: 25 print("栈已经为空") 26 return None 27 # 压栈，在列表的最后加入一个元素 28 def push(self,item): 29 self.items.append(item) 30 31 def moveBottomToTop(s): 32 if s.empty(): 33 return 34 top1=s.peek() 35 s.pop() 36 if not s.empty(): 37 moveBottomToTop(s) 38 top2=s.peek() 39 if top1>top2: 40 s.pop() 41 s.push(top1) 42 s.push(top2) 43 return 44 s.push(top1) 45 46 def sortStack(s): 47 if s.empty(): 48 return 49 # 把栈底元素移动到栈顶 50 moveBottomToTop(s) 51 top=s.peek() 52 s.pop() 53 # 递归处理子栈 54 sortStack(s) 55 s.push(top) 56 57 if __name__ == "__main__": 58 s=Stack() 59 s.push(1) 60 s.push(4) 61 s.push(3) 62 sortStack(s) 63 print("排序后出栈顺序为：") 64 while not s.empty(): 65 print(s.peek(),end=" ") 66 s.pop()
code_9：二叉树的实现与遍历
