基于python实现单链表代码 Marathon

"""
linklist.py
单链表的构建与功能操作
重点代码
"""

class Node:
    """
    思路：将自定义的类视为节点的生成类，
            实例对象中包含数据的部分和下一个节点的next
    """
    def __init__(self,val,next = None):
        self.val =  val # 有用数据
        self.next = next # 循环下一个节点的关系

# node1 = Node(1)
# node2 = Node(2,node1)
# node3 = Node(3,node2)

class LinkList:
    """
    思路：单链表类，生成对象可以进行增删改查操作
            具体操作通过调用具体方法完成
    """
    def __init__(self):
        """
        初始化链表，标记一个链表的开端，以便于获取后续的值
        """
        self.head = Node(None) # 定义开端
    # 通过为list_为链表添加一组节点
    def init_list(self,list_):
        p = self.head # p 作为移动变量
        for item in list_:
            p.next = Node(item)
            p = p.next

    # 遍历链表
    def show(self):
        p = self.head.next # 第一个有限节点
        while p is not None:
            print(p.val)
            p = p.next # p 向后移动

    # 判断链表为空
    def is_empty(self):
        if self.head.next is None:
            return True
        else:
            return False

    # 清空链表 断开head
    def clear_linklist(self):
        self.head.next = None

    # 增加节点
    def add_node(self):
        """ 链表不在尾部增加，因为要遍历到尾部

        """
        pass

    # 尾部插入节点,比列表插入慢
    def insert_end(self,val):
        p = self.head
        while p.next is not None:
            p = p.next
            p.next = Node(val)

    # 头部插入，速度快
    def insert_head(self,val):
        node = Node(val) # 1.新建节点
        node.next = self.head.next # 新节点指向原第二节点
        self.head.next = node # head 节点

    # 指定插入 难度***
    def insert_appoint(self,index,val):
        # 注意循环的临界问题,和头部插入类似
        p = self.head
        for i in range(index):
            # 如果index 值过大，退出循环
            if p.next is None:
                break
            p = p.next
        node = Node(val)
        node.next = p.next
        p.next = node

    # 删除节点 效率比列表快，不需要内存的移动
    def delete_node(self,x):
        p = self.head
        # 结束循环，必定条件有假,先判断是不是none,短路原则
        while p.next and p.next.val != x:
            p = p.next
        if p.next is None:
            raise ValueError("x not in linklist")
        else:
            p.next = p.next.next

    # 获取某个节点的值,传入节点位置，
    def get_node(self,index):
        if index < 0: # 判断索引值是否有误
            raise IndexError("index out of range")
        p = self.head.next
        for i in range(index):
            if p.next is None:
                raise  IndexError("list index out of range")
            p = p.next
        return p.val

    # 将第二个列表合并到第一个列表中，正序排列
    def merge_linklist(list1, list2):
        """
        p 指向l1-head,q 指向l2-元素2，p.next值和q比较
        如果比q小，p向后移动,此时p.next为3，大于2，令中间变量
        指向p.next,让p指向q,让q等于中间变量，p向后走指向2，重复
        上述操作，不用开辟第三个链表

        :param l1:
        :param l2:
        :return:
        """
        p = list1.head  # p指向l1头
        q = list2.head.next  # q指向l2的元素2
        while p.next is not None:
            if p.next.val < q.val:
                p = p.next
            else:
                # 前两必须标记，后两可以不按顺序
                tmp = p.next
                p.next = q
                p = p.next
                q = tmp
        p.next = q

#------测试代码-------
#if __name__ == "__main__":
# l = LinkList()
# # l.head.next = Node(1)
# # print(l.head.next.val) # 1
# l.init_list([1,2,3,4,5])
# l.show()