python数据结构与算法第四天_python对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。经过该步骤-CSDN博客

本文链接：https://blog.csdn.net/lyckid/article/details/103265915

文章目录

栈

栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许再容器的一端（称为栈顶端指标，push）进行加入数据和输出数据（pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。
由于站数据结构只允许一端进行操作，因而按照后进先出（LIFO）的原理运作
在这里插入图片描述

对列

队列（queue）是只允许再一段进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，…，an），那么a1就是对头元素，而an是对位元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的有限出列，最后的当然排在队伍最后。
在这里插入图片描述

栈的结构实现

栈可以用顺序表实现，也可以用链表实现。
栈的操作

stack()创建一个新的空栈
push(item)添加一个新的元素item到栈顶
pop()弹出栈顶元素
peek()返回栈顶元素
is_empty()判断栈是否为空
size()返回栈的元素个数

# coding:utf-8

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

    def push(self,item):
        self.__list.append(item)
        #self.__list.insert(0,item),zhe

    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 == []
        #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)
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())

队列的实现

操作

Queue()创建一个空队列
enqueue(itme)往队列中添加一个item元素
dequeue()从队列头部删除一个元素
is_empty()判断一个队列是否为空
size()返回队列的大小

# coding:utf-8

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

    def enqueue(self,item):
        self.__list.append(item)

    def dequeue(self):
        return self.__list.pop(0)

    def is_empty(self):
        return not 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)
    print(s.dequeue())
    print(s.dequeue())
    print(s.dequeue())
    print(s.dequeue())

双端队列

双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。
双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。
在这里插入图片描述
操作

Deque()创建一个空的双端队列
add_front(item)从队头加入一个item元素
add_rear(item)从队尾加入一个item元素
remove_front()从对头删除一个item元素
remove_rear()从队尾删除一个item元素
is_empty()判断双端队列是否为空
size()返回队列的大小

双端队列的实现

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

    def add_front(self,item):
        self.__list.insert(0,item)

    def add_rear(self,item):
        self.__list.append(item)

    def pop_front(self):
        return self.__list.pop(0)

    def pop_rear(self):
        return self.__list.pop()

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

    def size(self):
        return len(self.__list)

if __name__ == '__main__':
    deque = Deque()
    deque.add_front(1)
    deque.add_front(2)
    deque.add_rear(3)
    deque.add_rear(4)
    print(deque.size())
    print(deque.pop_front())
    print(deque.pop_front())
    print(deque.pop_rear())
    print(deque.pop_rear())

排序与搜索

排序算法（Sortint algorrithm）是一种将以传数据依照特定顺序进行排列的一种算法。

排序算法的稳定性

稳定性：稳定排序算法会让本来有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当前两个相等键值的记录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。
当相等的元素是无法分辨，比如像是整数，稳定性并不是一个问题。然而，假设以下的数对将要以他们的第一个数字来排序。
（4，1）（3，1）（3，7）（5，6）
在这种状况下，有可能产生两种不同的结果，一个是让相等键值的记录维持相对的次序，而另一个则没有：
（3，1）（3，7）（4，1）（5，6）(维持次序)
（3，7）（3，1）（4，1）（5，6）（次序被改变）
不稳定排序算法可能会在相等的键值中改变记录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被特别的实现为稳定。作这件事情的一个方式人工扩充键值的比较，如此在其他方面相同键值的两个对象之间比较，（比如上面的比较重加入第二个标准：第二个键值的大小）就会被决定使用在原先数据次序中的条目，当作一个同分决赛。然而，要记住这种次序牵涉到额外的空间负担。

冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复的进行直到没有需要交换。也就是说改数列已经完成排序。这个算法的名字由来就是越小的元素会经由交换慢慢浮到数列的顶端。
冒泡排序算法的运作如下：

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

冒泡排序的实现

# coding:utf-8

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 0 == count:
            return
            
# 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]

if __name__ == '__main__':
    li = [54,26,93,17,77,31,44,55,20]
    bubble_sort(li)
    print(li)

时间复杂度

最优时间复杂度：O（n）(表示遍历一次发现没有任何可以交换的元素，排序结束）
最坏时间复杂度：O($n^2)
稳定性：稳定

选择排序

选择排序是一种简单的排序算法。它的工作原理如下。首先在未排序序列中，找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序列的末尾。以此类推，直到所有元素均排序完毕。
选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，他们当中至少有一个被移到最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。再所有的完全依靠交换区移动元素的排序方法中，选择排序属于非常好的一种。

def select_sort(alist):
    n = len(alist)
    for j in range(n-1):
        min_index = j
        for i in range(j+1,n):
            if alist[min_index] > alist[i]:
                min_index = i
        if min_index != j:
            alist[j],alist[min_index] = alist[min_index],alist[j]

if __name__ == '__main__':
    li = [54,26,93,17,77,31,44,55,20]
    print(li)
    select_sort(li)
    print(li)

时间复杂度

最优时间复杂度：O( $n^2$ )
最坏时间复杂度：O( $n^2$ )
稳定性：不稳定（考虑升序每次选择最大的情况）

插入排序

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

def insert_sort(alist):
    n = len(alist)
    for j in range(1, n):
        # j = [1,2,3,n-1]
        # i 代表内层循环起始值
        i = j
        while i > 0:
            if alist[i] < alist[i - 1]:
                alist[i], alist[i - 1] = alist[i - 1], alist[i]
                i -= 1
            else:
                break

if __name__ == '__main__':
    li = [54,26,93,17,77,31,44,55,20]
    print(li)
    insert_sort(li)
    print(li)