栈+队列+双端队列的代码实现+排序算法的稳定性+冒泡排序+选择排序+插入算法

栈

实质上就是一种容器，可以存放数据元素、访问元素、删除元素

栈数据结构只允许在一端进行操作，按照后进先出（LIFO）的原理操作。

栈描述的数据如何操作，而顺序表描述的是数据如何存储

#压栈
class Stack(object):

    def __init__(self):
        self.__list = []


    def push(self, item):
        ''' 添加一个新元素，item到栈顶'''
        self.__list.append(item)
        #使用顺序表来保存数据的话，就用尾部添加的方式
        #self.__list.insert(0, item)  从头部添加，如果是链表机构，可以采用头插法，时间复杂度较低

    def pop(self):
        '''弹出栈顶元素'''
        return self.__list.pop()
        #self.__list.pop(0) #从头部添加的就从头部开始取，后进先出原则

    def peek(self):
        '''返回栈顶元素'''
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def is_empty(self):
        ''' 判断栈是否为空'''
        return self.__list == [] #如果列表为空则返回False，如果列表不为空则返回True
        #等同于 return not self.__list


    def size(self):
        '''返回栈的元素个数'''
        return len(self.__list)


if __name__ == "__main__":
    s = Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    s.push(5)
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())

队列

队列是指允许从一端进行插入操作，在另一端进行删除操作的线性表。

队列是一种先进先出的线性表，遵循（FIFO）原理

class Queue(object):
    '''队列'''
    def __init__(self):
        self.__list = [] #空列表用来保存队列的数据，把数据的存储形式构造出来

    def enqueue(self,item):
        '''队列中添加一个item元素'''
        self.__list.append(item) #尾插法
        #self.__list.insert(0,item) 头插法


    def dequeue(self):
        '''从队列头部删除一个元素'''
        return self.__list.pop(0)
        #在队尾添加元素，在队头取元素，因为队列是先进先出的原则
        #self.__list.pop() 从尾部弹出


    def is_empty(self):
        '''判断一个队列是否为空'''
        return self.__list == []



    def size(self):
        '''返回队列的大小'''
        return len(self.__list)


if __name__ == "__main__":
    s = Queue()
    s.enqueue(1)
    s.enqueue(2)
    s.enqueue(3)
    s.enqueue(4)
    s.enqueue(5)
    print(s.dequeue())
    print(s.dequeue())
    print(s.dequeue())
    print(s.dequeue())
    print(s.dequeue())

'''
1
2
3
4
5
'''

双端队列

双端队列，是一种具有队列和栈的性质的数据结构

class Dqueue(object):
    '''双端队列'''
    def __init__(self):
        self.__list = [] #空列表用来保存队列的数据，把数据的存储形式构造出来

    def add_front(self,item):
        '''队列中从头部添加一个item元素'''
        self.__list.insert(0, item)
        #双端的头尾是由我们自己定义的


    def add_rear(self, item):
        '''队列中从尾部添加一个item元素'''
        self.__list.append(item)


    def pop_front(self):
        '''从队列头部删除一个元素'''
        return self.__list.pop(0)
        #在队尾添加元素，在队头取元素，因为队列是先进先出的原则
        #self.__list.pop() 从尾部弹出

    def pop_rear(self):
        '''从队列尾部删除一个元素'''
        return self.__list.pop()


    def is_empty(self):
        '''判断一个队列是否为空'''
        return self.__list == []



    def size(self):
        '''返回队列的大小'''
        return len(self.__list)

排序与搜索

排序算法是一种能将一串数据依照稳定顺序进行排列的算法

排序算法的稳定性

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

冒泡排序

（1）冒泡排序的分析

走一遍先对比相邻两个数的大小，把这两个相邻数按照从小到大的顺序排列，走一遍之后只能把这几个数里的最大值排到最后，但是其他序列还是混乱的， 需要还需要再走一遍，把剩余的数的最大值排在倒数第二位，然后继续，go on，要做n-1次数

（2）算法实现

可以先写内部循坏，再写外部循环体

