2022/9/10——单链表的python实现

关键：1.单链表由节点组成， 每个节点维护了自己的data和对下一个节点的next（即引用）

           2. 需要设置对第一个节点的引用，并且要让最后一个节点知道它后面没有其它节点

           3.单链表只提供一个接口， 所有的遍历操作都依赖于对第一个节点的引用

class Node:
    """这个类只在UnorderedList类中生成节点实例"""

    def __init__(self, data):
        """初始化节点属性"""
        self.data = data
        self.next = None

    def getData(self):
        """获取节点的data"""
        return self.data

    def getNext(self):
        """获取节点包含的下一个节点的引用"""
        return self.next

    def setNext(self, next):
        """设置节点包含的下一个节点的引用"""
        self.next = next

    def setData(self, data):
        """设置当前节点的data"""
        self.data = data


class UnorderedList:
    """无序表类"""

    def __init__(self):
        """初始化无序表"""
        self.head = None  # head引用指明列表中第一个元素的位置

    def add(self, data):
        """用于添加新节点到无序表中"""
        new_node = Node(data)
        new_node.setNext(self.head)  # 新加入的节点包含前一个节点的引用
        self.head = new_node  # head设置为对它的引用

    def length(self):
        """获取无序表当前的长度"""
        # 节点的遍历以来与head对第一个节点的引用。设置一个外部引用，开始时获得head的引用，获取到下一个节点的引用后，接着在获取下一个节点的引用知道这个外部引用变为None
        external_reference = self.head
        counter = 0  # 计数器，external_referenc每移动一个节点就加1
        while external_reference is not None:
            counter += 1
            external_reference = external_reference.getNext()
        return counter

    def search(self, data):
        """搜索是否存在指定元素"""
        external_reference = self.head
        found_signal = None
        while not found_signal and external_reference is not None:
            if external_reference.getData() == data:  # 通过外部引用获取节点data
                found_signal = True
            else:
                external_reference = external_reference.getNext()  # 外部引用移到下一节点
        return found_signal

    def remove(self, data):
        """移除无序表指定元素"""
        external_reference1 = self.head
        external_reference2 = None  # 维持两个外部引用
        found_signal = None
        while not found_signal and external_reference1 is not None:
            if external_reference1.getData() == data:
                found_signal = True
            else:
                external_reference2 = external_reference1  # 第二个外部引用设置为第一个外部引用
                external_reference1 = external_reference1.getNext()
        if external_reference2 is None:  # 如果第二个引用是None说明要移除的元素就是无序表的第一个节点
            self.head = external_reference1.getNext()  # 设置head为第一个外部引用的下一节点引用,删除它的办法就是跳过它
        else:
            external_reference2.setNext(external_reference1.getNext())  # 设置前一节点包含下一节点的引用

    def index(self, data):
        """获取指定元素的索引"""
        external_reference = self.head
        found_signal = None
        index = 0
        while not found_signal and external_reference is not None:
            if external_reference.getData() == data:
                return index
            else:
                external_reference = external_reference.getNext()
            index += 1
        return 'No such node'

    def append(self, data, index=None):
        """默认从无序表的尾端添加节点，或通过index参数指定位置添加节点"""
        external_reference1 = self.head
        external_reference2 = None
        current_index = 0
        try:
            if index is None:
                the_index = self.length()
            else:
                the_index = index
            while not current_index == the_index:
                external_reference2 = external_reference1
                external_reference1 = external_reference1.getNext()
                current_index += 1
            new_node = Node(data)
            if external_reference2 is None:#如果添加到index=0的位置，external_reference2应该是None
                self.head = new_node
            else:
                new_node.setNext(external_reference1)
                external_reference2.setNext(new_node)
        except:
            print('out of range')

    def pop(self, index=None):
        """默认删除并返回无序表中最后一个元素或通过index指定要删除的元素"""
        current_index = 0 #额外维护的索引，用于与index进行比较，看是不是找到了
        external_reference1 = self.head
        external_reference2 = None
        
        if index is None:  # 检查index有没有输入
            the_index = self.length() - 1
        else:
            the_index = index
        # 循环找到指定index然后删除它并返回删除值
        while current_index is not the_index:  #这个循环确定指定index对应的元素和前一个元素
            current_index+=1
            external_reference2=external_reference1
            external_reference1=external_reference1.getNext()
        if external_reference2 is None:
            self.head=external_reference1.getNext()
        else:
            external_reference2.setNext(external_reference1.getNext())