Python数据结构与算法（三)--链表的基本操作

最新推荐文章于 2023-11-09 01:24:38 发布
最新推荐文章于 2023-11-09 01:24:38 发布
阅读量515 收藏 3
点赞数
分类专栏： python 文章标签： Python数据结构与算法（三)--链表的基本操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41511262/article/details/102056495
版权

文章目录

Python数据结构与算法（三)

一、链表的提出

（1）为什么需要链表

在这里插入图片描述

（2）链表的定义

在这里插入图片描述

二、单链表的ADT模型

（一）单向链表

在这里插入图片描述

（二）节点实现

在这里插入图片描述

（二）单链表的操作

在这里插入图片描述

三、Python中变量标识的本质

在这里插入图片描述

四、单链表及结点的定义代码

# coding:utf-8

class Node(object):
    '''节点'''
    def __init__(self,elem):
        self.elem = elem
        self.next = None

#  node = Node(100)
class SingleLinkList(object):
    """单链表"""
    def  __init__(self,node=None):
        self._head = node

    def is_empty(self):
        """链表是否为空"""
        pass

    def length(self):
        """链表长度"""
        pass

    def travel(self):
        """遍历整个链表"""
        pass

    def add(self,item):
        """链表头部添加元素"""
        pass

    def append(self,item):
        """链表尾部添加元素"""
        pass

    def insert(self,pos,item):
        """指定位置添加元素"""
        pass

    def remove(self,item):
        """删除节点"""
        pass

    def search(self,item):
        """查找节点是否存在"""
        pass

五、单链表的判空、长度、遍历与尾部添加结点的代码实现

在这里插入图片描述

头插法示意图
在这里插入图片描述

六、单链表尾部添加和在指定位置添加

在尾部插入结点示意图
在这里插入图片描述
在指定位置添加结点
在这里插入图片描述

七、单链表查找和删除元素

删除元素示意图
在这里插入图片描述
代码：

# coding:utf-8

class Node(object):
    '''节点'''
    def __init__(self,elem):
        self.elem = elem
        self.next = None

#  node = Node(100)
class SingleLinkList(object):
    """单链表"""
    def  __init__(self,node=None):
        self.__head = node    #__head是私有变量

    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:
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            #当循环退出后，pre指向pos-1位置
            node = Node(item)
            node.next = pre.next
            pre.next = node

    def remove(self,item):
        """删除节点"""
        cur = self.__head  #cur从头结点开始
        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__":
    ll = SingleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())


    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    #8 1 2 3 4 5 6
    ll.insert(-1,9) #9 8 1 2 3 4 5 6
    ll.travel()
    ll.insert(3,100) # 9 8 1 100 2 3 4 5 6
    ll.travel()
    ll.insert(10,200) #9 8 1 100 2 3 4 5 6 200
    ll.travel()
    ll.remove(100)
    ll.travel()
    ll.remove(9)
    ll.travel()
    ll.remove(200)
    ll.travel()

运行结果：
在这里插入图片描述

八、单链表与顺序表的对比

在这里插入图片描述

九、双向链表及添加元素

（一）概念

在这里插入图片描述

（二）操作

在这里插入图片描述
在头结点插入结点
在这里插入图片描述
在尾部插入结点
在这里插入图片描述
在固定位置插入结点
在这里插入图片描述

十、双向链表删除元素

删除元素
在这里插入图片描述
代码：

# coding:utf-8

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

class DoubleLinkList(object):
    """双链表"""
    def  __init__(self,node=None):
        self.__head = node    #__head是私有变量

    def is_empty(self):
        """链表是否为空"""
        return self.__head is 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
        node.next.prev = 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
            node.prev = cur

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

    def remove(self,item):
        """删除节点"""
        cur = self.__head  #cur从头结点开始
        while cur != None:
            if cur.elem == item:
                # 先判断此结点是否是头结点
                 # 头结点
                if cur == self.__head:
                    self.__head = cur.next
                    if cur.next:
                        # 判断链表是否只有一个结点
                        cur.next.prev = None
                else:
                    cur.prev.next = cur.next
                    if cur.next:
                        cur.next.prev = cur.prev
                break
            else:
                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__":
    ll = DoubleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    # 8 1 2 3 4 5 6
    ll.insert(-1, 9)  # 9 8 1 2 3 4 5 6
    ll.travel()
    ll.insert(3, 100)  # 9 8 1 100 2 3 4 5 6
    ll.travel()
    ll.insert(10, 200)  # 9 8 1 100 2 3 4 5 6 200
    ll.travel()
    ll.remove(100)
    ll.travel()
    ll.remove(9)
    ll.travel()
    ll.remove(200)
    ll.travel()

在这里插入图片描述

