链表

单向链表

class Node:
    def __init__(self, elem):
        '''节点'''
        
        #存放数据元素
        self.elem = elem
        #下一个节点的标识，一开始不知道下一个节点是谁，指定为空
        self.next = None
        
        
class SingleLinkList:
    '''单链表'''
    
    def __init__(self,node=None):
        self.__head = None
        
    # __head为私有变量，仅在内部使用.  __head初始值为None，判断空表即判断 _head是否为None
    def is_empty(self):
        """链表是否为空"""
        return self.__head == None
    
    #count变量用来记录链表长度，定义一个游标cur,指向__head，_head初始为None，当走到最后一个节点时，因为python左开右闭，所以需要用当前的
    #数据来做判断，最后一个节点后面没有节点了，即为None，以这两个当作循环停止条件，即cur不为None
    def lenght(self):
        """返回链表长度"""
         #游标，用来移动遍历节点
        cur = self.__head
        #记录数量
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count
    
    #同判断长度一样，不同的是循环时直接讲内容打印出来即可，没输出完一个就讲游标往后移动一位，直到游标的值等于None
    def travel(self):
        """遍历整个链表"""
        cur = self.__head
        while cur != None:
            print(cur.elem,end=' ')
            cur = cur.next
        print()
    def add(self,item):
        """链表头部添加元素（头插法）"""
        node = Node(item)
        node.next = self.__head
        self.__head = node
    
    # item为新传入的数据，需要先将数据变为节点，调用Node类的构造方法，如果_head指向的是None无法进入循环,则说明还没有数据传入过，第一次传入
    #需要单独处理，让_head指向当前item。当__head不再指向None,则可以进入循环，因为是向后面追加，所以最后一个节点指向新传入的数据形成的节点
    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
    
    #如果要在2的位置插入节点 ，那么是要对指向2位置的指针的方向进行调整，也就是1的指针，所以要操作的位置为 pos-1，当指针指向这个位置时循环结束
    #先将新节点的指针指向当前位置所指向的节点（2的位置），再把当前节点指向新的节点，如果指定要插入的位置小于0或大于链表的长度，
    #说明说要进行头插或者尾插
    def insert(self,pos,item):
        """插入：指定位置添加元素
           pos 从0开始
        """
        if pos < 0:
            self.add(item)
        elif pos > self.lenght() - 1:
            self.append(item)
        else:
            node = Node(item)
            pre = self.__head
            count = 0
            while count < pos - 1:
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node
        
    #两个指针，一快一慢相差一个节点，方便调整指向，还是利用遍历找 与给定要找的值相等的 cur.elem ，特殊情况为在头部和尾部
    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
                print('Delect Success')
                return True
            else:
                pre = cur
                cur = cur.next
        print('No Node')
        return False
        
    #遍历每一个节点，找与给定要找的值相等的 cur.elem，count记录下标位置
    def search(self,item):
        """查找节点是否存在"""
        cur = self.__head
        count = 0
        while cur != None:
            if cur.elem == item:
                print('Search Success',count)
                return True
            else:
                cur = cur.next
            count += 1
        print('No Node')
        return False

if __name__ == "__main__":
    ll = SingleLinkList()  
    print(ll.is_empty())
    print(ll.lenght())
    
    ll.append(1)
    print(ll.is_empty())
    print(ll.lenght())
    
    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.travel()
    ll.insert(2,30)
    ll.travel()
    ll.insert(20,100)
    ll.travel()
    ll.insert(-2,9)
    ll.travel()
    ll.search(9)
    ll.remove(30)

#True
#0
#False
#1
#8 1 2 3 4 5 6 
#8 1 30 2 3 4 5 6 
#8 1 30 2 3 4 5 6 100 
#9 8 1 30 2 3 4 5 6 100 
#Search Success 0
#Delect Success

双向链表