Python数据结构与算法---队列与排序

1. 队列的简介

队列这个概念非常好理解。你可以把它想象成排队买票，先来的先买，后来的人只能站末尾，不允许插队。先进者先出，这就是典型的“队列”。

队列跟栈非常相似，支持的操作也很有限，最基本的操作也是两个：入队 enqueue()，放一个数据到队列尾部；出队 dequeue()，从队列头部取一个元素。

队列的概念很好理解，基本操作也很容易掌握。作为一种非常基础的数据结构，队列的应用也非常广泛，特别是一些具有某些额外特性的队列，比如循环队列、阻塞队列、并发队列。它们在很多偏底层系统、框架、中间件的开发中，起着关键性的作用。

2. 队列的实现

2.1 普通队列的实现

操作：

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

用列表的方式实现队列：

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

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

    def enqueue(self, item):
        '''enqueue(item) 往队列中添加一个item元素'''
        self.__items.append(item)

    def dequeue(self):
        '''dequeue() 从队列头部删除一个元素'''
        if self.__items == []:
            return None
        else:
            self.__items.pop(0)

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

2.2 双端队列的实现

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

双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。

操作：

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

用列表的方式实现双端队列：

class Deque(object):
    '''Deque() 创建一个空的双端队列'''

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

    def add_front(self, item):
        '''add_front(item) 从队头加入一个item元素'''
        self.__items.insert(0, item)

    def add_rear(self, item):
        '''add_rear(item) 从队尾加入一个item元素'''
        self.__items.append(item)

    def remove_front(self):
        '''remove_front() 从队头删除一个item元素'''
        if self.__items == []:
            return None
        else:
            self.__items.pop(0)

    def remove_rear(self):
        '''remove_rear() 从队尾删除一个item元素'''
        if self.__items == []:
            return None
        else:
            self.__items.pop()

    def is_empty(self):
        '''is_empty() 判断双端队列是否为空'''
        return self.__items == []

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

    def travel(self):
        '''travel() 遍历'''
        for i in self.__items:
            print(i, end=' ')
        print()

2.3 阻塞队列

阻塞队列其实就是在队列基础上增加了阻塞操作。简单来说，就是在队列为空的时候，从队头取数据会被阻塞。因为此时还没有数据可取，直到队列中有了数据才能返回；如果队列已经满了，那么插入数据的操作就会被阻塞，直到队列中有空闲位置后再插入数据，然后再返回。

3. 递归

递归需要满足的三个条件：

1. 一个问题的解可以分解为几个子问题的解
2. 这个问题与分解之后的子问题，除了数据规模不同，求解思路完全一样
3. 存在递归终止条件

练习：
用递归的方式输出l=[‘jack’, (‘tom’, 23), ‘rose’, (14, 55, 67)] 列表内的每一个元素

lis = ['jack', ('tom', 23), 'rose', (14, 55, 67)]
def fn(l):
    if isinstance(l, (int, str)):
        print(l)
    else:
        for i in l:
            fn(i)

4. 冒泡排序法

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

冒泡排序算法的运作：

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

5. 冒泡排序法的实现

方法一：

lis = [54,26,93,17,77,31,44,55,20]
def bubble_sort(l):
    for i in range(len(l)-1, 0, -1):
        for j in range(i):          
            if l[j] > l[j+1]:
                l[j], l[j+1] = l[j+1], l[j]
    print(l)
bubble_sort(lis)
# [17, 20, 26, 31, 44, 54, 55, 77, 93]

方法二：

lis = [54,26,93,17,77,31,44,55,20]
def bubble_sort(l):
    for i in range(len(l)-1):
        for j in range(len(l)-1-i):
            if l[j] > l[j + 1]:
                l[j], l[j+1] = l[j+1], l[j]
    print(l)
bubble_sort(lis)
# [17, 20, 26, 31, 44, 54, 55, 77, 93]