數據是一個抽象的概念，將其進行分類後得到程序設計語言中的基本類型。如：int，float，char等。數據元素之間不是獨立的，存在特定的關系，這些關系便是結構。數據結構指數據對象中數據元素之間的關系。

算法與數據結構的區別

數據結構只是靜態的描述了數據元素之間的關系。

高效的程序需要在數據結構的基礎上設計和選擇算法。

程序 = 數據結構 + 算法

總結：算法是為了解決實際問題而設計的，數據結構是算法需要處理的問題載體

最常用的數據運算有五種：

• 插入
• 刪除
• 修改
• 查找
• 排序

順序表

一個線性表是某類元素的一個集合，還記錄著元素之間的一種順序關系。線性表是最基本的數據結構之一，在實際程序中應用非常廣泛，它還經常被用作更復雜的數據結構的實現基礎。

根據線性表的實際存儲方式，分為兩種實現模型：

• 順序表，將元素順序地存放在一塊連續的存儲區裏，元素間的順序關系由它們的存儲順序自然表示。
• 鏈表，將元素存放在通過鏈接構造起來的一系列存儲塊中。

順序表的結構

一個順序表的完整信息包括兩部分，一部分是表中的元素集合，另一部分是為實現正確操作而需記錄的信息，即有關表的整體情況的信息，這部分信息主要包括元素存儲區的容量和當前表中已有的元素個數兩項。

順序表的兩種基本實現方式

一體式結構，存儲表信息的單元與元素存儲區以連續的方式安排在一塊存儲區裏，兩部分數據的整體形成一個完整的順序表對象。

分離式結構，表對象裏只保存與整個表有關的信息（即容量和元素個數），實際數據元素存放在另一個獨立的元素存儲區裏，通過鏈接與基本表對象關聯。

元素存儲區替換

一體式結構由於順序表信息區與數據區連續存儲在一起，所以若想更換數據區，則只能整體搬遷，即整個順序表對象（指存儲順序表的結構信息的區域）改變了。

分離式結構若想更換數據區，只需將表信息區中的數據區鏈接地址更新即可，而該順序表對象不變。

Python中的順序表

Python中的list和tuple兩種類型采用了順序表的實現技術，具有前面討論的順序表的所有性質。

tuple是不可變類型，即不變的順序表，因此不支持改變其內部狀態的任何操作，而其他方面，則與list的性質類似。

list的基本實現技術

Python標準類型list就是一種元素個數可變的線性表，可以加入和刪除元素，並在各種操作中維持已有元素的順序（即保序），而且還具有以下行為特征：

• 基於下標（位置）的高效元素訪問和更新，時間復雜度應該是O(1)；

  為滿足該特征，應該采用順序表技術，表中元素保存在一塊連續的存儲區中。

• 允許任意加入元素，而且在不斷加入元素的過程中，表對象的標識（函數id得到的值）不變。

  為滿足該特征，就必須能更換元素存儲區，並且為保證更換存儲區時list對象的標識id不變，只能采用分離式實現技術。

在Python的官方實現中，list就是一種采用分離式技術實現的動態順序表。這就是為什麽用list.append(x) （或 list.insert(len(list), x)，即尾部插入）比在指定位置插入元素效率高的原因。

在Python的官方實現中，list實現采用了如下的策略：在建立空表（或者很小的表）時，系統分配一塊能容納8個元素的存儲區；在執行插入操作（insert或append）時，如果元素存儲區滿就換一塊4倍大的存儲區。但如果此時的表已經很大（目前的閥值為50000），則改變策略，采用加一倍的方法。引入這種改變策略的方式，是為了避免出現過多空閑的存儲位置。

鏈表

為什麽需要鏈表

順序表的構建需要預先知道數據大小來申請連續的存儲空間，而在進行擴充時又需要進行數據的搬遷，所以使用起來並不是很靈活。

鏈表結構可以充分利用計算機內存空間，實現靈活的內存動態管理。

鏈表的定義

鏈表（Linked list）是一種常見的基礎數據結構，是一種線性表，但是不像順序表一樣連續存儲數據，而是在每一個節點（數據存儲單元）裏存放下一個節點的位置信息（即地址）。

鏈表與順序表的對比

鏈表失去了順序表隨機讀取的優點，同時鏈表由於增加了結點的指針域，空間開銷比較大，但對存儲空間的使用要相對靈活。