十一、单向循环链表遍历和求长度

（一）概念

在这里插入图片描述

（二）操作

在这里插入图片描述
求循环单链表长度：
在这里插入图片描述
循环单链表的遍历
在这里插入图片描述

十二、单向循环链表添加元素

循环单链表头部插入元素在这里插入图片描述
尾插法的两种方式在这里插入图片描述
在任意位置插入和单链表相同
在这里插入图片描述

十三、单向循环链表查找元素

 # coding:utf-8

class Node(object):
    '''节点'''
    def __init__(self,elem):
        self.elem = elem
        self.next = None

 #  node = Node(100)
class SingleLinkList(object):
    """单向循环链表"""
    def  __init__(self,node=None):
        self.__head = node    #__head是私有变量
        if node:
            node.next = node

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

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

    def travel(self):
        """遍历整个链表"""
        if self.is_empty():
            return
        cur = self.__head
        while cur.next !=self.__head:
            print(cur.elem, end = "  ")
            cur = cur.next
        # 退出循环，cur指向尾结点，但尾结点的元素未打印
        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
            cur.next = self.__head



    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
            #node.next = cur.next
            node.next = self.__head
            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:
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            #当循环退出后，pre指向pos-1位置
            node = Node(item)
            node.next = pre.next
            pre.next = node

    def remove(self,item):
        """删除节点"""
        if self.is_empty():
            return
        cur = self.__head  #cur从头结点开始
        pre = 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:
                    #中间结点
                    pre.next = cur.next
                return
            else:
                 pre = cur
                 cur = cur.next
        #退出循环，cur指向尾结点
        if cur.elem == item:
            if cur == self.__head:
                # 链表只有一个节点
               self.__head = None
            else:
                pre.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
            else:
                cur = cur.next
        # 退出循环，cur指向尾结点
        if cur.elem == item:
            return True
        return False

if __name__ == "__main__":
    ll = SingleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())


    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    #8 1 2 3 4 5 6
    ll.insert(-1,9) #9 8 1 2 3 4 5 6
    ll.travel()
    ll.insert(3,100) # 9 8 1 100 2 3 4 5 6
    ll.travel()
    ll.insert(10,200) #9 8 1 100 2 3 4 5 6 200
    ll.travel()
    ll.remove(100)
    ll.travel()
    ll.remove(9)
    ll.travel()
    ll.remove(200)
    ll.travel()

运行结果
在这里插入图片描述

