目录
- 1、栈
- 1.1 栈的介绍
- 1.2 栈的代码实现
- 2、队列
- 2.1 队列的介绍
- 2.2 队列的代码实现
- 3、双端队列
- 4、数据结构与算法_排序算法
- 4.1 排序算法的稳定性
- 4.2 冒泡排序
- 4.3 选择排序
- 4.4 插入排序
- 4.5 快速排序
1、栈
1.1 栈的介绍
栈：运算受限的线性表，其限制是仅允许在表的一端进行插入和删除运算，这一端为栈顶，另一端为栈底。特点：先进后出
栈是计算机系统CPU结构里的一部分
栈的作用：局部变量的方便存储和及时销毁
1.2 栈的代码实现
借助链表
所以选择尾部进行增删操作
class Stack(object):
"""栈：先进后出"""
def __init__(self):
self.__items = []
def push(self):
"""进栈"""
self.__items.append(item)
def pop(self):
"""出栈"""
self.__items.pop()
def trave(self):
"""遍历"""
for i in self.__items:
print(i)
my_stack = Stack()
my_stack.push(1)
my_stack.push(1)
my_stack.push(1)
my_stack.trave() #输出1\n 2\n 3\n
#出栈
my_stack.pop()
my_stack.trave() #输出1\n 2\n
2、队列
2.1 队列的介绍
队列：一种特殊的线性表，特殊之处在于它只允许表的头部进行删除操作，表的尾部进行插入操作，是一种操作受限制的线性表，进行插入操作的端为队尾，进行删除操作的端为队头
队列的作用：任务处理类系统（多个任务发起，先存储起来，排队一个一个进行处理，起到了缓冲压力的作用）
2.2 队列的代码实现
此时选择对头队尾，复杂度都一样了，o(1)+o(n)
Class Queue(object):
def __init__(self):
#存储数据，线性表
self.items = []
#enqueue(item)队列尾部添加元素
def enqueue(self,item):
self.items.append(item)
#dequeue(item)队列头添加元素
def dequeue(self,item):
self.items.pop(0)
#is_empty()判断队列是否为空
def is_empty()(self):
return self.items == []
#size()返回队列的大小
def size(self):
return len(self.items)
q = Queue()
#添加数据
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
for i in q.items:
print(i) #输出：1\n2\n3\n
#删除数据
q.dequeue()
for i in q.items:
print(i) #输出：2\n3\n
print(q.is_empty())
print(q.size())
3、双端队列
双端队列：是一种具有队列和栈的数据结构。元素可以任意从两端进行插入和删除操作。
Class Deque(object):
def __init__(self):
self.items = []
def is_empty(self): #判断是否为空
return self.items == []
def size(self): #大小
return len(self.items)
def add_front(self,item): #头部添加数据
self.items.insert(0,item)
def add_rear(self,item): #尾部添加数据
self.items.append(item)
def remove_front(self,item): #头部删除数据
self.items.pop(0)
def remove_rear(self,item): #尾部删除数据
self.items.pop()
deque = Deque()
print(deque.is_empty())
print(deque.size())
#添加数据
deque.add_front(1)
deque.add_front(2)
deque.add_rear(3)
deque.add_rear(4)
for i in q.items:
print(i) #输出：2\n1\n3\n4\n
#删除数据
deque.remove_front()
deque.remove_rear()
for i in q.items:
print(i) #输出：1\n3\n
4、数据结构与算法_排序算法
4.1 排序算法的稳定性
排序：使得一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来
排序算法：如何使得这一串记录按照要求排列的方法
算法的稳定性：
对于具有相同的关键词的记录，他们的相对次序不变，即这种算法是稳定的，否则是不稳定的
不稳定的排序算法：选择排序、快速排序、希尔排序、堆排序
稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序
4.2 冒泡排序
冒泡排序：重复地走访过要排序的元素列，依次比较两个相邻的元素，如果元素排序错误就交换过来。重复进行直到没有相邻元素需要交换为止
代码实现：
def bubble_sort(alist):
"""冒泡排序"""
n=len(alist)
for j in range(0,n-1):
count =0
for i in range(0,n-j-1): #控制每一轮的比较次数
#比较相邻两数字，不符合要求便交换位置
if alist[i]>alist[i+1]:
alist[i],alist[i+1] =alist[i+1],alist[i]
count +=1
if count == 0: #如果遍历一轮后没有数字交换，就退出循环，防止浪费资源
break
if __name__ == '__main__':
alist = [5,3,4,7,2]
bubble_sort(alist)
print(alist)
冒泡排序：
时间复杂度：o(n^2)
最优时间复杂度 ：o(n) 最少也需要遍历一遍
算法稳定性：稳定算法 （if alist[i]>alist[i+1]中如果是>= ,则不是稳定算法）
4.3 选择排序
选择排序：第一次从待排序的数据元素中选出最小（大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，放到已排序的序列末尾，依次类推，直到全部排序完
def select_sort(alist):
"""选择排序"""
n = len(alist) #列表的长度
for j in range(0,n):
min_index = j #假定的最小值下标
for i in range(j+1,n):
if alist[i] < alist[min_index]: #进行比较获得最小值的下标
min_index = i
if min_index !=j:
alist[min_index],alist[j] = alist[j],alist[min_index]
if __name__ == '__main__':
alist = [1,5,3,4,7,2]
select_sort(alist)
print(alist)
选择排序：
时间复杂度：o(n^2)
最优时间复杂度 ：o(n^2)
算法稳定性：不稳定算法
4.4 插入排序
插入排序：将一个数据插入到已经排好序的有序数据中，从而得到一个新的，个数加一的有序数据，算法适用于少量数据的排序。排序时将第一个数作为有序数据
def insert_sort(alist):
"""插入排序"""
n = len(alist) #列表长度
for j in range(1,n): #控制轮数
for i in range(j,0,-1):#找到合适的位置安放我们的无序数据[j,j-1,j-2,...1]
if alist[i]<alist[i-1]:
alist[i],alist[i-1] =alist[i-1],alist[i]
else:
break
if __name__ == '__main__':
alist = [1,5,3,4,7,2]
insert_sort(alist)
print(alist)
插入排序：
时间复杂度：o(n^2) – 降序数据变成升序
最优时间复杂度 ：o(n) – 原本就是升序数据
算法稳定性：稳定算法 （if alist[i]<alist[i+1]中如果是<= ,则不是稳定算法）
4.5 快速排序
def quick_sort(alist,start,end):
"""快速排序"""
#递归的结束条件
if start>=end:
return
#界限值
mid = alist[start]
#左右游标
left = start
right = end
while left <right:
while alist[right]>=mid and left<right : #从右边开始找寻小于mid的值，归类到左边
right -=1
slist[left] = alist[right]
while alist[left]<mid and left<right:
left +=1
slist[right] = alist[left]
#循环一旦结束了，证明找到了mid应该在的位置
alist[left] = mid
#递归操作
quick_sort(alist,start,left-1)
quick_sort(alist,right+1,end)
if __name__ == '__main__':
alist = [1,5,3,4,7,2]
quick_sort(alist,0,len(alist)-1)
print(alist)
快速排序：
时间复杂度：o(n^2)
最优时间复杂度 ：o(nlogn)
算法稳定性：不稳定算法
