python数据结构及算法
一. 数据结构与算法
1. 算法的概念：算法是独立存在的一种解决问题的方法和思想
2. 算法的特征：输入，输出，有穷性，确定性，可行性
3. 时间复杂度是实现算法程序所需要的时间，即算法的优劣
4. 数据结构是指数据对象中数据元素之间的关系
5. 程序 = 数据结构 + 算法
6. 算法是为了解决实际问题而设计的，数据结构是算法需要处理的问题载体
二. 顺序表
1. 顺序表：将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示
2. 元素的物理地址 = 首地址 + 元素下标 * 存储单元大小
3. 顺序表分为一体式结构和分离式结构
4. 元素存储区替换：一体式结构需要移动整个数据区；分离式结构只需要移动数据区域链接地址即可
三. 链表
1. 将元素存放在通过链接构造起来的一系列存储块中，在每个结点存放下一个结点的地址
2. 单链表：单链表包含两个域，一个信息域，一个链接域（指向下一个节点）
3. 信息域存放具体的数据，链接域存放下一个结点的地址
4. 单链表操作：
操作 | 功能 |
is_empty | 链表是否为空 |
length() | 链表长度 |
travel() | 遍历整个链表 |
add(item) | 链表头部添加元素 |
qppend(item) | 链表尾部添加元素 |
insert(位置,item) | 指定位置添加元素 |
remove(item) | 删除节点 |
search()item | *查找节点是否存在 |
5. 单向循环链表：在单链表的尾部增加了一个指向头结点的链接
6. 双向链表：每个节点都包括一个数据域和两个链接域（一个指向前驱节点，一个指向后继节点）
四. 栈
1. 特点：只允许在容器的一端进行加入数据和输出数据（后进先出）
2. 栈的操作：
操作 | 功能 |
stack() | 创建一个新的空栈 |
push(item) | 添加一个新的元素item到栈顶 |
pop() | 弹出栈顶元素 |
peek() | 返回栈顶元素 |
is_empty | 判断栈是否为空 |
size() | 返回栈的元素个数 |
五. 队列
1. 队列是只允许在一端进行插入操作，在另一端进行删除操作的线性表（先进先出）
2. 双端队列：可以在任意一端入队和出队
3. 队列操作：
操作 | 功能 |
Deque() | 创建一个空的双端队列 |
add_from(item) | 在队头加入一个item元素 |
add_rear(item) | 在队尾加入一个item元素 |
remove_rear() | 在队尾删除一个item元素 |
is_empty | 判断双端队列是否为空 |
size() | 返回队列大小 |
六. 排序与搜索
排序算法是一种能将一串数字依照特定的顺序排列的一种算法
1. 冒泡排序
方法：把数组从前往后，两两比较，较大的数放在最后一位；每轮得到一个最大值且不参与下一轮排序，直到所有数字排序完毕
稳定性：稳定
代码如下：
def bubble_sort(alist):
"""冒泡排序"""
n = len(alist)
for j in range(n-1):
count = 0
for i in range(0,n-1):
"""序列从头走到尾"""
if alist[i] > alist[i+1]:
alist[i],alist[i+1] = alist[i+1],alist[i]
count += 1
if 0 == count:
return2. 选择排序
方法：每一轮找出一个最小值与第一个数交换，第二轮在除了第一个数外其余数里找一个最小的与第二个数交换，依此类推
稳定性：不稳定
代码如下：
def select_sort(alist):
"""选择排序"""
n = len(alist)
for j in range(n-1):
min_index = j
for i in range(j,n):
if alist[min_index] > alist[i]:
min_index = i
alist[j],alist[min_index] = alist[min_index],alist[j]3. 插入排序
方法：第一轮在前两个数种寻找最小值插入到第一个数，第二轮从前三个数里找最小值插入到第一个数，依此类推
稳定性：稳定
代码如下：
def insert_sort(alist):
"""插入排序"""
n = len(alist)
for j in range(1,n):
i = j
while i > 0:
if alist[i] < alist[i-1]:
alist[i],alist[i-1] = alist[i-1],alist[i]
i -= 1
else:
break4. 快速排序
方法：首先，把第一个数设置为基数，使用high和low下标，low在头（但不指向基数），high在尾，向中间移动，移动规则为low向后移动，遇到比基数大的停止，high遇到比基数小的停止，当high和low都停止时，二者交换，继续往中间移动，直到二者重合，把基数插入到重合点前；第二轮把数列以基数为中心分为两部分，继续进行相同操作
稳定性：不稳定
代码如下：
def quick_sort(alist,first,last):
"""快速排序"""
if first >= last:
return
mid_value = alist[first]
low = first
high = last
while low < high:
while low < high and alist[high] >= mid_value:
high -= 1
alist[low] = alist[high]
while low < high and alist[low] < mid_value:
low += 1
alist[high] = alist[low]
alist[low] = mid_value
quick_sort(alist,first,low-1)
quick_sort(alist,low+1,last)5. 希尔排序
方法：第一轮将数列分为以n//2为一组，每部分的对应位置进行插入排序；第二轮分为n//2//2部分，继续进行相同操作，直到分成n部分
稳定性：不稳定
代码如下：
def shell_sort(alist):
"""希尔排序"""
n = len(alist)
gap = n//2
while gap > 0:
for j in range(gap,n):
i=j
while i>0:
if alist[i] < alist[i-gap]:
alist[i],alist[i-gap] = alist[i-gap],alist[i]
i -= gap
else:
break
gap //= 26. 归并排序
方法：把数组先分为n/2为一组，再分为n/2/2为一组，直到n/n为一组，再把数字两两合并，第一次合并时，合并成2个为一组，根据左下标和右下标比较，较小的数先输出，直到一组数据为空，另一组数直接插入，第二次合并时，合并成4个为一组，直到一组数为空
稳定性：稳定
代码如下：
def merge_sort(alist):
"""归并排序"""
n = len(alist)
if n<=1:
return alist
mid=n//2
left_li=merge_sort(alist[:mid])
right_li=merge_sort(alist[mid:])
left_pointer,right_pointer=0,0
result=[]
while left_pointer < len(left_li) and right_pointer < len(right_li):
if left_li[left_pointer] < right_li[right_pointer]:
result.append(left_li[left_pointer])
left_pointer+=1
else:
result.append(right_li[right_pointer])
right_pointer+=1
result+=left_li[left_pointer:]
result+=right_li[right_pointer:]
return result7. 搜索
二分查找也叫折半查找，只能作用到顺序表
特点：比较次数少，速度快
七. 树与树算法
度：一个节点含有的子树的个数
树的度：最大的节点含有的子树的个数
节点的层次：从根开始定义，根为第一层，跟的子节点为第二层，依此类推
有序树分为：二叉树，霍夫曼树，B树
1. 二叉树
分类：二叉树分为完全二叉树，满二叉树，平衡二叉树（子树层次相差不大于1），排序二叉树（左小右大）
性质：在二叉树的第i层上至多有2^(i-1)个节点;
深度为k的二叉树至多有2^k-1个节点;
对于任意一颗二叉树，如果其叶子节点数为NO，而度数为2的节点总数为N2，则NO=N2+1;
具有n个节点的完全二叉树的深度为log2(n+1)
2. 树的遍历
分类：先序遍历；中序遍历；后序遍历
先序遍历先遍历根节点，再遍历左子树，再遍历右子树
中序遍历先遍历左子树，再遍历根节点，再遍历右子树
后序遍历先遍历左子树，再遍历右子树，再遍历根节点
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
