【Python——链表】

已于 2022-08-07 17:02:42 修改
阅读量1.5w 收藏 180
点赞数 35
文章标签： python pandas 数据分析
于 2022-08-05 22:06:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70964767/article/details/126184640
版权

目录

一、链表是什么？

二、单向链表

三、双向链表

一、链表是什么？

 1.定义：链表（Linked list）是一种常见的基础数据结构，是一种线性表，在每一个节点（数据存储单元）里存放下一个节点的位置信息

2.优点：顺序表的构建需要预知数据大小来申请连续存储空间，扩充时需要进行数据迁移，使用不灵活，链表充分利用计算机内存空间，实现灵活内存动态管理

二、单向链表

1.定义：单向链表（单链表）是链表中最简单一种形式，它的每个节点包含两个域——信息域（元素域）和链接域

(1)表元素域elem用来存放具体的数据

(2)链接域next用来存放下一个节点的位置

(3)变量p指向链表的头节点(首节点)的位置，从p出发能找到表中的任意节

2.链表相关方法：

方法说明
is_empty()链表是否为空
length()链表长度
travel()遍历整个链表
add(item)链表头部添加元素
append(item)链表尾部添加元素
insert(pos,item)在指定位置添加元素
remove(item)删除节点
search(item)查找结点是否存在
#定义节点
class Node(object):
    def __init__(self,elem):
        self.elem=elem
        self.next=None
#构造单向链表
class SingleLinkedList:
    #判断链表是否为空：_head指向None，则为空
    def is_empty(self):
        '''
        if self._head==None:
            print("True")
        else:
            print("False")
            '''
        return self._head==None
    #单向链表初始化
    def __init__(self,node=None):
        #判断node是否为空
        if node!=None:
            headNode=Node(node)
            self._head=headNode
        else:
            self._head=node
    #计算链表长度
    def length(self):
        count=0
        curNode=self._head
        while curNode!=None:
            count+=1
            curNode=curNode.next
            return count
    #遍历链表
    def travel(self):
        curNode=self._head
        while curNode!=None:
            print(curNode.elem,end='\t')
            curNode=curNode.next
        print("  ")
    #在头部添加元素
    def add(self,item):
        #将传入的值构造成节点
        node=Node(item)
        #将新节点的链接域next指向头节点
        node.next=self._head
        #将链表的头_head指向新节点
        self._head=node
    #在尾部添加元素
    def append(self,item):
        #将传入的值构造成节点
        node=Node(item)
        if self.is_empty(): #单链表为空
            self._head=node
        else: #单链表不为空
            curNode=self._head
            while curNode.next!=None:
                curNode=curNode.next
            #修改节点，最后一个节点的next指向node
            curNode.next=node

    #在指定位置添加元素
    def insert(self,pos,item):
        #如果pos<=0，默认插入到头部
        if pos<=0:
            self.add(item)
        #如果pos>链表长度，直接在尾部追加
        elif pos>(self.length()-1):
            self.append(item)
        else:
            #构造节点
            node=Node(item)
            count=0
            preNode=self._head
            while count<(pos-1): #查找前一个节点
                count+=1
                preNode=preNode.next
            #修改指向
            #将前一个节点的next指向插入节点
            node.next=preNode.next
            #将插入位置的前一个节点next指向新节点
            preNode.next=node

    #查找节点是否存在
    def search(self,item):
        curNode=self._head
        while curNode!=None:
            if curNode.elem==item:
                return True
            curNode=curNode.next
        return False
    #删除节点
    def remove(self,item):
        curNode=self._head
        preNode=None
        while curNode!=None:
            if curNode.elem==item:
                #判断是否是头节点
                if preNode==None:#是头节点
                    self._head=curNode.next
                else:
                    #删除
                    preNode.next=curNode.next
            break
        else:
                preNode=curNode
                curNode=curNode.next