山复尔尔，
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python typing optional_python – 我应该如何使用Optional类型提示？
weixin_39930557的博客
12-09 3197
可选[…]是Union […,None]的简写符号,告诉类型检查器需要特定类型的对象,或者需要None. …代表任何有效的类型提示,包括复杂的复合类型或更多类型的Union [].每当你有一个默认值为None的关键字参数时,你应该使用Optional.所以对于你的两个例子,你有dict和list容器类型,但是a关键字参数的默认值表明也允许None,所以使用Optional […]：from typ...
Python实现数据结构与算法——反转链表
12-21
题目描述： 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道...这个过程相当于，在遍历链表的过程中，每一个当前节点的nex
『Python』类型注解
七秒钟的记忆
01-20 2921
Python作为弱类型语言，对于代码补全和提示都不是很友好，并且对后人阅读代码也会造成不小的困扰，类型注解一定程度上缓解了这些不足
Python - typing 模块 —— Optional
eli的博客
01-05 2670
前言 typing 是在 python 3.5 才有的模块 前置学习 Python 类型提示：Python -类型提示 Type Hints - 小菠萝测试笔记 - 博客园 常用类型提示 Python - typing 模块 —— 常用类型提示 - 小菠萝测试笔记 - 博客园 类型别名 https://www.cnblogs.com/poloyy/p/15153883.html NewType Python - typing 模块 —— NewType - 小菠萝测试笔记.
python每日一练-合并两个有序的链表（超详细讲解）
m0_37623374的博客
05-13 2327
先来看题： 首先对于链表我也是首次接触，所以自己取学习了一下关于链表的知识。 首先我们先来看题目，因为本题目需要使用到递归的方法，所以我们首先先来介绍一下什么是递归？递归又是怎么用的？ 函数在运行时调用自己，这个函数就是递归函数。调用的过程就叫做递归。 def f(x): return x+f(x-1) 其实这就是相当于一个函数 f(x)=x+f(x-1)，但是这个函数如果不给予限制，那么他无穷无尽的循环，直到系统崩溃。 所以： 递归函数必须要有终止条件，否则就会出错。 递归函数先不断的调用自
python函数注释 typing模块函数类型注解（函数注解）（指定函数参数和返回值类型）Union注解、Callable注解、Optional可变参数注解。类型提示、类型注解
Dontla的博客
07-13 4392
因此，set(“dsf234fdsf”)的结果是一个包含字符串中每个字符的集合：{‘3’, ‘s’, ‘2’, ‘d’, ‘f’, ‘4’}。在函数get_unique_numbers中，参数numbers被注解为List[int]，表示它应该是一个整数类型的列表。然而，当你调用get_unique_numbers(“dsf234fdsf”)时，你传递给函数的参数是一个字符串，而不是一个整数列表。Python的typing模块提供了一种在函数定义中添加类型注解的方式，用于指定函数参数和返回值的类型。
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
约瑟夫生者死者游戏-Python数据结构与算法实战项目完整源码与界面资源
07-01
约瑟夫生者死者问题是数据结构与算法中的经典问题，本项目基于单向循环链表这一数据结构实现，并使用 tkinter技术 实现约瑟夫问题的可视化。项目使用了图形用户界面GUI技术，使用的开发工具为PyCharm 2021.3。实现了...
Python:Optional和带默认值的参数
热门推荐
qq_44683653的博客
10-10 6万+
带默认值的参数 在Python中的类或者函数中，默认值参数在声明时附带了它的默认值，故在实例化时，可以选择性的为该参数赋值。例如： #默认值参数 def foo_v1(a: int, b: int = 1): print(a + b) #未给b传入实参时，采用默认值 foo_v1(2) # 输出 # >>> 3 Typing.Optional类 可选类型，用该类声明的参数与带默认值的参数类似，不过特殊的用它声明的参数的默认值可以为None。 以下为Python Doc
力扣刷题笔记之简单题（python代码实现）
sinounuo的博客
03-29 195
好累，不想刷了，明天继续吧
Python实现单向链表
zhu6201976的博客
06-17 261
说明：仅供学习使用，请勿用于非法用途，若有侵权，请联系博主删除 作者：zhu6201976
python如何输入输出链表
toCVer的博客
07-11 1868
删除链表中重复元素
链表操作基础（python）
beautiful77moon的博客
09-23 5713
链表创建、合并、节点删除、翻转、奇偶位置重排
【数据结构与算法】python实现单向链表及操作
weixin_43911004的博客
03-19 2460
python快速实现单向链表及其操作
python链表操作_Python链表操作(实现)
weixin_39881387的博客
11-20 715
Python链表操作在Python开发的面试中，我们经常会遇到关于链表操作的问题。链表作为一个非常经典的无序列表结构，也是一个开发工程师必须掌握的数据结构之一。在本文中，我将针对链表本身的数据结构特点，以及链表的一些常见操作给大家做一个深入浅出的讲解，希望本文的读者能够掌握链表的操作。1. 什么是链表？简单地说，链表是一种无序的列表。你可以把链表里面的数据看成是随机排列的，元素之间并没有固定的先后...
Python中的链表：手把手教你实现基本操作
最新发布
xzj992186660的博客
11-09 188
这篇文章提供了Python中实现链表的简要指南。当然，链表的实现远不止这些。在实际应用中，你可能还需要实现更多高级操作，如翻转链表、排序链表等。希望这篇文章能够作为一个良好的起点，帮助你进一步探索Python中的数据结构。在使用这篇文章之前，请确保内容是原创的，并且适当修改以避免任何可能的版权问题。
使用类型注解让 Python 代码更易读
静觅
08-04 2229
“ 阅读本文大概需要 10分钟。 ”我们知道 Python 是一种动态语言，在声明一个变量时我们不需要显式地声明它的类型，例如下面的例子：a=2print('1+...
新特性Optional的使用，以及集合长度为0的踩坑
shijiujiu33的博客
05-28 8973
使用Java8的新特性Optional，再取属性的时候避免NullPointException，代替判空操作 如 return Optional.ofNullable(user).map(User::getName).orElse(null)); 代替 if(user!=null){ return user.getName(); }else{ return null; } 提高代码的可读性...
Python type hints 之 Optional，Union
ypgsh的博客
12-13 2万+
1，前言         type hint 在pep484加入，我个人觉得这种类似于类型约束的（机制）有点违背了python简单、简洁的初衷，在慢慢向c# java 这种强类型语言看齐的节奏。         不过好在不强制使用，个人觉得依照规则编码也有点好处， 一方面，因为输入输出的类型进行定义的过程中，推动个人对输入输出进行详细的思考，个人的思路也会更清晰， 写的函数不容易飘。 另一...
python数据结构与算法链表知识
05-05
链表（Linked List）是一种常见的数据结构，它是由一系列节点组成的，每个节点包含一个数据元素和一个指向下一个节点的指针。链表中的节点可以在运行时动态添加或删除，这使得链表在某些场景下比数组更加适用。 在 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值