Python实现单链表

#链表操作
#链表是由内存空间上不连续的节点构成的.其中每个节点的内容由两部分组成,一部分是当前节点的数据,一部分是下一个节点的地址.


'''

# 节点类最基本的功能包括：更新数据，查询数据，更新后继节点和查询后继节点。
class Node(object):
    #初始化，需要传入节点的数据
    def __init__(self, data):
        self.data = data
        self.next = None
    
    #返回节点的数据
    def get_data(self):
        return self.data
    
    #更新节点的数据
    def set_data(self, new_data):
        self.data = new_data
        
    #返回后继节点
    def get_next(self):
        return self.next
    
    #变更后继节点
    def set_next(self, new_next):
        self.next = new_next


#定义一个包含头结点的单链表.链表的主要功能包括：节点的增加、删除和查询，返回链表的长度，返回链表是否为空等
#链表类
class Linked_list(object):
    #初始化，头结点为空
    def __init__(self):
        self.head = None
        # self.data=0

    def add_front(self,new_val):
        new_node=Node(new_val)
        new_node.set_next(self.head)#完成前插操作,将头结点放在待插入节点的后面
        self.head = new_node#将头节点变为插入的节点

    #添加节点，添加的新节点作为新的头结点
    def add_behind(self, new_val):
        if self.head==None:
            new_node = Node(new_val)
            self.head=new_node
        else:
            new_node.set_next(self.head.next)#将待插入节点的next指向当前节点的下一个节点
            self.head.set_data(new_node)#将待插入节点插入当前节点.


    #包含查询，传入值，返回该值在链表中是否存在
    def search(self, data):
        checking = self.head #从头结点开始查询
        while checking != None :
            if checking.get_data() == data: #查找到，返回True
                return True
            checking = checking.get_next() #查询下一个节点
        return False #遍历到最后也未能找到，返回False
        
    #删除节点，将第一个具有传入值的节点从链表中删除,data为待删除的值
    def remove(self, data):
        checking = self.head #从头结点开始查询
        previous = None #记录前一个节点，头结点的前一个节点为None
        
        while checking != None :
            if checking.get_data() == data: #查找到，跳出查找循环
                break
            previous = checking # 更新前一个节点
            checking = checking.get_next() #查询下一个节点
            
        if previous == None:#如果头结点便是查找的节点
            self.head = checking.get_next()
        else: # 查找的节点不在头结点，即，存在前驱节点
            previous.set_next(checking.get_next())
    
    #判断链表是否为空
    def isEmpty(self):
        return self.head == None
    
    #返回链表长度
    def size(self):
        count = 0
        counting = self.head #从头结点开始计数
        while counting != None :
            count += 1
            counting = counting.get_next()
        return count




# 节点类最基本的功能包括：更新数据，查询数据，更新后继节点和查询后继节点。
'''
class Node:
    def __init__(self,val):
        self.data=val
        self.next=None
    
    def get_data(self):
        return self.data
    
    def set_data(self,new_val):
        self.data=new_val
    
    def get_next(self):
        return self.next
    
    def set_next(self,new_node):
        self.next=new_node




#定义一个包含头结点的单链表.链表的主要功能包括：节点的增加、删除和查询，返回链表的长度，返回链表是否为空等
class SingleLinklist_node:
    def __init__(self,node=None):
        self.head=node
    
    def add_front(self,new_add_val):
        new_node= Node(new_add_val)
        new_node.set_next(self.head)
        self.head=new_node
    
    def add_behind(self,new_add_val):   
        new_node=Node(new_add_val)
        if self.head==None:
            self.head=new_node
        else:
            new_node.set_next(self.head.get_next())
            # self.head.next=new_node
            self.head.set_next(new_node)
    
    def search_val(self,target_val):
        #从头节点开始查找
        cur_node=self.head
        while cur_node!=None:
            if cur_node.get_data() ==target_val:
                # break
                return True
            else:
                cur_node=cur_node.get_next()
        return False


    #假设链表中存在要删除的节点.
    def remove_node(self,target_val):
        previous_node=None
        checking_node=self.head
        # if checking_node ==None:
        #     return False

        # elif checking_node.data==target_val:#头节点的值就是要删除的值.
        #     self.head=self.head.get_next()

        # else:
        #     # previous_node=checking_node
        #     while checking_node !=None:
        #         previous_node=checking_node
        #         checking_node=checking_node.get_next()
        #         if checking_node.data==target_val:
        #             previous_node.set_next(checking_node.get_next())
        #             break
        #     return True
        # # if checking_node==None:
        # #     return False
        while checking_node!=None:
            if checking_node.data==target_val:
                break
            previous_node=checking_node
            checking_node=checking_node.get_next()
        
        #判断第一个节点是不是为目标节点
        if previous_node==None:
            self.head=self.head.set_next()
        else:
            previous_node.set_next(checking_node.get_next())


    def is_Empty(self):
        if self.head==None:
            return True
        else:
            return False

    def count_linklist_lenth(self):
        count=0
        counting_node=self.head
        while counting_node !=None:
            count=count+1
            counting_node=counting_node.get_next()
        return count                

        

class OrderlinkList:
    def __init__(self):
        self.head=None
        self.data=None
    
    #从小到大排序
    def add_new_node(self,new_node_data):
        new_node=Node(new_node_data)
        previous_node=None
        checking_node=self.head
        # 1.添加在头结点位置
        if previous_node==None:
            new_node.set_next(new_node)
            self.head=new_node

        # 2.当前列表后面或者链表的最后端添加节点
        while(checking_node != None):
            if new_node_data>checking_node.data:
                checking_node.set_next(new_node)
                new_node_data.set_next(checking_node.get_next())
                
            else:
                previous_node=checking_node
                checking_node.set_next(checking_node.get_next())

            
    def search_node(self,target_val):
        checking_node=self.head
        if self.is_Empty_node:
            return False
        
        while checking_node !=None:
            checking_data=checking_node.data
            if checking_data == target_val:
                return True
            else:
                checking_node=checking_node.get_next()
        return False

    
    def remove_node(self,target_val):
        is_exit_target=self.search_node(target_val)
        if is_exit_target:
            previous_node=None
            checking_node=self.head
            while checking_node !=None:

                #如果头结点就是要查找的目标节点
                if checking_node.data==target_val:
                    break
                previous_node=checking_node
                checking_node=checking_node.get_next()
            
            #如果头结点就是要查找的目标节点,则去除头结点
            if previous_node==None:
                self.head=self.head.get_next()
            
            else:
                previous_node.set_next(checking_node.get_next())
        else:
            print('Current Linklist has such  a {0} value!'.format(target_val))
            return False



    # def remove_node(self,target_val):
    #     previous_node=None
    #     checking_node=self.head

    #     if self.search_node(target_val):
    #         while checking_node !=None:
    #             if checking_node.data==target_val:
    #                 break
    #             previous_node=checking_node
    #             checking_node=checking_node.get_next()

    #         if previous_node==None:
    #             self.head=self.head.get_next()
    #         else:
    #             previous_node.set_next(checking_node.get_next())            

    def is_Empty_node(self):
        if self.head==None:
            return True
        else:
            return False
    
    def get_Linklistsize(self):
        linklist_lenth=0
        checking_count_node=self.head
        while checking_count_node != None:
            linklist_lenth+=1
            checking_count_node=checking_count_node.get_next()
        return linklist_lenth