Chapter 4 双向链表、栈、队列

双向链表（双面链表）

对于头结点来说，prev=None
对于尾结点来说，next=None

关于双链表的操作

双链表的判空、长度、遍历操作

与单链表相同，见：Chapter 3 单向链表

双链表的头部添加、尾部添加、指定位置添加操作

#coding=utf-8
class Node(object):
    '''节点'''
    def __init__(self,elem):
        self.elem=elem
        self.next=None    #后继
        self.prev=None    #前驱
        pass
    pass

class DoubleLikeList(object):
    '''双链表'''
    def __init__(self,node=None):
        self.__head=node

    def add(self,item):
        '''头部添加元素，头插法'''
        node=Node(item)
        node.next=self.__head                 #先将新结点的链接区指向原有首结点
        self.__head=node                     #后将__head指向新结点的数据区
        node.next.prev=node                  #node.next=100
# 以上两句话还可以改变顺序
#       self.__head.prev=node
#       self.__head=node
        pass

    def append(self,item):
        '''尾部添加元素,尾插法，item是具体的数据元素，并不是结点'''
        node=Node(item)
        cur=self.__head
        if self.is_empty():
            self.__head=node
        else:
            while cur.next !=None:
                cur=cur.next
            cur.next=node
            node.prev=cur
        pass

    def insert(self,pos,item):
        '''
        指定位置添加元素
        :param pos:指定位置，从0开始
        :param item:所添加的数据
        :return:
        '''
        node = Node(item)
        if pos<=0:                    #默认头插法
            self.add(item)
        elif pos>(self.length()-1):
            self.append(item)
        else:
            cur=self.__head
            count=0
            while count<pos:
                count+=1
                cur=cur.next
                pass
        #当循环退出后
            node.next=cur
            node.prev=cur.prev
            cur.prev.next=node
            cur.prev=node
            pass

头部添加演示：

中间指定位置添加：
先挪动N——>P(图中第二条竖线)，后挪动P——>N(图中第三条竖线)

先挪动P——>N(图中第二条竖线)，后挪动N——>P(图中箭头旁的那条横线)

双链表的查找、删除操作

查找与单链表一致。
删除操作：

    def remove(self,item):
        '''删除节点,item是数据'''
        cur=self.__head
        while cur!=None:
            if cur.elem==item:
                #先判断此结点是否为头结点
                if cur==self.__head:  #pre=None
                    self.__head=cur.next
                    if cur.next: 
                        #判断链表是否不止一个结点
                        cur.next.prev=None
                else:
                   cur.prev.next=cur.next
                   if cur.next:
                        cur.next.prev=cur.prev
                break  #删除后退出循环
            else:
                cur=cur.next #以上两步使得pre=cur.next

栈

栈的特征

1. 栈，也称为“堆栈”，是一种容器，可存入数据元素，访问元素，删除元素，其特点是只能再容器的一端（栈顶端指标，top）进行加入数据（push）和输出数据（pop）的运算。没有位置概念，保证任何时候可以访问和删除的元素都是此前存入的最后一个元素，确定了一种默认的访问顺序。
2. 后进先出原理（LIFO,Last In First Out）。
3. 栈中元素可以用顺序表或者链表来存放。
   

栈的实现

push(item)添加新的元素item到栈顶，也称压栈。
pop()弹出栈顶元素
peek()返回栈顶元素
is_empty()判断栈是否为空
size()返回栈的元素个数

#coding=utf-8

class Stack(object):
    '''栈'''
    def __init__(self):
        self.__list=[]

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

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

    def peek(self):
        ''' 返回栈顶元素'''
        if self.__list:
            return self.__list[-1]  #空列表不支持-1操作
        else:
            return None
        pass

    def is_empty(self):
        ''' 判断栈是否为空'''
        return self.__list==[]   #return not self.__list
        pass

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

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

队列

队列的特征

1. 只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
2. 先进先出原理（FIFO,First In First Out）。
3. 队列中元素可以用顺序表或者链表来存放。
4. 应用场景：树

队列的实现

enqueue()往队列里面添加一个item元素
dequeue()从队列头部删除一个元素
is_empty()判断队列是否为空
size()返回队列的元素个数

#coding=utf-8

class Queue():
    def __init__(self):
        self.__list=[]
        pass
    def enqueue(self,item):
        ''' 往队列里面添加一个item元素'''
        self.__list.append(item)  #尾部添加O(1)
        #(1) self.__list.insert(0,item)  #头部添加O(n)
        pass

    def dequeue(self):
        '''从队列头部删除一个元素 '''
        '''尾部添加元素，头部删除'''
        return self.__list.pop(0)   #O(n)
        '''头部添加元素，尾部删除'''
        #(1) self.__list.pop() #O(1)
        pass

    def is_empty(self):
        '''判断队列是否为空 '''
        return self.__list==[]
        pass
    def size(self):
        '''返回队列的元素个数 '''
        return len(self.__list)
        pass

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

双端队列

双端队列的特征

双端队列的实现

#coding=utf-8
class Deque():
    '''双端队列'''

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

    def add_front(self, item):
        ''' 往双端队列头部添加一个item元素'''
        self.__list.insert(0,item)
        pass
    def add_rear(self,item):
        '''往双端队列尾部添加一个item元素 '''
        self.__list.append(item)
        
    def pop_front(self):
        '''从双端队列头部删除一个元素 '''
        return self.__list.pop(0)  # O(n)
        pass
    def pop_rear(self):
        return self.__list.pop()
    
    def is_empty(self):
        '''判断双端队列是否为空 '''
        return self.__list == []
        pass

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