python链表

只因为你温柔

已于 2022-12-12 12:22:47 修改

阅读量1.1k

点赞数 7

CC 4.0 BY-SA版权

分类专栏： # python数据结构与算法文章标签： python链表

于 2019-05-05 13:40:56 首次发布

本文链接：https://blog.youkuaiyun.com/zsx1314lovezyf/article/details/89843536

python数据结构与算法专栏收录该内容

4 篇文章

订阅专栏

博客主要围绕Python链表展开，介绍了单向链表、双向链表和单向循环链表等不同类型的链表。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

python链表

单向链表

class Node(object):
    """结点"""
    def __init__(self,elem):
        self.elem = elem # 数据域
        self.next = None # 指针域


class SingleNode(object):
    """单链表"""

    def __init__(self,node=None):
        self.__head = node # 链表链接

    def is_empty(self):
        """链表是否为空"""
        return self.__head == None

    def length(self):
        """链表长度"""
        # cur 游标,用来移动遍历节点
        cur = self.__head
        # count记录数量
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    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

    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

    def insert(self,pos, item):
        """指定位置添加元素
        :param  pos 从0开始
        """
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            count = 0
            pre = self.__head
            while count < (pos-1):
                pre = pre.next
                count+=1
            # 从当前位置退出后,pre指向pos-1位置
            node.next = pre.next
            pre.next = node

    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
                break
            else:
                pre = cur
                cur = cur.next
                

    def search(self,item):
        """查找节点是否存在"""
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

if __name__ == "__main__":
    li = SingleNode()
    print(li.is_empty())
    print(li.length())
    li.append(1)
    print(li.is_empty())
    print(li.length())

    li.append(1)
    li.append(2)
    li.add(10)
    li.append(3)
    li.insert(-1,43)
    li.append(4)
    li.append(5)
    li.insert(3,99)
    li.append(6)
    li.append(7)
    li.append(8)
    li.insert(45,101)
    li.append(9)
    li.travel()
    a = li.search(7)
    print(a)
    b = li.search(999)
    print(b)
    li.remove(3)
    li.travel()

# 运行结果
True
0
False
1
43 10 1 99 1 2 3 4 5 6 7 8 101 9 
True
False
43 10 1 99 1 2 4 5 6 7 8 101 9

双向链表

class Node(object):
    """结点"""
    def __init__(self,item):
        self.elem = item
        self.prev = None
        self.next = None


