链表

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/kun1280437633/article/details/80787863

单链表demo：

class Node(object):
    """链表中的节点"""

    def __init__(self, item):
        # item 记录当前节点的内容
        self.item = item
        # next 记录下一个节点
        self.next = None

class SingleLinkList(object):
    """单向链表"""

    def __init__(self):
        # 只需要记录首节点
        self.__head = None

    def is_empty(self):
        """链表是否为空："""
        # 判断首节点是否有内容
        return self.__head is None

    def travel(self):
        """链表内容查看："""
        # 从首节点往后遍历
        # 定义游标变量指向头节点
        cur = self.__head
        while cur is not None:
            # 输出当前节点的内容
            print(cur.item, end=" ")
            # 让游标指向下一个节点
            cur = cur.next
        print()

    def add(self, item):
        """插头增: """
        # 创建新节点
        node = Node(item)
        # 1、让新节点的next指向老的头节点
        node.next = self.__head
        # 2、让head指向新节点
        self.__head = node

    def length(self):
        """链表元素数量："""
        # 遍历所有的节点，使用计数器变量累加节点个数
        count = 0
        cur = self.__head
        while cur is not None:
            count += 1
            # 让游标指向下一个节点
            cur = cur.next
        return count

    def append(self, item):
        """插尾增: """
        # 健壮性
        # 如果头节点为空
        if self.__head is None:
            self.add(item)
            return
        # 1、遍历找到尾节点
        cur = self.__head
        while cur.next is not None:
            # 让游标指向下一个节点
            cur = cur.next
        # while循环结束，cur指向是尾节点
        # 2、让尾节点指向新的节点
        node = Node(item)
        cur.next = node

    def insert(self, pos, item):
        """指定位置增:"""
        if pos <= 0:  # 如果pos<=0 插入到头
            self.add(item)
        elif pos >= self.length():  # 如果pos超出最大下标 追加到尾
            self.append(item)
        else:
            # 1、遍历找到pos位置的前一个节点
            cur = self.__head
            index = 0 #  记录当前游标对应的下标
            while index < (pos - 1):
                index += 1
                cur = cur.next
            # 当while循环结束时，cur指向的就是pos前一个节点
            # 2、让新节点指向pos位置的节点
            node = Node(item)
            node.next = cur.next
            #    让pos位置的前一个节点指向新节点
            cur.next = node

    def remove(self, item):
        """内容删除:"""
        # 遍历节点，定义pre记录当前节点的前一个节点
        cur = self.__head
        pre = None
        while cur is not None:
            if cur.item == item:
                # 如果pre为none，证明删除的是头节点
                if pre is None:
                    self.__head = cur.next
                else:
                    pre.next = cur.next
            pre = cur
            cur = cur.next

    def search(self, item):
        """链表内容搜索:"""
        # 从头遍历找item
        cur = self.__head
        while cur is not None:
            if cur.item == item:
                return True
            cur = cur.next
        # while循环结束还没找到，证明没有item数据
        return False

if __name__ == '__main__':

    # 创建链表对象
    sll = SingleLinkList()
    print("长度：",sll.length())
    print(sll.is_empty())
    sll.add(0)
    sll.add(1)
    print(sll.is_empty())
    sll.travel()
    sll.add(3)
    sll.add(4)
    sll.travel()
    print("长度：", sll.length())
    sll.append(5)
    sll.travel()
    sll.insert(2, 6)
    sll.travel()
    sll.insert(-10, 7)
    sll.travel()
    sll.insert(100, 8)
    sll.travel()
    sll.remove(3)
    sll.travel()
    sll.remove(7)
    sll.travel()
    print(sll.search(4))
    print(sll.search(0))
    print(sll.search(8))
    print(sll.search(10))

双向链表demo：

class Node(object):
    """链表中的节点"""

    def __init__(self, item):
        # item 记录当前节点的内容
        self.item = item
        # next 记录下一个节点
        self.next = None
        # pre 记录前一个节点
        self.pre = None

