數據結構與算法

 

數據結構和算法

算法： 解決問題的思想思路
    輸入項，輸出項，肯定性，可行性，有窮性

    基本運算數量 描述 時間複雜度

    基本類型的存儲方式---數據結構 python內置數據結構如列表，字典，集合，元組


順序表：（python中的list和tuple）
    表頭+數據區 -->表頭有容量和元素數量   
    兩種形式：
        1:表頭和數據區連續存儲(一體式)，
        2：表頭和數據區分開存儲，表頭多一個數據區存儲地址
        考慮動態數據的變化，一般使用分離式。
    採用一體式時，當存儲容量不夠時，將開啓新的內存空間，將表頭和數據遷移；
    採用分離式，將數據區遷移，而後將表頭的數據區地址更改
    數據區的擴充：固定容量擴充；翻倍擴充

    基本類型連續存儲在內存中,能夠物理地址查詢,例如一個整形存儲須要4個字節，
    第一個數據的物理地址爲l,接下來的第n個數據的物理地址爲l+n*4

    順序表基本佈局：
        將數據存儲在內存中，但只能存儲一樣數據類型

    順序表元素外置：
        將地址存儲在內存中，能夠存儲不一樣的數據類型

鏈表：
    將元素存放在經過連接構造起來的一系列存儲塊中；
    有數據區和連接區，連接區保存下一個數據的地址；
    
單向鏈表的建立：                 
    #節點的建立：                        
        class Node(object):                            
            def __init__(self,elem):
                self.elem = elem
                self.next = None
                
    #鏈的建立：                                  
        class LinkList(object):
            def __init__(self,node=None):
                self.__head = node
                
            def is_empty(self):
                return self.__head == None
                
            def length(self):
                cur = self.__head
                count = 0
                while cur != None:
                    conut += 1
                    cur = cur.next
                return count 
                
            def travel(self):
                cur = self.__head
                while cur != None:
                    print(cur.elem)
                    cur = cur.next
                
            def add(self,item):
                node = Node(elem)
                node.next = self.__head
                self.__head = node
                
            def insert(self,pos,item):
                if pos<=0:
                    self.add(item)
                elif pos > (self.length()-1):
                    self.append(item)
                else:
                    cur = self.__head
                    node = Node(elem)
                    conut = 0
                    while  count < (pos-1):
                        cur = cur.next
                        conut += 1
                    node.next = cur.next
                    cur.next = node 
                
            def append(self,item):
                node = Node(elem)
                if self.is_empty():
                    self.__head = node
                else:
                    cur = self.__head
                    while cur.next != None:
                        cur = cur.next
                    cur.next = node

            def remove(self,item):
                cur = self.__head
                pre = None
                while cur != None:
                    if cur.elem == item:
                        if cur == self.__head:
                            self.__head = cur.next
                        else:
                            pre.next = cur.next
                        break
                    else:
                        pre = cur
                        cur = cur.next
                
            def search(item):
                cur = self.__head
                while cur != None:
                    if cur.elem == item:
                        return True
                    else:
                        cur = cur.next 
                return False

雙向鏈表的建立：                 
    #節點的建立：                        
        class Node(object):                            
            def __init__(self,elem):
                self.elem = elem
                self.next = None
                self.prev = None
                
    #鏈的建立：                                  
        class LinkList(object):
            def __init__(self,node=None):
                self.__head = node
                
            def is_empty(self):
                return self.__head is None
                
            def length(self):
                cur = self.__head
                count = 0
                while cur != None:
                    conut += 1
                    cur = cur.next
                return count 
                
            def travel(self):
                cur = self.__head
                while cur != None:
                    print(cur.elem)
                    cur = cur.next
                
            def add(self,item):
                node = Node(elem)
                if self.is_empty():
                    self.__head = node
                else:
                    node.next = self.__head
                    self.__head.prev = node
                    self.__head = node
                
            def insert(self,pos,item):
                if pos<=0:
                    self.add(item)
                elif pos > (self.length()-1):
                    self.append(item)
                else:
                    cur = self.__head
                    node = Node(elem)
                    conut = 0
                    while  count < (pos-1):
                        cur = cur.next
                        conut += 1
                    node.next = cur.next
                    node.prev = cur
                    cur.next.prev = node
                    cur.next = node
                
            def append(self,item):
                node = Node(elem)
                if self.is_empty():
                    self.__head = node
                else:
                    cur = self.__head
                    while cur.next != None:
                        cur = cur.next
                    cur.next = node
                    node.prev = cur

            def remove(self,item):
                cur = self.__head            
                while cur != None:
                    if cur.elem == item:
                        if cur == self.__head:
                            self.__head = cur.next
                            if cur.next:
                                cur.next.prev = None
                        else:
                            cur.next.prev = cur.prev
                            if cur.next:
                                cur.prev.next = cur.next
                        break
                    else:
                        cur = cur.next
                
            def search(item):
                cur = self.__head
                while cur != None:
                    if cur.elem == item:
                        return True
                    else:
                        cur = cur.next 
                return False

