数据结构（一）链表

在逐渐的编程过程中，发现数据结构和算法很重要，虽然自己本科时候学过数据结构，但主要是以理论为主并没有编程实现，所以感觉对它的了解还不是很透彻（but 数据结构当时可是考满分呢hhhh）

那就重新再捡起来，好好透彻地实战一下啦！这次用python进行数据结构的实现

参考资料：

https://www.bilibili.com/video/av66834101/?p=5

那我主要想关注的点 是一下几个：

1. 各种排序算法
2. 基础数据结构和算法的实现：堆、二叉树、图
3. 基础数据结构的使用：链表、栈、队列、哈希表、图、trie、并查集等
4. 基础算法思想：深度优先、广度优先、二分查找、递归等
5. 算法设计层面：递归、分治、回溯搜索、贪心、动态规划

ADT方法

#用抽象数据类型，选定合适的数据结构进行相关操作(增加、删除、修改、查找、排序等)
class Bag(object):
    def __init__(self,maxlength=10):
        self.maxlength=maxlength
        self._items=list()

    def add(self,item):
        # if len(self)>self.maxlength:
        #     raise Exception("bag is full")
        self._items.append(item)

    def remove(self,item):
        self._items.remove(item)


    def len(self):
        return len(self._items)

    def iter(self):
        for item in self._items:
            print(item)

def test_bag():
    bag=Bag()
    bag.add(1)
    bag.add(3)
    bag.add(5)
    bag.remove(3)
    bag.iter()

test_bag()

一、线性结构-Array

特点：内存连续、通过下标进行访问，在python 中主要是list和set

list的内存分配策略：分配0,4,8,16,25,35,46,58等，而非一个一个进行分配

顺序表存储数据类型相同的元素

class Array(object):
    def __init__(self,size):
        self.__size=size
        self.__items=[None]*size

    def __getitem__(self, key):
        return self.__items[key]

    def __setitem__(self, key, value):
        self.__items[key]=value

    def __len__(self):
        return self.__size

    def clear(self):
        for i in range(self.__size):
            self.__items[i]=None

    def __iter__(self):
        for i in range(self.__size):
            yield i

test_array=Array(32)
test_array[0]=5
assert test_array[0]==5
test_array.clear()
assert test_array[0] is None
assert len(test_array)==32

二、顺序表

即线性表，具有存元素和元素外置两种形式，元素外置是指在线性表中保存每个元素的地址

三、链式结构

特点：内存不连续，不能通过下标进行访问，find操作麻烦

单链表：root→head→Node→Node→Node→。。。→tail

对于单个Node而言，包括value和next(下一个节点的地址)

linked list：包括data和method,data(root,length),method(init,remove,add,popleft,clear,append-left等)

只考虑整型、浮点型和字符串类型，而忽略Python内置的list set dict等

单链表

#sigle_linked_list
#coding:utf-8
class Node(object):
    def __init__(self,value,next=None):
        self.value=value
        self.next=next

#add(3) remove len iter is_empty
class Linked_list(object):

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

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

    def length(self):
        current_node=self.__head
        count=0
        while current_node!=None:
            count+=1
            current_node=current_node.next
        return count

    def travel(self):
        current_node=self.__head
        while current_node!=None:
            print(current_node.value)
            current_node=current_node.next

    #add element in head
    def add(self,value):
        node=Node(value)
        if self.__head==None:
            self.__head=node
        else:
            node.next=self.__head
            self.__head=node

    #add element in tail
    def append(self,value):
        node=Node(value)
        if self.__head==None:
            self.__head=node
        else:
            cur=self.__head
            while cur.next!=None:
                cur=cur.next
            cur.next=node

    #insert the element to the certain position
    def insert(self,pos,value):
        if pos==0:
            self.add(value)
        elif pos==self.length()-1:
            self.append(value)
        else:
            node = Node(value)
            cur = self.__head
            count = 0
            while cur.next!=None:
                if count+1==pos:
                    node.next=cur.next
                    cur.next=node
                cur=cur.next
                count+=1
    def revere(self):
        cur=self.__head
        iter_signal=self.__head
        pre=None
        while iter_signal!=None:
            cur=iter_signal
            cur.next=pre
            pre=iter_signal
            iter_signal=iter_signal.next




    def remove(self,value):
        if self.search(value)==False:
            return "not exist"
        else:
            cur=self.__head
            pre=None
            if cur.value==value:
                self.__head=None
            else:
                while cur!=None:
                    if cur.value==value:
                        pre.next=cur.next
                    pre=cur
                    cur=cur.next

    def search(self,value):
        cur=self.__head
        while cur!=None:
            if cur.value==value:
                return True
            else:
                cur = cur.next
        return False


if __name__=="__main__":
    sll=Linked_list()
    # print(sll.is_empty()==True)
    sll.add(5)
    sll.append(3)
    sll.insert(1,10)
    sll.remove(3)
    print(sll.search(10))
    print(sll.length())
    print(sll.revere().travel())

双链表：

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

class Double_linked_list(object):

    def __init__(self):
        self.__head=None

    def len(self):
        count=0
        cur=self.__head
        while cur!=None:
            count+=1
        return count

    #头插法
    def add(self,value):
        node=Node(value=value)
        if self.__head==None:
            self.__head=node
        else:
            node.next=self.__head
            self.__head=node

    #尾插法：
    def append(self,value):
        node=Node(value)
        if self.__head==None:
            self.__head=node
        else:
            cur = self.__head
            while cur!=None:
                cur=cur.next
            node.pre=cur
            cur.next=node

    #中间插
    def insert(self,pos,value):
        node=Node(value)
        if pos==0:
            self.add(value)
        elif pos==self.len()-1:
            self.append(value)
        else:
            cur=self.__head
            pre_node=None
            next_node=None
            count=0
            while cur!=None:
                count+=1
                if count==pos+1:
                    node.next=cur.next
                    node.pre=cur
                    next_node.pre=node
                cur=cur.next
                pre_node=cur.pre
                next_node=cur.next


if __name__=="__main__":
    dll=Double_linked_list()
    dll.add(5)
    # dll.add(6)
    # dll.append(10)
    print(dll.len())