数据结构——栈与队列基本功能的代码实现

栈：
栈(stack)，也可以称成为堆栈，是一种可以存放，访问及删除数据元素的容器。它的特点在于只能允许在容器的一端(栈顶：top)进行加入数据(push)和输出数据(pop) 的运算操作。
由于栈的数据结构只允许在一端进行操作，因此按照后进先出(LIFO, Last In First Out)的原理运作，符合这个运作原理的，就可以成为栈。
栈与链表和顺序表的区别在于：栈描述的的对数据元素怎么操作；顺序表和链表描述的是数据怎么存放。

栈结构实现：
可以用顺序表实现，也可以用链表实现，下面用顺序表实现：
Stack() 创建一个新栈
push(item) 添加一个新的元素item到栈顶
pop() 弹出栈顶元素
peek() 返回栈顶元素
is_empty() 判断栈是否为空
size() 返回栈的元素个数

class Stack(object):
    '''栈'''
    def __init__(self):
        self.__list = [] #构造存放数据的容器，这里使用顺序表(列表)

    def push(self, item):
        '''添加一个新的元素item到栈顶'''
        self.__list.append(item)

    def pop(self):
        '''弹出栈顶元素'''
        return self.__list.pop()

    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()) #4

    print(s.peek()) #3

    print(s.is_empty()) #False

    print(s.size()) #3

程序运行结果如下：

队列：
队列(queue)，是只允许在一端进行插入操作，在另一端进行删除操作的线性表。
队列按照先进先出(FIFO, First In First Out)的原理运作，同样，符合这个运作原理的，就可以成为队列。

队列结构实现：
可以用顺序表实现，也可以用链表实现，下面用顺序表实现：
Queue() 创建一个空的队列
enqueue(item) 添加一个新的元素item到队列中
dequeue() 删除队列中一个元素
is_empty() 判断队列是否为空
size() 返回队列的元素个数

class Queue(object):
    '''队列'''
    def __init__(self):
        self.__list = [] ##构造存放数据的容器，这里使用顺序表(列表)

    def enqueue(self, item):
        '''添加一个新的元素item到队列中'''
        self.__list.insert(0, item) #从列表头部添加
        #self.__list.append(item) #从列表尾部添加


    def dequeue(self):
        '''删除队列中一个元素'''
        return self.__list.pop() #从列表尾部弹出
        #return self.__list.pop(0) #从列表头部弹出


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

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

if __name__ == '__main__':
    q = Queue()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    q.enqueue(4)


    print(q.dequeue()) #1

    print(q.is_empty()) #False

    print(q.size()) #3

程序运行结果如下：

双端队列：
双端队列(deque, double-ended queue)，是一种具有队列和栈的性质的数据结构。
双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端运行，双端队列可以在队列的任意一端入队和出队。

双端队列结构实现：
可以用顺序表实现，也可以用链表实现，下面用顺序表实现：
Deque() 创建一个空的双端队列
add_front(item) 添加一个新的元素item到队头
add_rear(item) 添加一个新的元素item到队尾
remove_front(item) 删除队头元素
remove_rear(item) 删除队尾元素
is_empty() 判断双端队列是否为空
size() 返回双端队列的元素个数

class Deque(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 remove_front(self):
        '''删除队头元素'''
        return self.__list.pop(0)

    def remove_rear(self):
        '''删除队尾元素'''
        return self.__list.pop()


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

    def size(self):
        '''返回队双端列的元素个数'''
        return len(self.__list)


if __name__ == '__main__':
    d = Deque()
    d.add_front(1)
    d.add_front(2)
    d.add_rear(3)
    d.add_rear(4)

    print(d.remove_front()) #2
    print(d.remove_rear()) #4

    print(d.is_empty()) #False

    print(d.size()) #2

程序运行结果如下：