Python队列，双端队列，栈，

Python

**栈**

    class Node:
        def __init__(self, data):
            self.data = data
            self.next = None
    
        def __str__(self):
            return str(self.data)
    
    
    class Stack:
        def __init__(self):
            self._head = None
    
        # 压栈
        def push(self, item):
            node = Node(item)
            node.next = self._head
            self._head = node
            return node.data
    
        # 弹栈
        def pop(self):
            if self._head == None:
                return None
            else:
                data = self._head.data
                self._head = self._head.next
                return data
    
        # peek 取出栈顶元素
        def peek(self):
            if self._head != None:
                return self._head.data
            else:
                raise ValueError('stack is empty')
    
        def print_all(self):
            cur = self._head
            while cur != None:
                print(cur)
                cur = cur.next
    
    
    if __name__ == '__main__':
        s = Stack()
        s.push(6)
        s.push(1)
        s.push(8)
        s.push(10)
    
        s.print_all()
    
        print('--------pop-------------')
        s.pop()
        s.print_all()

队列

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

    def __str__(self):
        return str(self.data)


class Queue:
    def __init__(self, maxsize=-1):
        self.maxsize = maxsize
        self._head = None
        self._tail = None

    # 入队
    def enter(self, data):  # put
        size = self.qsize()
        if self.maxsize != -1 and self.maxsize > size or self.maxsize == -1:
            node = Node(data)
            if self._head == None and self._tail == None:
                self._head = node
                self._tail = node
            else:
                self._tail.next = node
                self._tail = node
        else:
            raise Exception('queue full ')

    # 出队
    def exit(self):  # get()
        if self._head == None and self._tail == None:
            # return None
            raise ValueError('queue is empty')
        data = self._head.data
        if self._head == self._tail:
            self._head = None
            self._tail = None
        else:
            self._head = self._head.next
        return data

    def print_all(self):
        cur = self._head
        while cur != None:
            print(cur)
            cur = cur.next

    def qsize(self):
        count = 0
        cur = self._head
        while cur != None:
            count += 1
            cur = cur.next

        return count

    def full(self):
        size=self.qsize()
        cur=self._head
        count=0
        while cur!=None:
            count+=1
            cur=cur.next
        if count==size:
            print('满')

    def empty(self):
        if self._head==self._tail:
            print('为空')
        else:print('No')




if __name__ == '__main__':
    q = Queue(4)

    q.enter(6)
    q.enter(4)
    q.enter(2)

    q.print_all()

    print('---------取出-------------')
    q.exit()
    q.print_all()

    print('-----------大小-------')
    q.enter(7)
    q.enter(1)
    # q.enter(9)
    print(q.qsize())
    q.empty()
    q.full()

双端队列

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

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

    def isEmpty(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)

    def print_all(self):
        for item in self.items:
            print(item)


if __name__ == '__main__':
    dq = Deque()
    dq.add_front(8)
    dq.add_front(9)
    dq.add_front(0)

    dq.print_all()

    dq.add_rear(6)
    dq.print_all()

    print('-----------remove---------')
    dq.remove_front()

    dq.print_all()

排序
排序算法（英语：Sorting algorithm）是一种能将一串数据依照特定顺序进行排列的一种算法。
冒泡排序
原则：
不断的重复‘走访’列表结构，进行相邻元素的比较。
升序： 判断第一个元素是否是比第二个元素大，如果True，则交换
当’走访’ 第一遍的时候，相当于搜索最大元素，并且将最大元素放到最后

选择排序

插入排序

快速排序
归并排序
希尔排序

[1,4,6,8,9,0,5,8,3,9,6,1,7]



**********************************冒泡排序
# list1 = [1, 4, 6, 8, 9, 9, 0, 5, 8, 3, 6, 1, 7]
# sorted(list1)

list1 = [1, 4, 6, 8, 9, 9, 0, 5, 8, 3, 6, 1, 7]


def bubble_sort(list1):
    for i in range(len(list1) - 1, 0, -1): # 11
        for j in range(i): # 0 ~ 11
            if list1[j] > list1[j + 1]:
                list1[j], list1[j + 1] = list1[j + 1], list1[j]


bubble_sort(list1)
print(list1)