class DoubleLinkList(object):
    """单链表"""
    def __init__(self,node=None):
        self.__head = node

    def is_empty(self):
        """链表是否为空"""
        return self.__head == None

    def length(self):
        """链表长度"""
        cur = self.__head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历链表"""
        cur = self.__head
        while cur != None:
            print(cur.elem,end=" ")
            cur = cur.next
        print("")

    def add(self,item):
        """链表头部添加"""
        node = Node(item)
        cur = self.__head
        node.next = cur
        self.__head = node

    def append(self,item):
        """链表尾部添加"""
        node = Node(item)
        cur = self.__head
        prev = None
        if cur == None:
            self.add(item)
        else:
            while cur != None:
                if cur.next == None:
                    cur.next = node
                    node.prev = cur
                    node.next = None
                    break
                else:
                    prev = cur
                    cur = cur.next

    def insert(self,pos, item):
        """指定位置添加"""
        # 这里的pos 相当于下标
        node = Node(item)
        cur = self.__head
        prev = None
        count = 0
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            while count < pos:
                if (count+1) == pos:
                    prev.next = node # 每一个next指针域  都是下一个对象地址
                    node.next = cur
                    break
                else:
                    prev = cur
                    cur = cur.next
                    count += 1


    def remove(self,item):
        """删除节点"""
        cur = self.__head
        prev = None
        while cur != None:
            if cur.elem == item:
                if cur == self.__head:
                    self.__head = cur.next
                else:
                    prev.next = cur.next
                    cur.prev = prev
                break
            else:
                prev = cur
                cur = cur.next

    def search(self,item):
        """查找节点是否存在"""
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False


if __name__ == "__main__":
    li = DoubleLinkList()
    print(li.is_empty())
    print(li.length())
    li.append(1)
    li.append(2)
    li.travel()
    li.append(3)
    li.append(4)
    print(li.is_empty())
    print(li.length())
    li.append(5)
    li.append(6)
    li.add(14)
    li.append(7)
    li.append(8)
    li.insert(4,99)
    li.append(9)
    li.append(10)
    li.travel()
    li.remove(7)
    li.travel()
    li.remove(14)
    li.travel()
    li.remove(10)
    li.travel()
    print(li.search(9))
    print(li.search(000))
    
    
# 运行结果
True
0
1 2 
False
4
14 1 2 99 3 4 5 6 7 8 9 10 
14 1 2 99 3 4 5 6 8 9 10 
1 2 99 3 4 5 6 8 9 10 
1 2 99 3 4 5 6 8 9 
True
False

单向循环链表

class Node(object):
    """结点"""
    def __init__(self,item):
        self.elem = item
        self.next = None


class SingleCycleLinkList(object):
    """单项循环链表"""
    def __init__(self,node=None):
        self.__head = node
        if node:  # 传结点的 时候
            node.next = node

    def is_empty(self):
        """判断链表是否为空"""
        return self.__head == None

    def length(self):
        """返回链表的长度"""
        if self.is_empty():  # 判断是否为空链表
            return 0
        count = 1
        cur = self.__head
        while cur.next != self.__head: # 因为是单循环链表 所以判断最后一个结点的指针域 是否为头结点
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历"""
        if self.is_empty(): # 判断是否为空链表
            return 
        cur = self.__head  
        print(cur.elem,end=" ") # 先打印第一个结点
        while cur.next != self.__head:
            cur = cur.next  # 这是从第二个结点开始打印
            print(cur.elem,end=" ")
        print("")
        """
        while cur.next != self.__head:
            print(cur.elem,end=" ")
            cur = cur.next
        print(cur.elem,end=" ") # 直接写这句 还是 下面两句 都行
        if cur.next == self.__head:
            print(cur.elem) 
        """

    def add(self,item):
        """在头部添加一个节点"""
        node = Node(item)
        if self.is_empty(): # 为空链表的时候
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head: 
                cur = cur.next

            # 退出循环,cur指向为节点
            node.next = self.__head
            self.__head = node
            cur.next = node

            

    def append(self,item):
        """在尾部添加一个节点"""
        node = Node(item)
        if self.is_empty(): # 判断列表时否为空
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next  
            # 退出循环,cur指向为节点
            cur.next = node
            node.next = self.__head

    def insert(self,pos, item):
        """在指定位置pos添加节点"""
        if pos <= 0: # 头插法
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item) # 尾插法
        else:
            node = Node(item)
            cur = self.__head
            count = 0
            while count < pos:
                if count+1 == pos:
                    node.next = cur.next
                    cur.next = node
                    break
                else:
                    cur = cur.next
                    count += 1

    def remove(self,item):
        """删除一个节点"""
        if self.is_empty():
            return 
        cur = self.__head
        prev = None
        while cur.next != self.__head:
            if cur.elem == item:
                if cur == self.__head:
                    # 头结点
                    # 找尾结点
                    rear = self.__head
                    while rear.next != self.__head:
                        rear = rear.next
                    self.__head = cur.next
                    rear.next = self.__head
                else:
                    # 中间结点
                    prev.next = cur.next
                return # 这里不能用break 因为break不能代表函数结束  他只是表明了 while结束 下面的 代码 还在执行

            else:
                prev = cur
                cur = cur.next

        # 退出循环,cur指向为节点
        if cur.elem == item:
            if cur == self.__head:
                # 链表只有一个节点的时候
                self.__head = None
            else:
                prev.next = cur.next

    def search(self,item):
        """查找节点是否存在"""
        if self.is_empty(): # 判断链表是否为空
            return False

        cur = self.__head
        while cur.next != self.__head:
            if cur.elem == item:
                return True
            cur = cur.next
            # 退出循环,cur指向为节点
        if cur.elem == item: # 判断最后一个结点
            return True
        return False # 没有就反回False



if __name__ == "__main__":
    cll = SingleCycleLinkList()
    cll.travel()
    cll.add(11)
    cll.travel()
    cll.add(11)
    cll.travel()
    cll.add(13)
    cll.travel()
    cll.append(26)
    cll.travel()
    cll.add(18)
    cll.travel()
    cll.insert(3,999)
    cll.travel()
    cll.add(19)
    cll.travel()
    cll.add(20)
    cll.travel()
    cll.remove(13)
    cll.travel()
    cll.remove(20)
    cll.travel()
    cll.remove(26)
    cll.travel()
    print(cll.search(2))
    print(cll.search(26))
    print(cll.search(18))
    print(cll.search(11111))
    
# 运行结果
11 
11 11 
13 11 11 
13 11 11 26 
18 13 11 11 26 
18 13 11 999 11 26 
19 18 13 11 999 11 26 
20 19 18 13 11 999 11 26 
20 19 18 11 999 11 26 
19 18 11 999 11 26 
19 18 11 999 11 
False
False
True
False