数据结构之链表

数据结构重点在于存储数据

一顺序表，存储元素的时候可以通过o(1)实现

表头：容量，个数     例如： int类型 4byte（4字节）  32位

数据区：所存放的数据

二链表：节点与节点直接靠链表联系，不需要预定内存。不需要连续的内存，每个节点包含两个域，一个是数据区，链接区

单向链表：链表的方向是单向的，从头指向尾

对于python  a=10指的是a的地址指向10

对于c       int a=10 指的是a的存储空间放进了10

链表和顺序表对比

1链表与顺序表都是线性表，

顺序表：将元素顺序地存放在一块连续的存储区域，元素箭的顺序关系有他们的存储顺序自然表示

链表：将元素存放在通过链表构造起来的一系列存储块中

时间复杂度对比：

操作	链表	顺序表
访问元素	o(n)	o(1)
在头部插入/删除	o(1)	o(n)
在尾部插入/删除	o(n)	o(1)
在中间插入/删除	o(n)	o(n)

单链表

class Node(object):
    def __init__(self,elem):
        self.elem=elem
        self.next=None
class SingleLinkList(object):
    def __init__(self,node=None):
        self._head=node
    #判断链表是否为空
    def is_empty(self):
        return self._head==None

    #链表长度
    def length(self):
        #cur游标，用来移动遍历节点
        cur=self._head
        #count记录数量
        count=0
        while cur!=None:
            count += 1
            cur=cur.next
        return count

    #遍历整个链表
    def travel(self):
        cur=self._head
        while cur!=None:
            print(cur.elem,end=' ')
            cur=cur.next


    #链表头部添加元素,item是具体的数值，所以一开始需要把item封装成节点
    def add(self,item):
        node=Node(item)
        node.next=self._head
        self._head=node



    #链表尾部添加元素
    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 insert(self,pos,item):
        if pos<=0:
            self.add(item)
        elif pos>=self.length():
            self.append(item)
        else:
            node=Node(item)
            count=0
            pre=self._head
            while count<pos:
                count+=1
                pre=pre.next
            node.next=pre.next
            pre.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
                    # pre.next=pre.next.next
                break
            else:
                pre=cur
                cur=cur.next

    #查找节点是否存在
    def search(self,item):
        cur=self._head
        while cur.next!=None:
            if cur.elem==item:
                return True
            else:
                cur=cur.next
        return False


if __name__=='__main__':

    ll=SingleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.insert(-1,0)
    ll.append(4)
    ll.add(9)
    ll.append(7)
    ll.append(1)
    ll.travel()
    print('\n')

    ll.remove(9)
    ll.travel()
    print('\n')
    ll.remove(7)
    ll.travel()
    print('\n')

三双向链表，头指向尾，尾指向头，前驱节点pre，数据，后继节点next

#链表头部添加元素,item是具体的数值，所以一开始需要把item封装成节点
def add(self,item):
    node=Node(item)
    node.next=self._head
    self._head=node
    node.next.pre=node
    # node=Node(item)
    # node.next=self._head
    # self._head.pre=node
    # self._head=node
        

 #链表尾部添加元素
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
       node.pre=cur

 #指定位置添加元素
def insert(self,pos,item):
    if pos<=0:
        self.add(item)
    elif pos>=self.length():
        self.append(item)
    else:
        node=Node(item)
        count=0
        cur=self._head
        while count<pos:
            count+=1
            cur=cur.next
        node.next=cur
        node.pre=cur.pre
        cur.pre.next=node
        cur.pre=node
        # node.next = cur
        # node.pre = cur.pre
        # cur.pre = node
        # node.pre.next = node

# #删除节点
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.pre=None
            else:
                cur.pre.next=cur.next
                if cur.next:
                    cur.next.pre=cur.pre
            break
        else:
            cur=cur.next

class Node(object):
    def __init__(self,elem):
        self.elem=elem
        self.next=None
        self.pre=None