class DoubleLinkList(object):
    """双向链表"""

    def __init__(self):
        # 只需要记录首节点
        self.__head = None

    def is_empty(self):
        """链表是否为空："""
        # 判断首节点是否有内容
        return self.__head is None

    def travel(self):
        """链表内容查看："""
        # 从首节点往后遍历
        # 定义游标变量指向头节点
        cur = self.__head
        while cur is not None:
            # 输出当前节点的内容
            print(cur.item, end=" ")
            # 让游标指向下一个节点
            cur = cur.next
        print()

    def add(self, item):
        """插头增: """
        # 创建新节点
        node = Node(item)
        # 判断是否是空链表
        if self.is_empty():
            self.__head = node
            return

        # 1、让新节点的next指向老的头节点
        node.next = self.__head
        # 2、让老的头节点的pre指向新节点
        self.__head.pre = node
        # 3、让head指向新节点
        self.__head = node

    def length(self):
        """链表元素数量："""
        # 遍历所有的节点，使用计数器变量累加节点个数
        count = 0
        cur = self.__head
        while cur is not None:
            count += 1
            # 让游标指向下一个节点
            cur = cur.next
        return count

    def append(self, item):
        """插尾增: """
        # 健壮性
        # 如果头节点为空
        if self.__head is None:
            self.add(item)
            return
        # 1、遍历找到尾节点
        cur = self.__head
        while cur.next is not None:
            # 让游标指向下一个节点
            cur = cur.next
        # while循环结束，cur指向是尾节点
        # 2、让尾节点指向新的节点
        node = Node(item)
        cur.next = node
        # 让新节点的pre指向尾节点
        node.pre = cur

    def insert(self, pos, item):
        """指定位置增:"""
        if pos <= 0:  # 如果pos<=0 插入到头
            self.add(item)
        elif pos >= self.length():  # 如果pos超出最大下标 追加到尾
            self.append(item)
        else:
            # 1、遍历找到pos位置的前一个节点
            cur = self.__head
            index = 0 #  记录当前游标对应的下标
            while index < (pos - 1):
                index += 1
                cur = cur.next
            # 当while循环结束时，cur指向的就是pos前一个节点
            # 2、让新节点指向pos位置的节点
            node = Node(item)
            node.next = cur.next
            # 让当前pos位置的节点的pre指向新节点
            cur.next.pre = node
            #   让pos位置的前一个节点指向新节点
            cur.next = node
            # 让新节点的pre指向pos前一个节点
            node.pre = cur

    def remove(self, item):
        """内容删除:"""
        # 遍历节点，前一个节点通过当前节点的pre获取
        cur = self.__head
        while cur is not None:
            if cur.item == item:
                # 如果cur.pre 为空，证明删除的是首节点
                if cur.pre is None:
                    self.__head = cur.next
                else:
                    # 让当前节点的前一个节点的next指向当前节点的下一个节点
                    cur.pre.next = cur.next
                # 如果cur.next 为空，删除的是尾节点
                if cur.next is not None:
                    # 让当前节点的下一个节点的pre指向当前节点的前一个节点
                    cur.next.pre = cur.pre
            cur = cur.next

    def search(self, item):
        """链表内容搜索:"""
        # 从头遍历找item
        cur = self.__head
        while cur is not None:
            if cur.item == item:
                return True
            cur = cur.next
        # while循环结束还没找到，证明没有item数据
        return False

if __name__ == '__main__':

    # 创建链表对象
    sll = DoubleLinkList()
    print("长度：",sll.length())
    print(sll.is_empty())
    sll.add(0)
    sll.add(1)
    print(sll.is_empty())
    sll.travel()
    sll.add(3)
    sll.add(4)
    sll.travel()
    print("长度：", sll.length())
    sll.append(5)
    sll.travel()
    sll.insert(2, 6)
    sll.travel()
    sll.insert(-10, 7)
    sll.travel()
    sll.insert(100, 8)
    sll.travel()
    sll.remove(3)
    sll.travel()
    sll.remove(7)
    sll.travel()
    print(sll.search(4))
    print(sll.search(0))
    print(sll.search(8))

    print(sll.search(10))

单向循环链表demo:

class Node(object):
    """链表中的节点"""

    def __init__(self, item):
        # item 记录当前节点的内容
        self.item = item
        # next 记录下一个节点
        self.next = None