if __name__=="__main__":
    #初始化元素值为10单向链表
    singleLinkedList=SingleLinkedList(30)
    print("是否为空链表：",singleLinkedList.is_empty())
    print("链表长度为：",singleLinkedList.length())
    print("----遍历链表----")
    singleLinkedList.travel()
    print("-----查找-----",singleLinkedList.search(30))
    print("-----头部插入-----")
    singleLinkedList.add(1)
    singleLinkedList.add(2)
    singleLinkedList.add(3)
    singleLinkedList.travel()
    print("-----尾部追加-----")
    singleLinkedList.append(10)
    singleLinkedList.append(20)
    singleLinkedList.travel()
    print("-----链表长度-----",singleLinkedList.length())
    print("-----指定位置插入-----")
    singleLinkedList.insert(-1,100)
    singleLinkedList.travel()
    print("-----删除节点-----")
    singleLinkedList.remove(100)
    singleLinkedList.travel()

是否为空链表： False
链表长度为： 1
----遍历链表----
30      
-----查找----- True
-----头部插入-----
3    2    1    30      
-----尾部追加-----
3    2    1    30    10    20      
-----链表长度----- 1
-----指定位置插入-----
100    3    2    1    30    10    20      
-----删除节点-----
3    2    1    30    10    20     

三、双向链表

1.双向链表（双面链表）是一种更复杂的链表。每个节点有两个链接:一个指向前一个节点，当此节点为第一个节点时，指向空值，而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。

2.双向链表的实现：

class Node:
    def __init__(self,elem):
        self.elem=elem
        self.next=None #下一个节点
        self.prev=None #前一个节点

class DoubleLinkedList:
    # 双向链表初始化
    def __init__(self, node=None):
        # 判断node是否为空
        if node != None:
            headNode=Node(node)
            self._head=headNode
        else:
            self._head=node
    def is_empty(self):
        '''
        if self._head==None:
            print("True")
        else:
            print("False")
            '''
        return self._head==None
    #计算链表长度
    def length(self):
        count=0
        curNode=self._head
        while curNode!=None:
            count+=1
            curNode=curNode.next
            return count
    #遍历链表
    def travel(self):
        curNode=self._head
        while curNode!=None:
            print(curNode.elem,end='\t')
            curNode=curNode.next
        print("  ")
    #在头部添加元素
    def add(self,item):
        #判断是否空链表
        node = Node(item)
        if self.is_empty():
            self._head=node
        else:
            #将传入的值构造成节点
            node=Node(item)
            #将新节点的链接域next指向头节点
            node.next=self._head
            #将_head的头节点的prev指向node
            self._head.prev=node
            #将链表的头_head指向新节点
            self._head=node
    #在尾部追加元素
    def append(self,item):
        #将传入的值构造成节点
        node=Node(item)
        if self.is_empty(): #双向链表为空
            self._head=node
        else: #双向链表不为空
            curNode=self._head
            while curNode.next!=None:
                curNode=curNode.next
            #修改节点，最后一个节点的next指向node
            curNode.next=node
            #将node节点的前驱指向当前节点
            node.prev=curNode

    #在指定位置添加元素
    def insert(self,pos,item):
        #如果pos<=0，默认插入到头部
        if pos<=0:
            self.add(item)
        #如果pos>链表长度，直接在尾部追加
        elif pos>(self.length()-1):
            self.append(item)
        else:
            #构造节点
            node=Node(item)
            count=0
            curNode=self._head
            while count<(pos-1): #查找前一个节点
                count+=1
                curNode=curNode.next
            #修改指向
            #node节点前驱指向当前节点
            node.prev=curNode
            #node节点的next指向当前节点的下一个节点
            node.next=curNode.next
            #当前节点的下一个节点的前驱指向node节点
            curNode.next.prev=node
            #当前节点的下一个节点指向node节点
            curNode.next=node

    #查找节点是否存在
    def search(self,item):
        curNode=self._head
        while curNode!=None:
            if curNode.elem==item:
                return True
            curNode=curNode.next
        return False
    #删除节点
    def remove(self,item):
        curNode=self._head
        while curNode!=None:
            if curNode.elem==item:
                #判断是否是头节点
                if curNode==self._head:#是头节点
                    self._head=curNode.next
                    #判断当前节点是否只有一个节点
                    if curNode.next:
                        curNode.next.prev==None
                else:
                    #删除
                    curNode.prev.next=curNode.next
                    #判断当前节点是否是最后一个节点，若是，不需要移动下一个
                    if curNode.next:
                        curNode.next.prev=curNode.prev
            break
        else:
                curNode=curNode.next
