單向連結串列：

元素僅和下一個位置元素有關聯。

除了儲存其本身的資訊之外，還要儲存一個指示其直接後繼的資訊，儲存資料元素資訊的域稱為資料域，把儲存直接後繼位置的域稱為指標域，指標域中儲存的資訊稱為指標，這兩部分資訊組成資料元素的儲存映像，稱為節點。

class SingleNode():
    """單鏈表節點"""

    def __init__(self,item):
        # item 存放資料元素
        self.item = item
        # next存放下一個節點的標識
        self.next = None


class SingleLinkList():
    """單鏈表"""

    def __init__(self):
        self._head = None

    def is_empty(self):
        """判斷列表是否為空"""
        return self._head == None

    def length(self):
        """連結串列長度"""
        count = 0
        # head初始化時指向頭節點
        head = self._head

        # 尾節點指向None，當沒有達到尾部時執行
        while head != None:
            count += 1
            # 將head後移一個節點
            head = head.next
        return count

    def travel(self):
        """遍歷連結串列"""
        head = self._head

        while head != None:
            print(head.item)
            head = head.next
        print("complete!")

    def add(self,item):
        """頭部新增元素"""
        # 先建立一個儲存item的節點
        node = SingleNode(item)
        # 將新增的節點的next指向原有的頭節點，就是self._head原有的位置
        node.next = self._head
        # 將連結串列的頭_head指向新節點
        self._head = node

    def append(self,item):
        """向尾部新增元素"""

        node = SingleNode(item)

        # 先判斷連結串列是否為空
        if self.is_empty():
            self._head = node
        else:
            cur = self._head
            while cur.next != None:
                cur = cur.next
        cur.next = node

    def insert(self,pos,item):
        """指定位置新增元素"""
        # 指定位置pos在第一個元素之前，向頭部插入
        if pos <= 0:
            self.add(item)
        # 指定位置pos在最後一個元素之後，向尾部插入
        elif pos>(self.length()-1):
            self.append(item)
        # 向中間插入，找到指定的位置
        else:
            node = SingleNode(item)
            count = 0
            # pre用來指向指定位置pos的前一個位置pos-1,初始時_head移動到指定位置
            pre = self._head
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 先將新節點node的next指向插入位置的節點
            node.next = pre.next
            # 將插入位置的前一個節點的next指向新節點
            pre.next = node

    def remove(self,item):
        """刪除元素"""
        cur = self._head
        pre = None

        while cur != None:
            # 找到指定元素
            if cur.item == item:
                # 如果第一個就是刪除的節點
                if not pre:
                    self._head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                # 繼續向連結串列後移動節點
                pre = cur
                cur = cur.next

    def search(self,item):
        """連結串列查詢節點是否存在，返回True或者False"""
        cur = self._head
        while cur!= None:
            if cur.item == item:
                return True
            cur = cur.next
        return False


if __name__ == '__main__':
    ll = SingleLinkList()
    ll.add(1)
    ll.add(2)
    ll.append(4)
    ll.insert(2,5)
    print(ll.search(3))
    print(ll.search(5))
    print(ll.search(1))
    ll.travel()
 

雙向連結串列：

雙向連結串列是在單鏈表的每個節點中，再設定一個前驅節點的指標域。所以雙向連結串列有兩個指標域，一個指向直接後繼，一個指向直接前驅。因為每個節點都需兩個指標，所以可能佔用的記憶體空間略微大一點。

class Node():
    """雙向連結串列節點"""
    def __init__(self,item):
        self.item = item
        self.next = None
        self.prev = None


class DLinkList():
    """雙向連結串列"""
    def __init__(self):
        self._head = None

    def is_empty(self):
        """判斷連結串列是否為空"""
        return self._head == None

    def length(self):
        """返回連結串列的長度"""
        cur = self._head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍歷連結串列"""
        cur = self._head
        while cur != None:
            print(cur.item)
            cur = cur.next
        print("complete!")

    def add(self,item):
        """頭部插入元素"""
        node = Node(item)
        if self.is_empty():
            self._head = node
        else:
            # 將node的next指向_head的頭節點
            node.next = self._head
            # 將_head的頭節點的prev指向node
            self._head.prev = node
            # 將_head指向node
            self._head = node

    def append(self,item):
        """向尾部新增元素"""
        node = Node(item)
        if self.is_empty():
            # 如果是空連結串列，將_head指向node
            self._head = node
        else:
            # 初始化指標
            cur = self._head
            while cur.next != None:
                cur = cur.next
            # 將尾節點cur的next指向node
            cur.next = node
            # 將node的prev指向cur
            node.prev = cur

    def search(self,item):
        """查詢元素是否存在"""
        cur = self._head
        while cur != Node:
            if cur.item == item:
                return True
            cur = cur.next
        return False

    def insert(self,pos,item):
        """在指定位置新增節點"""
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            count = 0
            # 移動指標cur到指定的位置的前一個位置
            while count < (pos -1):
                count += 1
                cur = cur.next
            # 將node節點的prev指向cur
            node.prev = cur
            # 將node節點的next指向下一個節點
            node.next = cur.next
            # 將cur的下一個節點的prev指向node
            cur.next.prev = node
            # 將cur的next指向node
            cur.next = node

    def remove(self,item):
        """刪除元素"""
        if self.is_empty():
            return
        else:
            cur = self._head
            if cur.item == item:
                if cur.next == None:
                    self._head = None
                else:
                    cur.next.prev = None
                    self._head = cur.next
                return
            while cur != None:
                if cur.item == item:
                    # 將cur的前一個節點的next指向cur的後一個節點
                    cur.prev.next = cur.next
                    # 將cur的後一個節點的prev指向cur的前一個節點
                    cur.next.prev = cur.prev
                    break
                cur = cur.next

if __name__ == '__main__':
    ll = DLinkList()
    ll.add(1)
    ll.add(2)
    ll.insert(0,5)
    ll.insert(4,7)
    ll.insert(2,9)
    print(ll.search(5))
    # print(ll.search(10))
    print(ll.length())
    ll.travel()
 

棧：

     先進後出，後進先出

class Stack():
    """棧"""
    def __init__(self):
        self.items = []

    def is_empty(self):
        return self.items == []

    def push(self,item):
        """加入元素"""
        self.items.append(item)

    def pop(self):
        """彈出元素"""
        return self.items.pop()

    def peek(self):
        """返回棧頂元素"""
        return self.items[-1]

    def size(self):
        """返回棧的大小"""
        return len(self.items)

if __name__ == '__main__':
    s = Stack()
    s.push('hello')
    s.push('world')
    s.push('stack')
    print(s.size())
    print(s.peek())
    print(s.pop())
 

佇列：

     先進先出，後進後出，只能在尾部刪除，在頭部插入，中間部分不能做處理。

class Queue(object):
    """佇列"""
    def __init__(self):
        self.items = []

    def is_empty(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(1)
    q.enqueue(2)
    print(q.size())
    print(q.dequeue())