1.python数据结构及算法基础学习笔记思维导图
2.程序代码演示
1.链表模型：linklist.py
1 """ 2 功能: 实现单链表的构建和操作 3 4 """ 5 6 # 创建节点类 7 class Node: 8 """ 9 思路 : *自定义类视为节点类,类中的属性为数据内容 10 *写一个next属性,用来和下一个 节点建立关系 11 """ 12 def __init__(self,val,next = None): 13 """ 14 val: 有用数据 15 next: 下一个节点引用 16 """ 17 self.val = val 18 self.next = next 19 20 21 # 链式线性表操作类 22 class LinkList: 23 """ 24 思路 : 生成单链表,通过实例化的对象就代表一个链表 25 可以调用具体的操作方法完成各种功能 26 """ 27 def __init__(self): 28 # 链表的初始化节点,没有有用数据,但是便于标记链表的开端 29 self.head = Node(None) 30 31 # 初始化链表,添加一组节点 32 def init_list(self,list_): 33 p = self.head # p 作为移动变量 34 for i in list_: 35 # 遍历到一个值就创建一个节点 36 p.next = Node(i) 37 p = p.next 38 39 # 遍历链表 40 def show(self): 41 p = self.head.next # p代表第一个有值的节点 42 while p is not None: 43 print(p.val) 44 p = p.next # p向后移动 45 46 # 判断链表为空 47 def is_empty(self): 48 if self.head.next is None: 49 return True 50 else: 51 return False 52 53 # 清空链表 54 def clear(self): 55 self.head.next = None 56 57 # 尾部插入 58 def append(self,val): 59 p = self.head 60 # p移动到最后一个节点 61 while p.next is not None: 62 p = p.next 63 p.next = Node(val) # 最后添加节点 64 65 # 头部插入 66 def head_insert(self,val): 67 node = Node(val) 68 node.next = self.head.next 69 self.head.next = node 70 71 # 指定位置插入 72 def insert(self,index,val): 73 # 设置个p 移动到待插入位置的前一个 74 p = self.head 75 for i in range(index): 76 # 如果index超出了最大范围跳出循环 77 if p.next is None: 78 break 79 p = p.next 80 # 插入节点 81 node = Node(val) 82 node.next = p.next 83 p.next = node 84 85 # 删除节点 86 def remove(self,val): 87 p = self.head 88 # p 移动,待删除节点上一个 89 while p.next is not None and p.next.val != val: 90 p = p.next 91 92 if p.next is None: 93 raise ValueError("x not in linklist") 94 else: 95 p.next = p.next.next 96 97 98 # 获取某个节点的值 (通过索引获取) 99 def search(self,index): 100 if index < 0: 101 raise IndexError("index out of range") 102 103 p = self.head.next 104 # 循环移动p 105 for i in range(index): 106 if p is None: 107 raise IndexError("index out of range") 108 p = p.next 109 return p.val 110 111 112 if __name__ == "__main__": 113 # 想有一个链表 114 link = LinkList() 115 # 初始化一组数据 116 l = [1,2,3,4] 117 link.init_list(l) 118 # link.clear() 119 print(link.search(0)) 120 # 链表遍历 121 # link.show() 122 # link.insert(2,88) 123 # link.show() 124 # link.clear() 125 # print(link.is_empty()) 126 # Abby = Node((1,'Abby',18,'w')) 127 # Emma = Node((2,'Emma',17,'w')) 128 # Alex = Node((3,'Alex',19,'m')) 129 # Abby.next = Emma 130 # Emma.next = Alex
2.栈的顺序存储：sstack.py
""" 栈模型的顺序存 思路 : 1. 顺序存储可以使用列表实现,但是列表功能丰富,不符合栈模型要求 2. 将列表功能封装,实现顺序栈的类,只提供栈的操作功能 功能: 出栈, 入栈,判断栈空,查看栈顶元素 """ # 自定义异常 class StackError(Exception): pass # 顺序栈 class SStack: def __init__(self): # 空列表就是栈的存储空间 # 列表的最后一个元素作为栈顶元素 self.__elems = [] # 入栈 def push(self,val): self.__elems.append(val) # 判断栈空 def is_empty(self): return self.__elems == [] # 出栈 def pop(self): if self.is_empty(): raise StackError("pop from empty stack") return self.__elems.pop() # 查看栈顶 def top(self): if self.is_empty(): raise StackError("pop from empty stack") return self.__elems[-1] if __name__ == '__main__': st = SStack() st.push(10) st.push(20) st.push(30) while not st.is_empty(): print(st.pop()) st.pop()
3.栈的链式存储：lstack.py
1 """ 2 栈的链式模型 3 4 思路: 5 1. 通过节点存储数据达到链式存储的目的 6 2. 封装方法,实现栈的基本操作(入栈,出栈,栈空,查看栈顶) 7 3. top为栈顶,在链表的头作为栈顶位置 (不许要遍历) 8 """ 9 10 # 自定义异常 11 class StackError(Exception): 12 pass 13 14 # 节点类 15 class Node: 16 def __init__(self,val,next = None): 17 self.val = val 18 self.next = next 19 20 # 链式栈模型 21 class LStack: 22 def __init__(self): 23 # top作为栈顶的标记 24 self.__top = None 25 26 def is_empty(self): 27 return self.__top is None 28 29 # 入栈 30 def push(self,val): 31 self.__top = Node(val,self.__top) 32 33 # node = Node(val) 34 # node.next = self.__top 35 # self.__top = node 36 37 # 出栈 38 def pop(self): 39 if self.__top is None: 40 raise StackError("pop from empty stack") 41 data = self.__top.val 42 self.__top = self.__top.next 43 return data 44 45 # 查看栈顶元素 46 def top(self): 47 if self.__top is None: 48 raise StackError("pop from empty stack") 49 return self.__top.val 50 51 52 if __name__ == '__main__': 53 ls = LStack() 54 ls.push(10) 55 ls.push(20) 56 ls.push(30) 57 print(ls.pop()) 58 print(ls.pop())
4.队列的顺序存储：squeue.py
1 """ 2 队列的顺序存储 3 4 思路 : 5 1. 基于列表完成数据存储 6 2. 对列表功能进行封装 7 3. 列表的头部作为队头,尾部作为队尾 8 功能: 入队(enqueue),出队(dequeue),判断队列为空 9 """ 10 11 # 自定义异常 12 class QueueError(Exception): 13 pass 14 15 class SQueue: 16 # 设置空列表作为队列存储空间 17 def __init__(self): 18 self.__elems = [] 19 20 # 判断队列是否为空 21 def is_empty(self): 22 return self.__elems == [] 23 24 # 入队 25 def enqueue(self,val): 26 self.__elems.append(val) 27 28 # 出对 29 def dequeue(self): 30 if not self.__elems: 31 raise QueueError("Queue is empty") 32 return self.__elems.pop(0) 33 34 if __name__ == '__main__': 35 sq = SQueue() 36 37 sq.enqueue(10) 38 sq.enqueue(20) 39 sq.enqueue(30) 40 41 while not sq.is_empty(): 42 print(sq.dequeue())
5.队列的链式存储：lqueue.py
1 """ 2 链式队列 3 4 思路: 5 1. 基于链表构建队列模型 6 2. 链表的开端作为队头, 结尾作为队尾 7 3. 对头队尾分别添加标记,避免每次插入数据都遍历链表 8 4. 队头和队尾重叠时认为队列为空 9 """ 10 11 # 自定义异常 12 class QueueError(Exception): 13 pass 14 15 # 节点类 16 class Node: 17 def __init__(self,val,next = None): 18 self.val = val 19 self.next = next 20 21 # 队列操作 22 class LQueue: 23 def __init__(self): 24 # 定义队头,队尾 25 self.front = self.rear = Node(None) 26 27 def is_empty(self): 28 return self.front == self.rear 29 30 # 如队 rear动 31 def enqueue(self,val): 32 self.rear.next = Node(val) 33 self.rear = self.rear.next 34 35 # 出队 front动 36 def dequeue(self): 37 if self.front == self.rear: 38 raise QueueError("Queue is empty") 39 40 # front移动到的节点已经出队 41 self.front = self.front.next 42 return self.front.val 43 44 if __name__ == '__main__': 45 lq = LQueue() 46 lq.enqueue(10) 47 lq.enqueue(20) 48 lq.enqueue(30) 49 print(lq.dequeue())
6.递归函数：recursion.py
1 """ 2 求一个数的阶乘 n! 3 """ 4 5 def fun(n): 6 result = 1 7 for i in range(1, n + 1): 8 result *= i 9 return result 10 11 12 def recursion(n): 13 if n <= 1: 14 return 1 15 return n * recursion(n - 1) 16 17 18 print(fun(5)) 19 print(recursion(5))
7.二叉树的链式存储：btree.py
1 """ 2 二叉树的遍历实践 3 4 思路分析: 5 1. 使用链式结构存储二叉树的节点数据 6 2. 节点中存储 数据, 左孩子链接,右孩子链接 三个属性 7 """ 8 from squeue import * 9 10 # 二叉树节点类 11 class Node: 12 def __init__(self,val,left=None,right=None): 13 self.val = val 14 self.left = left 15 self.right = right 16 17 # 二叉树遍历方法 18 class Bitree: 19 def __init__(self,root): 20 self.root = root 21 22 # 先序遍历 23 def preOrder(self,node): 24 if node is None: 25 return 26 print(node.val) 27 self.preOrder(node.left) 28 self.preOrder(node.right) 29 30 # 中序遍历 31 def inOrder(self, node): 32 if node is None: 33 return 34 self.inOrder(node.left) 35 print(node.val) 36 self.inOrder(node.right) 37 38 # 后序遍历 39 def postOrder(self, node): 40 if node is None: 41 return 42 self.postOrder(node.left) 43 self.postOrder(node.right) 44 print(node.val) 45 46 # 层次遍历 47 def levelOrder(self,node): 48 """ 49 node先入队,循环判断,队列不为空时,出队表示遍历, 50 同时让出队元素的左右孩子入队 51 """ 52 sq = SQueue() 53 sq.enqueue(node) 54 while not sq.is_empty(): 55 node = sq.dequeue() 56 print(node.val) # 遍历元素 57 if node.left: 58 sq.enqueue(node.left) 59 if node.right: 60 sq.enqueue(node.right) 61 62 63 64 if __name__ == '__main__': 65 b = Node('B') 66 f = Node('F') 67 g = Node('G') 68 d = Node('D',f,g) 69 h = Node('H') 70 i = Node('I') 71 e = Node('E',h,i) 72 c = Node('C',d,e) 73 a = Node('A',b,c) # 整个树根 74 75 bt = Bitree(a) # 把a作为根节点进行遍历 76 77 bt.preOrder(bt.root) 78 print("========================") 79 bt.inOrder(bt.root) 80 print("========================") 81 bt.postOrder(bt.root) 82 print("========================") 83 bt.levelOrder(bt.root)
8.排序算法选择、冒泡、插入、归并、快速排序：sort.py
1 def selection_sort(arr): 2 """ 3 1.选择排序：外层循环一次，就可排好一个数,从前往后排。 4 用选定元素与其后的所有元素进行比较，较大（小）交换 5 """ 6 for i in range(len(arr) - 1): # 需要比较n-1轮 7 for j in range(i + 1, len(arr)): # 每一轮需要比较j次 8 if arr[i] > arr[j]: # 升序排列 9 arr[i], arr[j] = arr[j], arr[i] 10 11 12 def buble_sort(arr): 13 """ 14 2.冒泡排序：外层循环一次，就可排好最后一个数,从后往前排。 15 所有相邻元素依次进行比较，较大（小）交换 16 """ 17 for i in range(len(arr) - 1): # 需要比较n-1轮 18 for j in range(len(arr) - 1 - i): # 每轮比较中，索引j的取值0到(n-1)-i 19 if arr[j] > arr[j + 1]: 20 arr[j], arr[j + 1] = arr[j + 1], arr[j] 21 22 23 def insert_sort(arr): 24 """ 25 3.插入排序：将第一个元素看做有序序列，从后向前扫描有序序列，将为排序元素依次插入对应位置 26 """ 27 for i in range(1, len(arr)): # 只需要对第二个到最后一个元素进行排序 28 preindex = i - 1 29 current = arr[i] 30 while preindex >= 0 and arr[preindex] > current: 31 arr[preindex + 1] = arr[preindex] # 将前一个元素赋值给当前元素位置上 32 preindex -= 1 33 arr[preindex + 1] = current # 将当前元素赋值给“对应”位置上 34 35 36 def merge_sort(arr): 37 """ 38 4.归并排序：递归的将arr一分为二的拆分为一个二叉树（每个叶子节点只有一个数）， 39 定义空列表result=[]，回归的将叶子结点合并到result中，回归到根节点 40 """ 41 if len(arr) < 2: 42 return arr # 递归结束条件：拆分后的最终列表中只有一个元素 43 middle = len(arr) // 2 44 left, right = arr[:middle], arr[middle:] 45 return merge(merge_sort(left), merge_sort(right)) 46 47 48 def merge(left, right): 49 result = [] 50 while left and right: # 回归阶段：将左右子节点合并到父节点 51 if left[0] <= right[0]: 52 result.append(left.pop(0)) 53 else: 54 result.append(right.pop(0)) 55 while left: 56 result.append(left.pop(0)) 57 while right: 58 result.append(right.pop(0)) 59 return result 60 61 62 def quick_sort(arr): 63 """ 64 5.快速排序：选定第一个元素为基准，将后面的元素“依次”与基准比较， 65 较大的放基准右边区域，较小的放基准左边区域。 66 递归的对左右区域进行分区操作，直至该区域中只有一个元素了 67 """ 68 sort(arr, 0, len(arr) - 1) 69 70 71 def sort(arr, left, right): 72 if left >= right: # 递归终止条件：被分区区域内只有1个元素了 73 return 74 pivot = partition(arr, left, right) 75 # 递归的进行分区 76 sort(arr, left, pivot - 1) 77 sort(arr, pivot + 1, right) 78 79 80 # 分区，返回基准值的索引 81 def partition(arr, left, right): 82 pivotkey = arr[left] # 选定第一个元素为基准值 83 while left < right: 84 while arr[right] >= pivotkey and right > left: 85 right -= 1 86 arr[left] = arr[right] # 小于基准值的元素放到左边区域：小的往前甩 87 while arr[left] < pivotkey and left < right: 88 left += 1 89 arr[right] = arr[left] # 大于等于基准值的元素放到右边区域：大的往后甩 90 arr[left] = pivotkey 91 return left 92 93 94 arr = [9, 8, 7, 6, 5, 4, 3, 2, 1] 95 # selection_sort(arr) 96 # buble_sort(arr) 97 # insert_sort(arr) 98 # print(merge_sort(arr)) 99 quick_sort(arr) 100 print(arr)
9.二分法查找：search.py
1 def search(l,val): 2 low,high = 0,len(l) - 1 # 查找范围的开始和结束索引位 3 # 循环查找,每次去除一半 4 while low <= high: 5 mid = (low + high) // 2 # 中间数索引 6 if l[mid] < val: 7 low = mid + 1 8 elif l[mid] > val: 9 high = mid - 1 10 else: 11 return mid 12 13 14 l = [1,2,3,4,5,6,7,8,9,10] 15 print("Key index:",search(l,666))
