棧、隊列和鏈表

棧

棧是一種後進先出的策略，其操作包括入棧，出棧，獲取棧頂元素值等。
我們這裏用python列表簡單的模擬棧，考慮上下溢出的情況，其代碼實現如下：

class Stack:
    def __init__(self,sz=65536):
        self.stack = []
        self.top = -1
        self.size = sz

    def isEmpty(self):
        return True if self.top is -1 else False

    def isFull(self):
        return True if self.top is self.size - 1 else False

    def push(self,obj): #壓入棧操作
        if self.isFull():
            raise Exception("Stack over flow!")
        else:
            self.stack.append(obj)
            self.top += 1

    def pop(self): #彈出棧頂元素
        if self.isEmpty():
            raise Exception("Stack is empty!")
        else:
            self.top -= 1
            return self.stack.pop()

    def count(self): #獲取棧中元素個數
        return self.top + 1

    def top(self): #獲取棧頂元素值
        if self.isEmpty():
            raise Exception("Stack is empty!")
        return self.stack[top]

    def show(self):
        print(self.stack)

隊列

隊列是一種先進先出的數據結構，主要操作包括入隊,出隊。入隊的元素加入到對尾，從隊頭取出出隊的元素。這裏用列表簡單模擬隊列，其實現如下：

class Queue:
    def __init__(self,sz=65535):
        self.queue = []
        self.size = sz
        self.len = 0

    def isEmpty(self):
        return True if self.len is 0 else False

    def isFull(self):
        return True if self.len is self.size else False

    def length(self):
        return self.len

    def enqueue(self,obj): #入隊
        if self.isFull():
            raise Exception("Queue is Full!")
        else:
            self.queue.append(obj)
            self.len += 1

    def dequeue(self): #出隊
        if self.isEmpty():
            raise Exception("Queue is Empty!")
        else:
            self.len -= 1
            return self.queue.pop(0)

    def show(self):
        print(self.queue)

實際應用中還使用一種叫做雙端隊列的數據結構，其實現也在隊列的基礎上變成可以對兩端操作。

class Deque:
    def __init__(self,sz=65535):
        self.queue = []
        self.size = sz
        self.len = 0

    def isEmpty(self):
        return True if self.len is 0 else False

    def isFull(self):
        return True if self.len is self.size else False

    def length(self):
        return self.len

    def enqueue(self,obj): #從右邊入隊
        if self.isFull():
            raise Exception("DeQueue is Full!")
        else:
            self.len += 1
            self.queue.append(obj)

    def enqueueLeft(self,obj): #從左邊入隊
        if self.isFull():
            raise Exception("DeQueue is Full!")
        else:
            self.len += 1
            self.queue.insert(0,obj)

    def dequeue(self): #從左邊出隊
        if self.isEmpty():
            raise Exception("DeQueue is Empty!")
        else:
            self.len -= 1
            return self.queue.pop(0)

    def dequeueRight(self): #從右邊出隊
        if self.isEmpty():
            raise Exception("DeQueue is Empty!")
        else:
            self.len -= 1
            return self.queue.pop()

    def show(self):
        print(self.queue)

鏈表

鏈表分爲單向鏈表和雙向鏈表，這裏給出雙向鏈表的實現：

#構成雙向鏈表的結點
class Node:
    def __init__(self,key=None):
        self.key = key
        self.prev = None #指向前驅
        self.next = None #指向後繼

    def getKey(self):
        return self.key

    def getPrev(self):
        return self.prev

    def getNext(self):
        return self.next

    def setKey(self, key):
        self.key = key

    def setPrev(self, prev):
        self.prev = prev

    def setNext(self, next):
        self.next = next


class LinkList:
    def __init__(self,data=None):
        self.head = None
        self.len = 0
        if data:
            p = self.head = Node(data[0])
            self.len += 1
            for key in data[1:]:
                node = Node(key)
                p.setNext(node)
                node.setPrev(p)
                self.len += 1
                p = node
    #重載[]運算符，使其具體下標訪問能力，比如像obj[1]這樣訪問           
    def __getitem__(self, index):
        if index >= self.len or index < 0:
            raise Exception("Index out of range!")
        else:
            p = self.head
            for i in range(index):
                p = p.getNext()
            return p.getKey()

    def length(self):
        return self.len

    def search(self,key):
        p = self.head
        while p and p.getKey() is not key:
            p = p.getNext()
        return p

    def insert(self,key):
        p = Node(key)
        if not self.head:
            self.head = p
            self.len += 1
        else:
            self.head.setPrev(p)
            p.setNext(self.head)
            self.head = p
            self.len += 1

    def delete(self,key):
        p = self.search(key)
        if p:
            if p.getPrev():
                p.getPrev().setNext(p.getNext())
            else:
                self.head = p.getNext()
            if p.getNext():
                p.getNext().setPrev(p.getPrev())
            p.setPrev(None)
            p.setNext(None)
            self.len -= 1

    def show(self):
        p = self.head
        while p:
            print(p.getKey(),end=' ')
            p = p.getNext()
        print()