if __name__=="__main__":
    doubleLinkedList=DoubleLinkedList()
    print("-----头部添加-----")
    doubleLinkedList.add(11)
    doubleLinkedList.add(22)
    doubleLinkedList.add(33)
    doubleLinkedList.travel()
    print("-----尾部追加-----")
    doubleLinkedList.append(44)
    doubleLinkedList.travel()
    print("指定位置插入")
    doubleLinkedList.insert(3,100)
    doubleLinkedList.travel()
    print("-----删除元素-----")
    doubleLinkedList.remove(33)
    doubleLinkedList.travel()

 -----头部添加-----
33    22    11      
-----尾部追加-----
33    22    11    44      
指定位置插入
33    22    11    44    100      
-----删除元素-----
22    11    44    100     

In my opinion
关注
数据结构Python版（二）——链表
⚡
06-20 1968
数据结构-Python-链表
Python数据结构——链表
Echo_Wish的博客
10-25 663
链表是一种基本的数据结构，用于组织和管理数据。在Python中，你可以使用自定义类来实现链表。了解链表数据结构及其应用场景将帮助你更好地解决各种编程问题。链表是动态分配内存的数据结构，因此非常适合实现动态数据结构和一些高级算法。无论是在数据结构设计、算法实现还是操作系统开发中，链表都是一个非常有用的工具。
Python实现数据结构与算法（三）链表
weixin_64338372的博客
12-11 665
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。
python中的链表理解
LJC的博客
11-25 3960
链表概念：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 相关代码 # 首先定义结点类，链表结点包括值域 val，和 next 指针 class ListNode: def __init__(self, x): self.val = x self.next = None def main(): """ 利用数组初始化一个链表 """ nums = [1, 4, 2, 7..
链表的python实现
最新发布
qq_57331743的博客
09-09 2608
self.item = item # 存放节点数据self.next = None # 用于指向下一个节点双链表是在链表的基础上，每个节点有两个指针：一个指向前一个节点，一个指向后一个节点。self.item = item # 用于存放节点数据self.prior = None # 指向前一个节点self.next = None # 指向后一个节点。
[Python-链表]
green_handnie的博客
12-10 1374
链表（Linked List）是一种基础的数据结构，用于组织和存储一系列元素。链表中的元素被组织成节点，每个节点包含数据和一个指向下一个节点的引用（指针或链接），即每个节点包含了两种内容：数据域和指针域。
链表（python）
weixin_43765321的博客
03-19 2746
1. 链表定义 链表是由一系列节点组成的元素集合。每个节点包含两部分，数据域item和指向下一个节点的指针next。通过节点之间的相互连接，最终串联成一个链表。 单链表如下图所示： 单链表中的结点类型描述如下： class Node: def __init__(self, item): self.item = item self.next = None 2. 链表的实现方式 2.1 头插法 头插法从一个空表开始，生成新结点，并将读取到的数据存放到新结点的数据域中，
【Python】python链表
热门推荐
weixin_45718987的博客
05-31 2万+
python链表总结 原Blog链接：https://blog.csdn.net/qq_44941689/article/details/122402938 1. 链表基本类型 链表（Linked List）：一种线性表数据结构。它使用一组任意的存储单元（可以是连续的，也可以是不连续的），来存储一组具有相同类型的数据。即「链表」 是实现线性表的链式存储结构的基础。 单链表每个数据元素占用若干存储单元的组合称为一个「链节点」，还要存放一个指出这个数据元素在逻辑关系上的直接后继元素所在链节点的地址，该地址被
数据结构——链表（python版）
点赞的都能无bug通过！
05-05 6302
结点的数据结构为数据元素(item)与 指针(next)class Node(object) : """单链表的结点""" def __init__(self , item) : # item存放数据元素 self . item = item # next是下一个节点的标识 self . next = None链表需要具有首地址指针head。class SingleLinkList(object) : """单链表""" def __init__(self) : self . _head = None。
图解数据结构（使用Python）——链表
12-21
【链表】是一种基本的数据结构，它在计算机科学中扮演着重要的角色，特别是在处理动态数据集合时。链表不同于数组，它的元素在内存...通过Python实现链表的各种操作，不仅可以加深对链表的理解，也有助于提高编程能力。
Python数据结构实战——链表(LinkedList)
12-21
在Python中，链表的每个元素由一个结点（Node）对象表示。结点包含两个主要部分：数据（data）和指向下一个结点的引用（next）。以下是定义结点类的代码： ```python class Node: def __init__(self, data=None, ...
数据结构-第二期——链表（Python）
荷叶田田的博客
12-17 678
链表是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的链接。
python链表_python链表
weixin_39634022的博客
11-20 348
一 简介1 链表简介链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序...
python中的链表
m0_54146002的博客
09-14 577
单向链表也叫单链表，是链表中最简单的一种形式，他的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的连接域则指向一个空值。（3）变量 p 指向链表的头节点（首节点）的位置，从 p 出发能找到表中的任意节点。（2）链接域 next 用来存放下一个节点的位置（python 中的标识）（1）表元素域 elem 用来存放具体的数据。
Python 数据库——链表
思则变的专栏
09-12 3972
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表在逻辑上是连续的，但是在物理空间上可能是不连续的，因为链表的内存都是临时申请的，不一定会申请到连续的内存空间。常用的链表有单向链表和双向链表。这里主要介绍单项链表。单项链表的组成节点有两部分构成：数据和下一个列表的存储地址。单节点结构图：链表结构图：可以看到每一个节点中的addr都指向下一个节点的地址，phead为整个链表的头节点，不能改变，否则就会找不到整个链表。
python 链表
我只是个小学生 能力有限 一直抱着学习的态度
11-03 419
链表是由一系列节点组成的元素集合，每个节点包含两部分，数据域item和指向下一个节点的指针next。通过节点之间的相互连接，最终串联成一个链表
python链表
xiao-啸
05-05 1078
单项链表 class Node(object): """结点""" def __init__(self,elem): self.elem = elem # 数据域 self.next = None # 指针域 class SingleNode(object): """单链表""" def __init_...
python数据结构 —— 链表
2301_77774241的博客
05-15 2265
简要介绍了链表这一数据结构，并且详细介绍了如何进行链表初始化、打印列表、append和pop操作
python数据结构之链表
Ernestwang2016的博客
07-07 333
链表(Linked List)，由于python是动态语言，可以直接把对象赋值给新的变量，于是在python一切皆为对象的原理上实现链表的各项操作。在实现链表python类的属性和方法操作之前，先整理一些链表的理论知识。 一、链表的基本结构链表是通过一个个节点（Node）组成的，每个节点都包含了称为数据域(value)和指针域(next)的基本单元，它也是一种递归的数据结构。它能保持数据之间的逻辑...
python合并链表
08-17
要在Python中合并链表，有两种常见的情况： 1. 直接合并，没有什么规则，只是将多个链表的头尾相连合并成一个链表。例如，可以使用以下代码实现直接合并多个链表： ```python from slinklist import SlinkList def concat(lista): slink = SlinkList() for ll in lista: sllv = ll.display() for v in sllv: slink.appendtail(v) return slink def main(): sll1 = SlinkList() sll2 = SlinkList() for i in range(1, 6): sll1.appendtail(i) sll2.appendtail(i * i) lst = [sll1, sll2] newlinklist = concat(lst) print(newlinklist.display()) #### 引用[.reference_title] - *1* *2* *3* [Python——数据结构——链表——合并单链表](https://blog.csdn.net/qq_41188247/article/details/122128989)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

In my opinion

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值