鏈表與順序表的各種操作復雜度如下所示：

註意雖然表面看起來復雜度都是 O(n)，但是鏈表和順序表在插入和刪除時進行的是完全不同的操作。鏈表的主要耗時操作是遍歷查找，刪除和插入操作本身的復雜度是O(1)。順序表查找很快，主要耗時的操作是拷貝覆蓋。因為除了目標元素在尾部的特殊情況，順序表進行插入和刪除時需要對操作點之後的所有元素進行前後移位操作，只能通過拷貝和覆蓋的方法進行。

單向鏈表

單向鏈表也叫單鏈表，是鏈表中最簡單的一種形式，它的每個節點包含兩個域，一個信息域（元素域）和一個鏈接域。這個鏈接指向鏈表中的下一個節點，而最後一個節點的鏈接域則指向一個空值。

• 表元素域elem用來存放具體的數據。
• 鏈接域next用來存放下一個節點的位置（python中的標識）
• 變量p指向鏈表的頭節點（首節點）的位置，從p出發能找到表中的任意節點。

單鏈表的實現

class SingleLinkList(object):
    """單鏈表"""
    def __init__(self):
        self._head = None

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

    def length(self):
        """鏈表長度"""
        # cur初始時指向頭節點
        cur = self._head
        count = 0
        # 尾節點指向None，當未到達尾部時
        while cur != None:
            count += 1
            # 將cur後移一個節點
            cur = cur.next
        return count

    def travel(self):
        """遍歷鏈表"""
        cur = self._head
        while cur != None:
            print cur.item,
            cur = cur.next
        print ""

節點操作

#  頭部添加元素
 def add(self, item):
        """頭部添加元素"""
        # 先創建一個保存item值的節點
        node = SingleNode(item)
        # 將新節點的鏈接域next指向頭節點，即_head指向的位置
        node.next = self._head
        # 將鏈表的頭_head指向新節點
        self._head = node

    def append(self, item):
        """尾部添加元素"""
        node = SingleNode(item)
        # 先判斷鏈表是否為空，若是空鏈表，則將_head指向新節點
        if self.is_empty():
            self._head = node
        # 若不為空，則找到尾部，將尾節點的next指向新節點
        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)
        # 若指定位置超過鏈表尾部，則執行尾部插入
        elif pos > (self.length()-1):
            self.append(item)
        # 找到指定位置
        else:
            node = SingleNode(item)
            count = 0
            # pre用來指向指定位置pos的前一個位置pos-1，初始從頭節點開始移動到指定位置
            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:
                    # 將刪除位置前一個節點的next指向刪除位置的後一個節點
                    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

單向循環鏈表

單鏈表的一個變形是單向循環鏈表，鏈表中最後一個節點的next域不再為None，而是指向鏈表的頭節點。

實現：

class Node(object):
    """節點"""
    def __init__(self, item):
        self.item = item
        self.next = None