class DoubleLinkList(object):
    def __init__(self,node=None):
        self._head=node
    #判断链表是否为空
    def is_empty(self):
        return self._head==None

    #链表长度
    def length(self):
        #cur游标，用来移动遍历节点
        cur=self._head
        #count记录数量
        count=0
        while cur!=None:
            count += 1
            cur=cur.next
        return count

    #遍历整个链表
    def travel(self):
        cur=self._head
        while cur!=None:
            print(cur.elem,end=' ')
            cur=cur.next

    #链表头部添加元素,item是具体的数值，所以一开始需要把item封装成节点
    def add(self,item):
        node=Node(item)
        node.next=self._head
        self._head=node
        node.next.pre=node
        # node=Node(item)
        # node.next=self._head
        # self._head.pre=node
        # self._head=node

    #链表尾部添加元素
    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
            node.pre=cur

    #指定位置添加元素
    def insert(self,pos,item):
        if pos<=0:
            self.add(item)
        elif pos>=self.length():
            self.append(item)
        else:
            node=Node(item)
            count=0
            cur=self._head
            while count<pos:
                count+=1
                cur=cur.next
            node.next=cur
            node.pre=cur.pre
            cur.pre.next=node
            cur.pre=node
            # node.next = cur
            # node.pre = cur.pre
            # cur.pre = node
            # node.pre.next = node

    # #删除节点
    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.pre=None
                else:
                    cur.pre.next=cur.next
                    if cur.next:
                        cur.next.pre=cur.pre
                break
            else:
                cur=cur.next

    #查找节点是否存在
    def search(self,item):
        cur=self._head
        while cur.next!=None:
            if cur.elem==item:
                return True
            else:
                cur=cur.next
        return False


if __name__=='__main__':

    dll=DoubleLinkList()
    print(dll.is_empty())
    print(dll.length())

    dll.append(2)
    dll.insert(-1,0)
    dll.append(4)
    dll.add(9)
    dll.append(7)
    dll.append(1)
    dll.travel()
    print('\n')
    dll.insert(10,200)
    dll.travel()
    print('\n')
    dll.remove(9)
    dll.travel()
    print('\n')
    dll.remove(7)
    dll.travel()
    print('\n')
    dll.remove(200)
    dll.travel()

四单链表循环

 #链表头部添加元素,链表为空，链表只有一个元素，多个元素
def add(self,item):
    node=Node(item)
    if self._head==None:
        self._head=node
        node.next=node
    else:
        cur=self._head
        while cur.next!=self._head:
            cur=cur.next
        #退出循环，cur指向尾结点
        node.next=self._head
        self._head=node
        cur.next=self._head

class Node(object):
    def __init__(self,elem):
        self.elem=elem
        self.next=None
class SingleCycleLinkList(object):
    def __init__(self,node=None):
        self._head=node
        if node:
            node.next=node
    #判断链表是否为空
    def is_empty(self):
        return self._head==None

    #链表长度
    def length(self):
        if self.is_empty():
            return 0
        #cur游标，用来移动遍历节点
        cur=self._head
        #count记录数量
        count=1
        while cur.next!=self._head:
            count += 1
            cur=cur.next
        return count

    #遍历整个链表
    def travel(self):
        cur=self._head
        while cur.next!=self._head:
            print(cur.elem)
            cur=cur.next
       #退出循环，cur指向尾结点，但尾结点的元素未打印
        print(cur.elem, end=' ')
        print('')


    #链表头部添加元素,item是具体的数值，所以一开始需要把item封装成节点
    def add(self,item):
        node=Node(item)
        if self._head==None:
            self._head=node
            node.next=node
        else:
            cur=self._head
            while cur.next!=self._head:
                cur=cur.next
            #退出循环，cur指向尾结点
            node.next=self._head
            self._head=node
            cur.next=self._head

    #链表尾部添加元素
    def append(self,item):
        node=Node(item)
        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
            cur.next=node

    #指定位置添加元素
    def insert(self,pos,item):
        if pos<=0:
            self.add(item)
        elif pos>=self.length():
            self.append(item)
        else:
            node=Node(item)
            count=0
            pre=self._head
            while count<pos:
                count+=1
                pre=pre.next
            node.next=pre.next
            pre.next=node

    # #删除节点
    def remove(self,item):
        if self.is_empty():
            return
        cur=self._head
        pre=None
        while cur.next!=self._head:
            if cur.elem==item:
                # 先判断此节点是否是头结点
                if cur==self._head:
                    #头结点的情况找尾结点
                    rear=self._head
                    while rear.next!=self._head:
                        rear=self._head
                    self._head=cur.next
                    rear.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=cur.next
    #查找节点是否存在
    def search(self,item):
        cur=self._head
        while cur.next!=self._head:
            if cur.elem==item:
                return True
            else:
                cur=cur.next
        if cur.elem==item:
            return True
        return False


if __name__=='__main__':

    ll=SingleCycleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.insert(-1,0)
    ll.append(4)
    ll.add(9)
    ll.append(7)
    ll.append(1)
    ll.travel()
    print('\n')

    ll.remove(9)
    ll.travel()
    print('\n')
    ll.remove(7)
    ll.travel()
    print('\n')