class SingleCycLinkList(object):
    """单向循环链表"""

    def __init__(self):
        # 只需要记录首节点
        self.__head = None

    def is_empty(self):
        """链表是否为空："""
        # 判断首节点是否有内容
        return self.__head is None

    def travel(self):
        """链表内容查看："""
        if self.is_empty():
            return
        # 从首节点往后遍历
        # 定义游标变量指向头节点
        cur = self.__head
        # 首节点不为空，直接输出首节点
        print(cur.item, end=" ")
        # 处理不了首节点
        while cur.next is not self.__head:
            # 让游标指向下一个节点
            cur = cur.next
            # 输出当前节点的内容
            print(cur.item, end=" ")

        print()

    def add(self, item):
        """插头增: """
        # 创建新节点
        node = Node(item)
        if self.is_empty():
            # 如果链表为空，添加节点后，自己的next指向自己
            self.__head = node
            node.next = self.__head
            return

        cur = self.__head
        # 遍历找到尾节点
        while cur.next is not self.__head:
            # 让游标指向下一个节点
            cur = cur.next
        # while循环结束，cur指向是尾节点
        # 1、让新节点的next指向老的头节点
        node.next = self.__head
        # 2、让head指向新节点
        self.__head = node
        # 3、让尾节点指向新的头
        cur.next = self.__head

    def length(self):
        """链表元素数量："""
        if self.is_empty():
            return 0
        # 遍历所有的节点，使用计数器变量累加节点个数
        count = 1
        cur = self.__head
        # 下面的计算少一个
        while cur.next is not self.__head:
            count += 1
            # 让游标指向下一个节点
            cur = cur.next
        return count

    def append(self, item):
        """插尾增: """
        # 健壮性
        # 如果头节点为空
        if self.__head is None:
            self.add(item)
            return
        # 1、遍历找到尾节点
        cur = self.__head
        while cur.next is not self.__head:
            # 让游标指向下一个节点
            cur = cur.next
        # while循环结束，cur指向是尾节点
        # 2、让尾节点指向新的节点
        node = Node(item)
        cur.next = node
        # 3、让新的尾节点指向头节点
        node.next = self.__head

    def insert(self, pos, item):
        """指定位置增:"""
        if pos <= 0:  # 如果pos<=0 插入到头
            self.add(item)
        elif pos >= self.length():  # 如果pos超出最大下标 追加到尾
            self.append(item)
        else:
            # 1、遍历找到pos位置的前一个节点
            cur = self.__head
            index = 0 #  记录当前游标对应的下标
            while index < (pos - 1):
                index += 1
                cur = cur.next
            # 当while循环结束时，cur指向的就是pos前一个节点
            # 2、让新节点指向pos位置的节点
            node = Node(item)
            node.next = cur.next
            #    让pos位置的前一个节点指向新节点
            cur.next = node

    def remove(self, item):
        """内容删除:"""
        if self.is_empty():
            return
        # 遍历节点，定义pre记录当前节点的前一个节点
        cur = self.__head
        pre = None
        while cur.next is not self.__head:
            if cur.item == item:
                # 如果pre为空，证明删除的是头
                if pre is None:
                    # 让head指向当前节点的下一个节点，让尾节点指向新的头
                    temp = self.__head
                    while temp.next is not self.__head:
                        temp = temp.next
                    # temp指向尾节点
                    self.__head = cur.next
                    temp.next = self.__head
                else:
                    pre.next = cur.next
            pre = cur
            cur = cur.next
        # while循环处理不了尾节点，循环结束后单独处理尾节点
        if cur.item == item:
            # 如果pre为空，证明链表只有一个节点，而且要删的就是这个节点
            if pre is None:
                self.__head = None
            else:
                # 让尾节点的前一个节点指向头节点
                pre.next = self.__head

    def search(self, item):
        """链表内容搜索:"""
        if self.is_empty():
            return False
        # 从头遍历找item
        cur = self.__head
        if cur.item == item:
            return True
        # 处理不了首节点
        while cur.next is not self.__head:
            cur = cur.next
            if cur.item == item:
                return True
        # while循环结束还没找到，证明没有item数据
        return False

if __name__ == '__main__':

    # 创建链表对象
    sll = SingleCycLinkList()
    print("长度：",sll.length())
    print(sll.is_empty())
    sll.add(0)
    sll.add(1)
    print(sll.is_empty())
    sll.travel()
    sll.add(3)
    sll.add(4)
    sll.travel()
    print("长度：", sll.length())
    sll.append(5)
    sll.travel()
    sll.insert(2, 6)
    sll.travel()
    sll.insert(-10, 7)
    sll.travel()
    sll.insert(100, 8)
    sll.travel()
    sll.remove(3)
    sll.travel()
    sll.remove(7)
    sll.travel()
    sll.remove(8)
    sll.travel()
    print(sll.search(4))
    print(sll.search(0))
    print(sll.search(5))
    print(sll.search(10))