class SinCycLinkedlist(object):
    """單向循環鏈表"""
    def __init__(self):
        self._head = None

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

    def length(self):
        """返回鏈表的長度"""
        # 如果鏈表為空，返回長度0
        if self.is_empty():
            return 0
        count = 1
        cur = self._head
        while cur.next != self._head:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍歷鏈表"""
        if self.is_empty():
            return
        cur = self._head
        print cur.item,
        while cur.next != self._head:
            cur = cur.next
            print cur.item,
        print ""


    def add(self, item):
        """頭部添加節點"""
        node = Node(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            #添加的節點指向_head
            node.next = self._head
            # 移到鏈表尾部，將尾部節點的next指向node
            cur = self._head
            while cur.next != self._head:
                cur = cur.next
            cur.next = node
            #_head指向添加node的
            self._head = node

    def append(self, item):
        """尾部添加節點"""
        node = Node(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            # 移到鏈表尾部
            cur = self._head
            while cur.next != self._head:
                cur = cur.next
            # 將尾節點指向node
            cur.next = node
            # 將node指向頭節點_head
            node.next = self._head

    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
            # 移動到指定位置的前一個位置
            while count < (pos-1):
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        """刪除一個節點"""
        # 若鏈表為空，則直接返回
        if self.is_empty():
            return
        # 將cur指向頭節點
        cur = self._head
        pre = None
        # 若頭節點的元素就是要查找的元素item
        if cur.item == item:
            # 如果鏈表不止一個節點
            if cur.next != self._head:
                # 先找到尾節點，將尾節點的next指向第二個節點
                while cur.next != self._head:
                    cur = cur.next
                # cur指向了尾節點
                cur.next = self._head.next
                self._head = self._head.next
            else:
                # 鏈表只有一個節點
                self._head = None
        else:
            pre = self._head
            # 第一個節點不是要刪除的
            while cur.next != self._head:
                # 找到了要刪除的元素
                if cur.item == item:
                    # 刪除
                    pre.next = cur.next
                    return
                else:
                    pre = cur
                    cur = cur.next
            # cur 指向尾節點
            if cur.item == item:
                # 尾部刪除
                pre.next = cur.next

    def search(self, item):
        """查找節點是否存在"""
        if self.is_empty():
            return False
        cur = self._head
        if cur.item == item:
            return True
        while cur.next != self._head:
            cur = cur.next
            if cur.item == item:
                return True
        return False

雙向鏈表

一種更復雜的鏈表是“雙向鏈表”或“雙面鏈表”。每個節點有兩個鏈接：一個指向前一個節點，當此節點為第一個節點時，指向空值；而另一個指向下一個節點，當此節點為最後一個節點時，指向空值。

棧

棧（stack），有些地方稱為堆棧，是一種容器，可存入數據元素、訪問元素、刪除元素，它的特點在於只能允許在容器的一端（稱為棧頂端指標，英語：top）進行加入數據（英語：push）和輸出數據（英語：pop）的運算。沒有了位置概念，保證任何時候可以訪問、刪除的元素都是此前最後存入的那個元素，確定了一種默認的訪問順序。

由於棧數據結構只允許在一端進行操作，因而按照後進先出（LIFO, Last In First Out）的原理運作。

棧結構實現

棧可以用順序表實現，也可以用鏈表實現。

棧的操作

• Stack() 創建一個新的空棧
• push(item) 添加一個新的元素item到棧頂
• pop() 彈出棧頂元素
• peek() 返回棧頂元素
• is_empty() 判斷棧是否為空
• size() 返回棧的元素個數

class Stack(object):
    """棧"""
    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[len(self.items)-1]

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

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

隊列

隊列（queue）是只允許在一端進行插入操作，而在另一端進行刪除操作的線性表。

隊列是一種先進先出的（First In First Out）的線性表，簡稱FIFO。

隊列的實現

同棧一樣，隊列也可以用順序表或者鏈表實現。

操作

• Queue() 創建一個空的隊列
• enqueue(item) 往隊列中添加一個item元素
• dequeue() 從隊列頭部刪除一個元素
• is_empty() 判斷一個隊列是否為空
• size() 返回隊列的大小

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("hello")
    q.enqueue("world")
    q.enqueue("itcast")
    print q.size()
    print q.dequeue()
    print q.dequeue()
    print q.dequeue()

雙端隊列

雙端隊列（deque，全名double-ended queue），是一種具有隊列和棧的性質的數據結構。

雙端隊列中的元素可以從兩端彈出，其限定插入和刪除操作在表的兩端進行。雙端隊列可以在隊列任意一端入隊和出隊。

操作

• Deque() 創建一個空的雙端隊列
• add_front(item) 從隊頭加入一個item元素
• add_rear(item) 從隊尾加入一個item元素
• remove_front() 從隊頭刪除一個item元素
• remove_rear() 從隊尾刪除一個item元素
• is_empty() 判斷雙端隊列是否為空
• size() 返回隊列的大小

實現

class Deque(object):
    """雙端隊列"""
    def __init__(self):
        self.items = []

    def is_empty(self):
        """判斷隊列是否為空"""
        return self.items == []

    def add_front(self, item):
        """在隊頭添加元素"""
        self.items.insert(0,item)

    def add_rear(self, item):
        """在隊尾添加元素"""
        self.items.append(item)

    def remove_front(self):
        """從隊頭刪除元素"""
        return self.items.pop(0)

    def remove_rear(self):
        """從隊尾刪除元素"""
        return self.items.pop()

    def size(self):
        """返回隊列大小"""
        return len(self.items)


if __name__ == "__main__":
    deque = Deque()
    deque.add_front(1)
    deque.add_front(2)
    deque.add_rear(3)
    deque.add_rear(4)
    print deque.size()
    print deque.remove_front()
    print deque.remove_front()
    print deque.remove_rear()
    print deque.remove_rear()

常見數據結構與python實現