栈

栈（stack）有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。
按照后进先出（LIFO, Last In First Out）的原理运作

栈结构的实现和操作

栈可以用：顺序表，链表实现

class Stack(object):
"""栈"""
def __init__(self):
self.items = []

def is_empty(self):
"""判断是否为空"""
return self.items == []

def push(self, item):
"""加入元素"""
self.items.append(item)

def pop(self):
"""弹出元素"""
return self.items.pop()

def peek(self):
"""返回栈顶元素"""
return self.items[len(self.items)-1]

def size(self):
"""返回栈的大小"""
return len(self.items)

队列

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出的（First In First Out）的线性表，简称FIFO。

队列操作

class Queue(object):
"""队列"""
def __init__(self):
self.items = []

def is_empty(self):
return self.items == []

def enqueue(self, item):
"""进队列"""
self.items.insert(0,item)

def dequeue(self):
"""出队列"""
return self.items.pop()

def size(self):
"""返回大小"""
return len(self.items)

双端队列

双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。

class Deque(object):
"""双端队列"""
def __init__(self):
self.items = []

def is_empty(self):
"""判断队列是否为空"""
return 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):
"""从队头删除元素"""
return self.items.pop(0)

def remove_rear(self):
"""从队尾删除元素"""
return self.items.pop()

def size(self):
"""返回队列大小"""
return len(self.items)

排序与搜索

排序算法的稳定性

稳定性：稳定排序算法会让原本有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。

冒泡排序

冒泡排序（英语：Bubble Sort）：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

def bubble_sort(alist):
for j in range(len(alist)-1,0,-1):
# j表示每次遍历需要比较的次数，是逐渐减小的
for i in range(j):
if alist[i] > alist[i+1]:
alist[i], alist[i+1] = alist[i+1], alist[i]

li = [54,26,93,17,77,31,44,55,20]
bubble_sort(li)
print(li)

选择排序

选择排序（Selection sort）：

1. 从第一个元素开始，依次跟后面元素比较，碰到比第一个小的元素，则选择状态修改为较小的元素，遍历一遍后选择出最小的元素放置到第一个。
2. 就按这个原则，遍历n-1遍。

def selection_sort(alist):
n = len(alist)
# 需要进行n-1次选择操作
for i in range(n-1):
# 记录最小位置
min_index = i
# 从i+1位置到末尾选择出最小数据
for j in range(i+1, n):
if alist[j] < alist[min_index]:
min_index = j
# 如果选择出的数据不在正确位置，进行交换
if min_index != i:
alist[i], alist[min_index] = alist[min_index], alist[i]

alist = [54,226,93,17,77,31,44,55,20]
selection_sort(alist)
print(alist)

插入排序

插入排序（英语：Insertion Sort）：

1. 先根据起始位置的两个元素比较大小，排除顺序
2. 依次从无序列表选择元素插入前面的有序列表中

def insert_sort(alist):
# 从第二个位置，即下标为1的元素开始向前插入
for i in range(1, len(alist)):
# 从第i个元素开始向前比较，如果小于前一个元素，交换位置
for j in range(i, 0, -1):
if alist[j] < alist[j-1]:
alist[j], alist[j-1] = alist[j-1], alist[j]

alist = [54,26,93,17,77,31,44,55,20]
insert_sort(alist)
print(alist)

• 点赞
• 收藏
• 分享
• 文章举报