python算法--鏈表、隊列、棧

一、鏈表

1. 算法原理：
   通過一個個節點組成的，每個節點都包含了value的基本元素，能保存數據之間邏輯順序，但存儲空間不必按照順序存儲。
   鏈表的基本元素：
   node節點：每個節點存儲兩個部分，左邊部分爲值域用來存放用戶數據，右邊部分爲指針域用來存放下一個元素指針
   head節點：永遠指向第一個節點
   tail節點：永遠指向最後一個節點
   None：鏈表中最後一個節點的指針域未None值
2. 代碼：

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

    def __repr__(self):
        return str(self.value)
    

class LinkChain(object):
    def __init__(self,head):
        self.head = head
        self.tail = self.head.next

    # 鏈表長度
    def __len__(self):
        count = 0
        if self.head is None:
            return count
        curr = self.head
        while curr:
            count += 1
            curr = curr.next
        return count

    # 正序打印鏈表所有內容
    def printList(self):
        all = []
        if self.head is None:
            return all
        curr = self.head
        while curr:
            all.append(curr.value)
            curr = curr.next
        return all

    # 在鏈表開頭插入
    def insertToFront(self, number):
        if self.head is None:
            return None
        node = Node(number, self.head)
        self.head = node
        return number

    # 在鏈表末尾插入
    def append(self, number):
        if self.head is None:
            return None
        curr =self.head
        while curr.next:
            curr = curr.next
        curr.next = Node(number)
        return number

    def find(self, number=None):
        if number is None or self.head is None:
            return None
        curr = self.head
        while curr:
            if curr.value == number:
                return curr.value
            curr = curr.next
        return False

    # 在鏈表中刪除數字
    def deleteData(self, number=None):
        if number is None:
            return None
        if self.head.value == number:
            self.head = self.head.next
            return self.head
        curr = self.head
        while curr.next:
            if curr.next.value == number:
                curr.next = curr.next.next
                return curr
            curr = curr.next
        return False


if __name__ == '__main__':
    node1 = Node(1)
    node2 = Node(2)
    node3 = Node(3)
    node1.next = node2
    node2.next = node3
    l = LinkChain(node1)
    print('在鏈表開頭插入4：', l.insertToFront(4))
    print('在鏈表末尾插入5：', l.append(5))
    print('在鏈表中查找數字：', l.find(5))
    print('在鏈表中刪除數字：', l.deleteData(4))
    print('正序打印鏈表：', l.printList())

執行結果：
在鏈表開頭插入4： 4
在鏈表末尾插入5： 5
在鏈表中查找數字： 5
在鏈表中刪除數字： 1
正序打印鏈表： [1, 2, 3, 5]

二、隊列

1. 算法原理：
   先進先出。
   隊列中基本元素：
   head：頭結點
   tail：尾結點
   隊列實例方法：
   enquenen：入隊列
   dequeue：出隊列
2. 代碼：

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

class Queue(object):
    def __init__(self):
        self.head = None
        self.tail = None

# 入隊列
    def enQueue(self, n):
        node = Node(n)
        if self.head is None:
            self.head = node
            self.tail = node
        else:
            self.tail.next = node
            self.tail = node

# 出隊列
    def deQueue(self):
        if self.head is None:
            return None
        else:
            temp = self.head.value
            self.head = self.head.next
            if self.head is None:
                self.tail = None
        return temp


if __name__ == '__main__':
    q = Queue()
    q.enQueue(1)
    q.enQueue(2)
    print(q.deQueue())
	print(q.deQueue())


執行結果：
1
2

三、棧

1. 算法原理：
   棧是一種只能在一端進入插入和刪除操作數據結構。先進後出原則。
   棧中基本屬性:
   top：棧頂元素
   棧實例方法：
   push(n)：入棧
   pop()：出棧
   peek()：獲取棧頂元素
2. 代碼：

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


class stack(object):
    def __init__(self):
        self.top = None

    # 入棧
    def push(self, n):
        node = Node(n)
        node.next = self.top
        self.top = node
        return node.value

    # 出棧
    def pop(self):
        if self.top is None:
            return None
        temp = self.top.value
        self.top = self.top.next
        return temp

    # 獲取棧頂元素
    def peek(self):
        if self.top is None:
            return None
        else:
            return self.top.value


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

執行結果：
3
2