單向循環鏈表的建立：                 
    #節點的建立：                        
        class Node(object):                            
            def __init__(self,elem):
                self.elem = elem
                self.next = None
                
    #鏈的建立：                                  
        class LinkList(object):
            def __init__(self,node=None):
                self.__head = node
                
            def is_empty(self):
                return self.__head is None
                
            def length(self):
                if self.is_empty():
                    return 0
                else:
                    cur = self.__head
                    count = 1
                    while cur.next != self.__head:
                        conut += 1
                        cur = cur.next
                    return count 
                
            def travel(self):
                if self.is_empty():
                    return 
                else:
                    cur = self.__head
                    while cur.next != self.__head:
                        print(cur.elem)
                        cur = cur.next
                    print(cur.item)
                
            def add(self,item):
                node = Node(elem)
                if self.is_empty():
                    self.__head = node
                    node.next = node
                else:
                    cur = self.__head
                    while cur.next != self.__head:
                        cur = cur.next
                    node.next = self.__head
                    self.__head = node
                    cur.next = node
                
                node.next = self.__head
                self.__head = node
                
            def insert(self,pos,item):
                if pos<=0:
                    self.add(item)
                elif pos > (self.length()-1):
                    self.append(item)
                else:
                    cur = self.__head
                    node = Node(elem)
                    conut = 0
                    while  count < (pos-1):
                        cur = cur.next
                        conut += 1
                    node.next = cur.next
                    cur.next = node 
                
            def append(self,item):
                node = Node(elem)
                if self.is_empty():
                    self.__head = node
                    node.next = node 
                else:
                    cur = self.__head
                    while cur.next != None:
                        cur = cur.next
                    cur.next = node
                    node.next = self.__head

            def remove(self,item):
                if self.is_empty():
                    return
                else:
                    cur = self.__head
                    pre = None
                    while cur.next != None:
                        if cur.elem == item:
                            if cur == self.__head:
                                r = self.__head
                                while r.next != self.__head:
                                    r = r.next
                                self.__head = cur.next
                                r.next = self.__head
                            else:
                                pre.next = cur.next
                            break
                        else:
                            pre = cur
                            cur = cur.next
                    if cur.elem == item:
                        if cur == self.__head:
                            self.__head = None
                        else:
                            pre.next = self.__head
                
            def search(item):
                cur = self.__head
                while cur.next != None:
                    if cur.elem == item:
                        return True
                    else:
                        cur = cur.next
                if cur.elem == item:
                    return True
                return False    
        
    
棧：
    #順序表實現棧:
        class Stack(object):
        def __init__(self):
            self.__list = []

        def push(self,item):
            self.__list.append(item)

        def pop(self):
            return self.__list.pop()

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

        def size(self):
            return len(self.__list)

        def peek(self):
            return self.__list[-1]
            
    #鏈表實現棧
        class Node(object):
            def __init__(self,item):
                self.item = item
                self.next = None

        class SingleLink(object):
            def __init__(self,node=None):
                self.__head = node

            def is_empty(self):
                return self.__head == None

            def length(self):
                if self.is_empty():
                    return 0
                else:
                    cur = self.__head
                    count = 0
                    while cur != None:
                        conut+= 1
                        cur = cur.next
                    return count

            def append(self,item):
                node = Node(item)
                if self.is_empty():
                    self.__head = node
                else:
                    cur = self.__head
                    while cur.next != None:
                        cur = cur.next
                    cur.next = node

            def display(self):
                cur = self.__head
                pre = None
                while cur != None:
                    pre = cur
                    cur = cur.next
                return pre.item

            def remove(self):
                if self.is_empty():
                    return 
                else:
                    cur = self.__head
                    pre = None
                    while cur.next != None:
                        pre = cur
                        cur = cur.next
                    if cur == self.__head:
                        self.__head = None
                        return cur.item
                    else:
                        pre.next = None
                        return cur.item

        class Stack(object):
            def __init__(self):
                self.__item = SingleLink()

            def push(self,item):
                self.__item.append(item)

            def pop(self):
                return self.__item.remove()

            def is_empty(self):
                return self.__item.is_empty()

            def size(self):
                return self.__item.length()

            def peek(self):
                 return self.__item.display()

        if __name__ == '__main__':
    
