【Python】链表、队列、栈

链表的定义：

　　链表(linked list)是由一组被称为结点的数据元素组成的数据结构，每个结点都包含结点本身的信息和指向下一个结点的地址。由于每个结点都包含了可以链接起来的地址信息，所以用一个变量就能够访问整个结点序列。也就是说，结点包含两部分信息：一部分用于存储数据元素的值，称为信息域；另一部分用于存储下一个数据元素地址的指针，称为指针域。链表中的第一个结点的地址存储在一个单独的结点中，称为头结点或首结点。链表中的最后一个结点没有后继元素，其指针域为空。 

一、单链表

在C++中是利用指针完成相关的操作，在Python里可以创建一个Node类来实现，用类的属性来代替指针

• 单链表的建立、打印、测长、删除节点、插入、排序、逆置

class Node(object):         # Node类有value和next两个属性    def __init__(self,value,next=None):        self.value=value    # 存放数据元素        self.next=next      # next是下一个节点的标识def create_list(n):     # 建立单链表    if n<=0:        return False    if n==1:        return Node(1)    else:        root=Node(1)        tmp=root        for i in range(2, n+1):            tmp.next=Node(i)            tmp=tmp.next        return rootdef print_list(head):      # 打印单链表    p=head    while p!=None:        print(p.value)        p=p.nextdef len_list(head):       # 链表长度    c=0    p=head    while p!=None:        c=c+1        p=p.next    return cdef del_list(head,n):  # 删除链表    if n<1 or n>len_list(head):        return head    elif n is 1:        '''        Python中的对象包含三要素：id、type、value        其中id用来唯一标识一个对象，type标识对象的类型，value是对象的值        is判断的是a对象是否就是b对象，是通过id来判断的        ==判断的是a对象的值是否和b对象的值相等，是通过value来判断的        '''        head=head.next   # head指向P1，删除index=1以后，head指向P2；    else:        p=head        for i in range(1,n-1):            p=p.next        q=p.next        # n=4时，p.next指向4        p.next=q.next   # q.next指向5，并放在3后面    return headdef insert_list(head,n):  # 插入    if n<1 or n>len_list(head):        return    p=head    for i in range(1,n-1):        p=p.next    t=Node(5)   #设定插入的值    t.next=p.next    p.next=t    return headdef sort_list(head):    if head is None:        return    right=head.next                         # left的值大于right，值互换    while right is not None:        left=head        right_val=right.value        while left is not right:            if left.value<=right_val:                pass            else:                left.value,right_val=right_val,left.value            left=left.next        right.value=right_val        right=right.nextdef reverse_list(head): # 逆置    p1=None    p2=head    while(p2 is not None):        tmp=p2.next        p2.next=p1        p1=p2        p2=tmp    return p1if __name__=='__main__':    n=8    head=create_list(n)    print_list(head)    print("___________________________")    print("删除后的list:")    n1=4    del_list(head,n1)    print_list(head)    print("___________________________")    print("插入后的list:")    n = 8    head = create_list(n)    n2=4    insert_list(head,n2)    print_list(head)    print("___________________________")    print("排序后的list:")    sort_list(head)    print_list(head)

二、双链表

双链表的情况和单链表类似，只是增加了一个前置链而已

• 双链表的建立、删除节点、插入节点

class Node(object):    def __init__(self, value=None):        self._prev = None        self.data = value        self._next = None    def __str__(self):        return "Node(%s)" % self.dataclass DoubleLinkedList(object):    def __init__(self):        self._head = Node()    def insert(self, value):        element = Node(value)        element._next = self._head        self._head._prev = element        self._head = element    def search(self, value):        if not self._head._next:            raise ValueError("the linked list is empty")        temp = self._head        while temp.data != value:            temp = temp._next        return temp    def delete(self, value):        element = self.search(value)        if not element:            raise ValueError('delete error: the value not found')        element._prev._next = element._next        element._next._prev = element._prev        return element.data    def __str__(self):        values = []        temp = self._head        while temp and temp.data:            values.append(temp.data)            temp = temp._next        return "DoubleLinkedList(%s)" % values 

三、队列（queue）

队列也是表，使用队列时插入在一端进行而删除在另一端进行

• 入队（enqueue）：在表的末端队尾（rear）插入一个元素
• 出队（dequeue）：删除（并返回）表的开头队头（front）的元素

class Queue(object):    def __init__(self):        self.items = []    def isEmpty(self):        return self.items == []    def enqueue(self,item):# 入队        self.items.insert(0,item)    def dequeue(self):# 出队        return self.items.pop()    def size(self):        return len(self.items)if __name__=='__main__':    q=Queue()    q.enqueue('Apple')    q.enqueue('Sumsung')    q.enqueue('Xiaomi')    print(q.dequeue())    print('--------------------')    print(q.isEmpty())    print('--------------------')    print(q.size())

四、栈（stack）

栈是一种只能通过访问其一端来实现数据存储与检索的线性数据结构，具有后进先出(last in first out，LIFO)的特征；

栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈的顶（top）；

基本操作有进栈（push）和出栈（pop）

class Stack(object):      def __init__(self):          self._top = 0          self._stack = []        def push(self, data):          self._stack.insert(self._top, data)          self._top += 1        def pop(self):          if self.isEmpty():              raise ValueError('stack 为空')          self._top -= 1          data = self._stack[self._top]            return data        def isEmpty(self):          if self._top == 0:              return True          else:              return False        def __str__(self):          return "Stack(%s)"%self._stack