【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 root

def print_list(head):      # 打印单链表
    p=head
    while p!=None:
        print(p.value)
        p=p.next

def len_list(head):       # 链表长度
    c=0
    p=head
    while p!=None:
        c=c+1
        p=p.next
    return c

def 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 head

def 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 head

def 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.next

def reverse_list(head): # 逆置
    p1=None
    p2=head
    while(p2 is not None):
        tmp=p2.next
        p2.next=p1
        p1=p2
        p2=tmp
    return p1

if __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.data

class 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