隊列：  
    Quque
        操做：
            Queue() 建立一個空的隊列
            enqueue(item) 往隊列中添加一個item元素
            dequeue() 從隊列頭部刪除一個元素
            is_empty() 判斷一個隊列是否爲空
            size() 返回隊列的大小
    #順序表實現
        
    #鏈表實現 
    
    雙端隊列（deque，全名double-ended queue），是一種具備隊列和棧的性質的數據結構。
    雙端隊列中的元素能夠從兩端彈出，其限定插入和刪除操做在表的兩端進行。雙端隊列能夠在隊列任意一端入隊和出隊。
    deque 
        操做：
            Deque() 建立一個空的雙端隊列
            add_front(item) 從隊頭加入一個item元素
            add_rear(item) 從隊尾加入一個item元素
            remove_front() 從隊頭刪除一個item元素
            remove_rear() 從隊尾刪除一個item元素
            is_empty() 判斷雙端隊列是否爲空
            size() 返回隊列的大小
    
    
排序算法
    #採用順序表    
    
    冒泡排序：
    def bubble_sort(alist):
        n = len(alist)
        for j in range(n-1):
            #count = 0  優化；表示遍歷一次發現沒有任何能夠交換的元素，排序結束
            for i in range(n-1-j):
                if alist[i] > alist[i+1]:
                    alist[i],alist[i+1] = alist[i+1],alist[i]
                    count += 1
            #if count == 0:
                #return 
        
    選擇排序：
    def select_sort(alist):
        n = len(alist)
        for j in range(n-1):
            min_index = j
            for i in range(j+1,n):
                if alist[min_index] > alist[i]:
                    min_index = i 
            alist[min_index],alist[j] = alist[j],alist[min_index]
    
    插入排序：
    def insert_sort(alist):
        n = len(alist)
        for j in range(1,n):
            i = j
            while i>0:
                if alist[i] < alist[i-1]:
                    alist[i], alist[i-1] = alist[i-1], alist[i]
                    i-= 1
                else:
                    break
    
    
    希爾排序：
    def shell_sort(alist):
        n = len(alist)
        gap = n//2
        
        while gap>0:
            for j in range(gap,n):
                i = j
                while i>0:
                    if alist[i] < alist[i-gap]:
                        alist[i], alist[i-gap] = alist[i-gap],alist[i]
                        i -= gap
                    else:
                        break
            gap = gap//2
    
    
    快速排序：
    def quick_sort(alist,start,end):
        if start>=end:
            return
        index = alist[start]
        low = start
        high = end
        while low<high:
            while low<high and alist[high]>index:
                high-=1
            alist[low] = alist[high]
            while low<high and alist[low]<=index:
                low+=1
            alist[high] = alist[low]        
        alist[low] = index
        quick_sort(alist,start,low-1)
        quick_sort(alist,low+1,end)
    
    歸併排序：
    *****
    
搜索：
    二分查找：
    1#遞歸版
    def binary_search(alist,item):
        n = len(alist)
        if n > 0:
            mid = n//2
            if alist[mid] == item:
                return True
            elif alist[mid]>item:
                return binary_search(alist[:mid],item)
            else:
                return binary_search(alist[mid+1:],item)
        return False
    
    2#非遞歸版
    def binary_search(alist,item):
        n = len(alist)
        first = 0
        last = n-1
        mid = (first+last)//2
        while first <= last:
            if alist[mid] == item:
                return True
            elif alist[mid] > item:
                last = mid-1
            else:
                first = mid+1
        return False
    
    
    
    二叉樹：
        插入：
            class Node(object):
                def __init__(self,item):
                    self.elem = item
                    self.lchild = None
                    self.rchild = None
            
            class Tree(object):
                def __init__(self):
                    self.root = None
                
                def add(self,item):
                    node = Node(item)
                    if self.root = None:
                        self.root = node
                        return 
                    queue = [self.root]
                    while queue:
                        cur_node = queue.pop(0)
                        if cur_node.lchild is None:
                            cur_node.lchild = node
                            return
                        else:
                            queue.append(cur_node.lchild)
                        if cur_node.rchild is None:
                            cur_node.rchild = node
                            return
                        else:
                            queue.append(cur_node.rchild)
                def breadth_travel(self):
                    #廣度遍歷
                    if self.root is None:
                        return 
                    queue = [self.root]
                    while queue:
                        cur_node = queue.pop(0)
                        print(cur_node.elem)
                        if not cur_node.lchild:
                            queue.append(cur_node.lchild)
                        if not cur_node.rchild:
                            queue.append(cur_node.rchild)
            
                def preorder(self,node):
                    if node is None:
                        return
                    print(node.elem)
                    self.preorder(node.lchild)
                    self.preorder(node.rchild)
                    
                def inorder(self,node):
                    if node is None:
                        return
                    self.inorder(node.lchild)
                    print(node.elem)
                    self.inorder(node.rchild)
                
                def postorder(self,node):
                    if node is None:
                        return
                    self.postorder(node.lchild)
                    self.postorder(node.rchild)
                    print(node.elem)