def bubble_sort(alist):
    '''冒泡排序'''
    n = len(alist)
    for j in range(n-1):  #先写内层循环，先让指针从头到尾走一遍，写完内层循环后，再想想这样的过程经历了多少遍
        count = 0
        for i in range(0, n-1-j):
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]
                count += 1
        if count == 0:
            return
#当我的列表本身就是一个有序列表，在第一遍从头到尾遍历的时候不会做出顺序的交换，说明我的列表本身就有序，不需要多余的操作，可以直接退出循坏体
#改进之后，最优时间复杂度变成了O（1），但是最坏时间复杂度没变，还是O（n*n）




if __name__ == "__main__":
    li = [54, 26, 93, 13, 77, 31, 55, 28]
    bubble_sort(li)
    print(li)

选择排序算法及实现

从原本的序列找到一个最小的，然后把最小的放在第一个位置；然后从剩下的数字里面找到次小的，放在第二个位置，依次类推

#先写了内层循坏
'''
def select_sort(alist):

    n = len(alist)
    min_index = 0      #默认第一个位置的数是最小值
    for i in range(n-1):
        if alist[min_index] > alist[i]:
            min_index = i         #当找到其他位置的数值比第一个数要大的时候，最小值的索引要发生了变化
'''


#思考外层循坏

def select_sort(alist):
    '''选择排序'''
    n = len(alist)
    for j in range(n-1):
        min_index =j    #最小值得索引从0依次向后推，不是每次都从第一个位置开始的
        for i in range(j+1, n): #要跟j之后的所有元素进行比较排序
            if alist[min_index] > alist[i]:
                min_index = i  # 当找到其他位置的数值比第一个数要大的时候，最小值的索引要改变
        #找到更小的值以后要做替换
        alist[j], alist[min_index] = alist[min_index], alist[j]

if __name__ == "__main__":
    li = [54, 26, 93, 13, 77, 26, 31, 55, 28]
    select_sort(li)
    print(li)
    #[13, 26, 28, 31, 54, 55, 77, 93]

#最坏时间复杂度和最优时间复杂度都是O（n * n）
#对于选择排序来说，如果是每次默认第一个位置是最大值时，如果出现相同的数值，会出现排序不稳定的情况
#例如[26,9,12,16,17,15,11,26,18],每次都选择最大的放在最后一个位置，当第一个26与第二个26进行比较的时候，由于并没有出现比第一个 26大的情况，会把第一个26放在最后一个位置，而第二个26作为次大的元素放在倒数第二个位置，即出现了不稳定的情况

插入算法

''''
#先写内循环——是从右边的无序排列中找到一个数来与前面的有序排列进行比较插入到合适的位置
def insert_sort(alist):

    n = len(alist)
    while i >0 :
        if alist[i] < alist[i - 1]:
            alist[i], alist[i - 1] = alist[i - 1], alist[i]
            i -= 1
        else:
            break

        # 当前的元素一直与前面的元素做比较，当比前面的元素小的时候，就会一直往前走，当比前面的元素大或等于前面的元素时，可以退出循环
'''



def insert_sort(alist):
    '''插入排序'''
    n = len(alist)
    #从右边的无序排序中取出多少个元素执行这样的过程
    for j in range(1, n):
        i = j
        #执行从右边的无序序列中取出第一个元素，即i位置的元素，然后将其插入到前面序列的正确位置中
        while i > 0:
            if alist[i] < alist[i - 1]:
                alist[i], alist[i - 1] = alist[i - 1], alist[i]
                i -= 1
            else:   #当前元素比前一个元素大的话，一定比前面的元素都大，也就可以退出循环，不需要挨个儿比较了
                break
                #else是一个优化的过程

if __name__ == "__main__":
    li = [54, 26, 93, 13, 77, 26, 31, 55, 28]
    insert_sort(li)
    print(li)
    #[13, 26, 28, 31, 54, 55, 77, 93]

#最优时间复杂度是O（1），最坏时间复杂度为O（n），排序是稳定的！