概念
数据结构是计算机科学中的一个核心概念，它是指数据的组织、管理和存储方式，以及数据元素之间的关系。数据结构通常用于允许高效的数据插入、删除和搜索操作。
数据结构大致分为几大类：
线性结构：数组、链表、栈、队列等。
非线性结构：树、二叉树、堆、图等。
散列：哈希表。
索引：B树、B+树等。
常见数据结构：
栈：
栈（stack），它是一种运算受限的线性表，遵循后进先出（Last In First Out，LIFO）原则的数据结构。
LIFO(last in first out)表示就是后进入的元素, 第一个弹出栈空间. 类似于自动餐托盘, 最后放上的托盘, 往往先把拿出去使用.
其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；
从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
示例：
class Stack:
def __init__(self, size):
#通过数组实现栈的操作
self.items = []
self.size = size
#判断栈是否为满
def is_full(self):
return len(self.items) == self.size
#判断栈是否为空
def is_empty(self):
return len(self.items) == 0
#入栈，先判断栈是否已满，是则抛异常，否则在尾部添加元素
def push(self, item):
if self.is_full():
raise Exception('Stack is full!')
self.items.append(item)
#出栈，先判断是否为空，是则抛异常，否则删除尾部元素
def pop(self):
if self.is_empty():
raise Exception('Stack is empty!')
return self.items.pop()
#清除栈内所有元素
def clear(self):
self.items.clear()
#查询,返回最后一个元素
def peek(self):
if self.is_empty():
raise Exception('Stack is empty!')
return self.items[-1]
if __name__ == '__main__':
s = Stack(10)
s.push(1)
s.push(3)
s.push(2)
s.pop()
print(s.peek())
#3
链表：
链表是一条相互链接的数据节点表。每个节点由两部分组成：数据和指向下一个节点的指针。
优点：
-
物理存储单元上非连续，而且采用动态内存分配，能够有效的分配和利用内存资源；
-
节点删除和插入简单，不需要内存空间的重组。
缺点：
-
不能进行索引访问，只能从头结点开始顺序查找；
-
数据结构较为复杂，需要大量的指针操作，容易出错。
示例：
class Node:
def __init__(self, data = None):
if data is not None:
self.data = data
self.next = None
class LinkedList:
def __init__(self):
head = Node()
self.head = head
#头部插入
def head_insert(self,data):
new_node = Node(data)
#如果链表为空
if self.head.next is None:
self.head.next = new_node
#如果链表不为空
else:
new_node.next = self.head.next
self.head.next = new_node
#尾部插入
def tail_insert(self,data):
new_node = Node(data)
#如果链表为空
if self.head.next is None:
self.head.next = new_node
#如果链表不为空
else:
node = self.head.next
#判断数据节点后边是否还存在节点，如果存在节点则指针向后移动，否则认为是最后一个节点，将新节点连接到最后一个节点后边
while node.next is not None:
node = node.next
node.next = new_node
#删除链表节点
def node_delete(self,data):
if self.head.next is None:
raise Exception('LinkedList is empty!')
node = self.head
#判断数据节点是否为空，不为空则判断数据节点的data是否与要删除的data相等，是则删除，否则节点向后移动到下一个节点
while node.next is not None:
if node.next.data == data:
node.next = node.next.next
break
node = node.next
def show_LinkedList(self):
if self.head.next is None:
return None
node = self.head.next
while True:
print(node.data)
if node.next is None:
break
node = node.next
if __name__ == '__main__':
l = LinkedList()
l.head_insert(2)
l.head_insert(1)
l.tail_insert(3)
l.tail_insert(4)
l.node_delete(4)
l.show_LinkedList()
#1
#2
#3
队列：
队列(Queue)，它是一种运算受限的线性表,先进先出(FIFO First In First Out)
-
队列是一种受限的线性结构
-
受限之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作
queue.Queue 是 Python 标准库 queue 模块中的一个类，适用于多线程环境。它实现了线程安全的 FIFO（先进先出）队列。
双端队列（Deque，Double-Ended Queue）是一种具有队列和栈性质的数据结构，它允许我们在两端进行元素的添加（push）和移除（pop）操作。在Python中，双端队列可以通过collections模块中的deque类来实现。
deque是一个双端队列的实现，它提供了在两端快速添加和移除元素的能力。
优先队列（Priority Queue）是一种特殊的队列，其中的元素按照优先级进行排序。优先级最高的元素总是最先出队。Python 标准库中提供了 queue.PriorityQueue 和 heapq 模块来实现优先队列。
queue.PriorityQueue
queue.PriorityQueue 是 Python 标准库 queue 模块中的一个类，适用于多线程环境。它实现了线程安全的优先队列。
示例：
import queue
import heapq
from collections import deque
#python提供的普通队列
def func01():
q = queue.Queue()
q.put(1)
q.put(2)
q.put(3)
q.put(4)
q.get()
def func02():
q = deque()
q.append(1)
q.append(2)
q.append(3)
#append pop结合使用可以实现栈的操作
print(q.pop())
print(q.pop())
print(q.pop())
def func03():
#双端队列
q = deque()
#队列左端入队
q.appendleft(1)
print(q.popleft())
def func04():
#优先队列 按入队时的优先级进行排序，出队时按照优先级出队，优先级高的先出
q = queue.PriorityQueue()
#元组(priority,item)
q.put(2,'item2')
q.put(1,'item1')
q.put(3,'item3')
print(q.get())
print(q.get())
print(q.get())
'''
Queue、deque、priorityQueue都是线程安全的
heapq线程不安全，基于堆实现队列，堆时是共享资源，如果多线程同时访问共享资源，则会产生资源竞争，并没有采取措施解决资源竞争问题
'''
def func05():
#heapq:基于堆的优先队列
#使用数组实现
heap = []
#heappush将一个元组存入heap，元素格式为(priority,item)
heapq.heappush(heap,(1,'item1'))
heapq.heappush(heap,(3,'item3'))
heapq.heappush(heap,(2,'item2'))
#heappop从heap中出队
print(heapq.heappop(heap))
print(heapq.heappop(heap))
print(heapq.heappop(heap))
if __name__ == '__main__':
func05()
树：
树的定义:
-
树（Tree）: n（n≥0）个结点构成的有限集合。
-
当n=0时，称为空树；
-
对于任一棵非空树（n> 0），它具备以下性质：
-
树中有一个称为“根（Root）”的特殊结点，用 root 表示；
-
其余结点可分为m(m>0)个互不相交的有限集T1，T2，... ，Tm，其中每个集合本身又是一棵树，称为原来树的“子树（SubTree）”
注意:
-
子树之间不可以相交
-
除了根结点外，每个结点有且仅有一个父结点；
-
一棵N个结点的树有N-1条边。
-
树的术语:
-
1.结点的度（Degree）：结点的子树个数.
-
2.树的度：树的所有结点中最大的度数. (树的度通常为结点的个数N-1)
-
3.叶子结点（Leaf）：度为0的结点. (也称为叶子结点)
-
4.父结点（Parent）：有子树的结点是其子树的根结点的父结点
-
5.子结点（Child）：若A结点是B结点的父结点，则称B结点是A结点的子结点；子结点也称孩子结点。
-
6.兄弟结点（Sibling）：具有同一父结点的各结点彼此是兄弟结点。
-
7.路径和路径长度：从结点n1到nk的路径为一个结点序列n1 , n2,… , nk, ni是 ni+1的父结点。路径所包含边的个数为路径的长度。
-
8.结点的层次（Level）：规定根结点在1层，其它任一结点的层数是其父结点的层数加1。
-
9.树的深度（Depth）：树中所有结点中的最大层次是这棵树的深度。
二叉树：
二叉树的定义
-
二叉树可以为空, 也就是没有结点.
-
若不为空，则它是由根结点和称为其左子树TL和右子树TR的两个不相交的二叉树组成。
二叉树有五种形态:
-
注意c和d是不同的二叉树, 因为二叉树是有左右之分的.
二叉树有几个比较重要的特性, 在笔试题中比较常见:
-
一个二叉树第 i 层的最大结点数为：2^(i-1), i >= 1;
-
深度为k的二叉树有最大结点总数为： 2^k - 1, k >= 1;
-
对任何非空二叉树 T，若n0表示叶结点的个数、n2是度为2的非叶结点个数，那么两者满足关系n0 = n2 + 1。
-
满二叉树(Full Binary Tree）
-
在二叉树中, 除了最下一层的叶结点外, 每层节点都有2个子结点, 就构成了满二叉树.
完全二叉树(Complete Binary Tree)
-
除二叉树最后一层外, 其他各层的节点数都达到最大个数.
-
且最后一层从左向右的叶结点连续存在, 只缺右侧若干节点.
-
满二叉树是特殊的完全二叉树.
-
下面不是完全二叉树, 因为D节点还没有右结点, 但是E节点就有了左右节点.
遍历规则：
前序遍历，按照以下顺序访问节点：根节点、左子树、右子树。
中序遍历，按照以下顺序访问节点：左子树、根节点、右子树。
后序遍历，按照以下顺序访问节点：左子树、右子树、根节点。
二叉查找树：
二叉查找树（Binary Search Tree, BST）是一种特殊的二叉树，它具有以下性质：
-
每个节点都有一个键值（key）。
-
对于每个节点，其左子树中的所有节点的键值都小于该节点的键值。
-
对于每个节点，其右子树中的所有节点的键值都大于该节点的键值。
-
左子树和右子树也分别是二叉查找树。
-
二叉查找树不允许出现键值相等的结点。
插入操作的步骤：
-
如果树为空：直接将新节点作为根节点。
-
如果树不为空：
-
从根节点开始，根据新节点的键值与当前节点的键值的比较结果，决定向左子树还是右子树移动。
-
如果新节点的键值小于当前节点的键值，如果当前节点没有左子树，则将新节点插入到当前节点的左子树，否则向左子树移动。
-
如果新节点的键值大于当前节点的键值，如果当前节点没有右子树，则将新节点插入到当前节点的右子树，否则向右子树移动。
-
重复上述步骤，直到找到一个空位置，将新节点插入到该位置。
-
删除逻辑：
1.递归查找待删除节点
-
如果待删除节点的键值小于当前节点的键值，递归地在左子树中查找并删除。
-
如果待删除节点的键值大于当前节点的键值，递归地在右子树中查找并删除。
2.找到待删除节点
删除操作的步骤可以分为以下几种情况：
-
待删除节点是叶子节点（没有子节点）：直接删除该节点。
-
待删除节点只有一个子节点：用其子节点替换该节点。
-
待删除节点有两个子节点：
-
找到右子树中的最小节点（即后继节点）。
-
用后继节点的键值替换待删除节点的键值。
-
删除后继节点（后继节点要么是叶子节点，要么只有一个右子节点）。
-
假设我们有以下二叉搜索树：
50 / \ 30 70 / \ / \ 20 40 60 80
删除节点 20
-
找到键值为 20 的节点。
-
该节点是叶子节点，直接删除。
删除后的树：
50 / \ 30 70 \ / \ 40 60 80
删除节点 30
-
找到键值为 30 的节点。
-
该节点有一个右子节点 40，用 40 替换 30。
删除后的树：
50 / \ 40 70 / \ 60 80
删除节点 50
-
找到键值为 50 的节点。
-
该节点有两个子节点，找到右子树中的最小节点 60（即后继节点）。
-
用 60 替换 50。
-
删除右子树中的 60。
删除后的树：
60 / \ 40 70 \ 80
示例：
class TreeNode:
def __init__(self,key):
self.key = key
self.left = None
self.right =None
class BSTree:
def __init__(self):
self.root = None
def insert(self,key):
#如果树为空，直接将新节点作为根节点
if self.root is None:
self.root = TreeNode(key)
else:
self._insert(self.root,key)
def _insert(self,node,key):
#如果新的节点的键值小于当前节点的键值，如果当前节点，没有左子树，则将新节点插入到当前节点的左子树，否则向左子树移动
if key < node.key:
if node.left is None:
node.left = TreeNode(key)
else:
self._insert(node.left,key)
#如果新的节点的键值大于当前节点的键值，如果当前节点，没有右子树，则将新节点插入到当前节点的右子树，否则向右子树移动
elif key > node.key:
if node.right is None:
node.right = TreeNode(key)
else:
self._insert(node.right,key)
def search(self,key):
return self._search(self.root,key)
def _search(self,node,key):
if node is None or node.key == key:
return node
if key < node.key:
return self._search(node.left,key)
elif key > node.key:
return self._search(node.right,key)
def inorder(self):
result = []
self._inorder(self.root,result)
return result
def _inorder(self,node,result):
if node is not None:
self._inorder(node.left,result)
result.append(node.key)
self._inorder(node.right,result)
def preorder(self):
result = []
self._preorder(self.root,result)
return result
def _preorder(self,node,result):
if node is not None:
result.append(node.key)
self._preorder(node.left,result)
self._preorder(node.right,result)
def postorder(self):
result = []
self._postorder(self.root,result)
return result
def _postorder(self,node,result):
if node is not None:
self._postorder(node.left,result)
self._postorder(node.right,result)
result.append(node.key)
def delete(self,key):
self.root = self._delete(self.root,key)
def _delete(self,node,key):
if node is None:
return node
if key < node.key:
node.left = self._delete(node.left,key)
elif key > node.key:
node.right = self._delete(node.right,key)
else:
if node.left is None and node.right is None:
return None
elif node.left is None:
return node.right
elif node.right is None:
return node.left
#如果当前节点有两个子节点,就找右子树的最小值
else:
min_value_node = self._min_value_node(node.right)
node.key = min_value_node.key
node.right = self._delete(node.right,min_value_node.key)
return node
def _min_value_node(self,node):
current = node
while current.left is not None:
current = current.left
return current
if __name__ == '__main__':
bst = BSTree()
bst.insert(5)
bst.insert(3)
bst.insert(7)
bst.insert(4)
bst.insert(2)
print(bst.search(7).key)
bst.delete(7)
bst.delete(5)
res1 = bst.inorder()
print(res1)
# res2 = bst.preorder()
# print(res2)
# res3 = bst.postorder()
# print(res3)
#7
#[2, 3, 4]
扫一扫
3648
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
