数据结构与算法——链表——Celia

最新推荐文章于 2021-12-09 15:49:26 发布
最新推荐文章于 2021-12-09 15:49:26 发布
阅读量208 收藏
点赞数
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48929099/article/details/108700751
版权

文章目录

单链表及基本操作

概念补充：后继结点，即后一个邻结点

  1. 创建一个节点
# 单链表及节点定义代码
# 节点中需要保存它的数据和下一个链接地址
class Node(object):
    """节点"""
    def __init__(self, elem):
        self.elem = elem+
        
        self.next = None  # 先不指向任何区域
  1. 创建一个链表
class SingleLinkList(object):
    """单链表"""
    # 链表中必须存在一个（对象）属性，指向第一个节点
    # 设置默认参数为空，为让顾客没输入第一个节点时也可以运行
    def __init__(self, node):
        self.__head = None
  1. 一些链表相关操作：
    宗旨：不要先打断原有链表，先对待操作的新节点进行操作
    ① 判断是否为空链表
    # 链表是否为空（对具体对象的操作是对象方法而不是类方法）
    def is_empty(self):
        """链表是否为空"""
        return self.__head == None

② 计算链表长度

    def length(self):
        """链表长度(节点数目）"""
        # cur游标用来移动遍历节点
        cur = self.__head  # 建立cur游标=起始节点
        # count记录数量
        count = 0  # 若设置为1则还需要额外考虑空链表情况
        while cur != None:
            count += 1
            cur = cur.next
        return count

③ 遍历整个链表

    def travel(self):
        """遍历整个链表（需要定义一个游标cur来记录当前位置）"""
        cur = self.__head
        while cur != None:
            print(cur.elem, end="")
            cur = cur.next

④ 在链表头部插入节点：

def add(self, item):
    """链表头部添加元素（放入节点），头插法"""
    node = Node(item)  # 待插入的新节点
    # 注意这里指的不是node节点的下一节点，而是其next区域
    node.next = self.__head  # 让新节点的next区域等于原head区域（插入图片）

在这里插入图片描述

def add(self, item):
    """链表头部添加元素（放入节点），头插法"""
    node = Node(item)  # 待插入的新节点
    # 注意这里指的不是node节点的下一节点，而是其next区域
    node.next = self.__head  # 让新节点的next区域等于原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:
        count = 0
        pre = self.__head  # 定义一个游标
        while count < (pos-1):
            count += 1
            pre = pre.next
        # 当循环退出后，pre指向pos-1位置
        node = Node(item)
        node.next = pre.next
        pre.next = node

⑦ 查找节点是否存在

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

⑧删除节点
有两种情况：两个游标和一个游标
在这里插入图片描述
两个游标的情况：

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游标前面
            pre = cur
            cur = cur.next
    return False

补充说明：
在这里插入图片描述
self.__head指的是其指向的100node

总体及运行结果：

# 单链表及节点定义代码
# 节点中需要保存它的数据和下一个链接地址
class Node(object):
    """节点"""
    def __init__(self, elem):
        self.elem = elem
        self.next = None  # 先不指向任何区域



class SingleLinkList(object):
    """单链表"""
    # 链表中必须存在一个（对象）属性，指向第一个节点
    # 设置默认参数为空，为让顾客没输入第一个节点时也可以运行
    def __init__(self, node):
        self.__head = None

    # 链表是否为空（对具体对象的操作是对象方法而不是类方法）
    def is_empty(self):
        """链表是否为空"""
        return self.__head == None

    def length(self):
        """链表长度(节点数目）"""
        # cur游标用来移动遍历节点
        cur = self.__head  # 建立cur游标=起始节点
        # count记录数量
        count = 0  # 若设置为1则还需要额外考虑空链表情况
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历整个链表（需要定义一个游标cur来记录当前位置）"""
        cur = self.__head
        while cur != None:
            print(cur.elem, end="")
            cur = cur.next

        print("")  # 遍历后换行



    def add(self, item):
        """链表头部添加元素（放入节点），头插法"""
        node = Node(item)  # 待插入的新结点
        # 注意这里指的不是node节点的下一节点，而是其next区域
        node.next = self.__head  # 让新节点的next区域等于原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:
            count = 0
            pre = self.__head  # 定义一个游标
            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
        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游标前面
                pre = cur
                cur = cur.next
        return False


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


"""
node = Node(100)
single_obj = SingleLinkList(node)
single_obj.travel()
"""

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

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

    ll.append(2)
    ll.append(3)
    ll.append(4)
    ll.add(8)
    ll.insert(-1, 9)  # 小于0都视为从头开始，9、8、1、2、3、4
    ll.travel()
    ll.insert(3, 100)  # 索引计数从0开始，9、8、1、100、2、3、4
    ll.travel()
    ll.insert(10, 200)  # 9、8、1、100、2、3、4、200
    ll.travel()
    ll.remove(100)
    ll.travel()
    ll.remove(9)
    ll.travel()
    ll.remove(200)
    ll.travel()
True
0
False
1
981234
981100234
981100234200
981234200
81234200
81234

链表与顺序表的对比

在这里插入图片描述

双向链表基本操作

双向链表：
在这里插入图片描述
引入概念：前驱结点、后继结点
基本操作
① 结点创建

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

② 链表创建

class DoubleLinkList(object):  # 不涉及pre游标的也可以直接继承自单链表
    def __init__(self, node):
        self.__head = None

③判断链表是否为空

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

④ 链表长度计算

def length(self):
    """链表长度(节点数目）"""
    # cur游标用来移动遍历节点
    cur = self.__head  # 建立cur游标=起始节点
    # count记录数量
    count = 0  # 若设置为1则还需要额外考虑空链表情况
    while cur != None:
        count += 1
        cur = cur.next
    return count

⑤ 遍历

def travel(self):
    """遍历整个链表（需要定义一个游标cur来记录当前位置）"""
    cur = self.__head
    while cur != None:
        print(cur.elem, end="")
        cur = cur.next

    print("")  # 遍历后换行

⑥ 头部添加元素

def add(self, item):
    """链表头部添加元素（放入节点），头插法"""
    node = Node(item)  # 待插入的新节点
    # 注意这里指的不是node节点的下一节点，而是其next区域
    node.next = self.__head  # 让新节点的next区域等于原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
    while cur != None:
        if cur.elem == item:
            # 先判断此节点是否是头节点
            # 头节点
            if cur == self.__head:
                self.__head = cur.next
                if cur.next != None:
                    # 判断链表是否只有一个结点
                    cur.next.prev = None  # 若是，则cur.next是None，没有prev
            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__":
    dll = DoubleLinkList(1)
    print((dll.is_empty()))
    print((dll.length()))

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

    dll.append(2)
    dll.append(3)
    dll.append(4)
    dll.add(8)
    dll.insert(-1, 9)
    dll.travel()
    dll.insert(3, 100)
    dll.travel()
    dll.insert(10, 200)
    dll.travel()
    dll.remove(100)
    dll.travel()
    dll.remove(9)
    dll.travel()
    dll.remove(200)
True
0
False
1
981234
981100234
981100234200
981234200
81234200
81234

单向循环链表

一. 遍历和求长度

单向循环链表：尾结点指针区next指向头结点
在这里插入图片描述

二. 添加元素

（宗旨：尽量先动要插入的结点，不先动原有结点）
1.在头部添加元素：
1.将node插入头部
在这里插入图片描述

node.next = self.__head （self.__head指的是100结点，此操作让400的next指向100）
self.__head = node （让head指向400）

注意：
1）上述顺序不能颠倒，否则后部分链表会丢失
2）这里self.__head是一个 “前部分为空+next” 结点，本身的意思就是“next”形式的
3）self.__head是真实存在的结点

2.让尾部指向头部
由于需要找到尾结点，所以需要有一个遍历的过程。有两种方法：先遍历找到尾结点再插入头结点 or 先插入再遍历

方法一：先插入后遍历（不太好理解）
要遍历，就先设计游标cur：
1）由于终止条件原来是：cur.next = self.__head ，所以找到 “cur.next = node.next”也就找到了尾结点（ 即都指向100结点）
在这里插入图片描述
方法2：先遍历找到尾结点再插入
1）当 cur.next = self.__head 则找到了尾结点，所以

while cur.next != self.__head
    cur = cur.next

2)然后

node.next = self.__head
self.__head = node
cur.next = node # 使尾结点指向node,
# 或者写成cur.next = self.__head

3)检查特殊情况（空链表、、）
空链表：若判断为空，则让head指向添加的结点，并让它再指向自身

if self.is_empty():
    self.__head = node
    node.next = node
else

只有一个结点：
原代码依然可行，不用修改

2.在尾部添加元素

  1. 将node插入尾部
    两种方法
# 先动node
node.next = cur.next
cur.next = node

或者

# 先动链表
cur.next = node
node.next = self.__head
Celia Wang colar
关注
Python进阶 - 数据结构与算法 - 04 单向循环链表的操作
shandy_liunian的博客
11-16 394
一、单向循环链表的引入 单向循环链表的结构 链表中的每一个节点都包括数据域和链接域两部分。数据域中存放真实的数据，链接域存放下一个数据的地址，且尾节点的链接域为首节点。 二、单向循环链表的操作 2.1 节点的实现 链表中的每一个数据都由数据区和链接域两部分组成，在Python或者其他语言中没有一个数据类型可以同时储存这两个数据，因此我们可以定义节点这样一个类，而节点中的数据和链接区可以想象成该类...
数据结构与算法详解——链表篇（附c++实现代码）
JMasker的博客
05-01 3191
链表详解及完整实现
力扣--链表知识点
华辰烟雨的博客
07-08 731
含义：链表是一种通过指针串联在一起的线性结构，每一个节点是有两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针）。链表的入口点成为头结点（head）。链表的节点在内存中是分散存储的，通过指针连在一起。它的长度可以是不固定的，并且可以动态增删，适合数据量不固定，频繁增删，较少查询的场景。 类型： （1）单链表： 刚才所讲的含义中就是单链表。 （2）双链表： 双链表是指每一个节点有两个指针域，一个指向下一个节点...
头指针与头结点的理解，链表带有头结点与不带头结点的python实现
zxyhfdl的博客
05-24 2562
对于数据结构的头结点、头指针问题，一直都有点不太清楚理解。现对其中涉及的概念与如何使用python语言创建链表（带有头结点与不带头结点）进行解释。 一、基本概念 假设我们将对数组array[a1,a2,a3]创建链表结果，两种存储方式如下图所示： 概念小结： 1）对一个链表结构，头指针是必须存在的，其实就是链表名称，指向的是链表的第一个节点的指针（可以是头结点也可以是首元节点，看实现方式）。 2）当链表头结点存在的时候，它是是链表的第一个节点，指向首元节点（首元节点存储数据a1）。头结点的
python实现单向循环链表
qq_41020281的博客
05-04 1143
单向循环链表单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。操作is_empty() 判断链表是否为空length() 返回链表的长度travel() 遍历add(item) 在头部添加一个节点append(item) 在尾部添加一个节点insert(pos, item) 在指定位置pos添加节点remove(item) 删除一个节点search...
python数据结构——链表及其实现
阿鹏的摇滚小站
02-25 213
一、单向链表 二、单向链表实现 class Node(object): """节点""" def __init__(self, elem): super(Node, self).__init__() # 元素 self.elem = elem # 下一个节点地址 self.next = None ...
Python实现数据结构与算法——反转链表
12-21
反转链表是数据结构与算法领域中的一个经典问题，它要求我们改变链表节点的指向，使得原本顺着一个方向的链表变成逆序。在这个问题中，我们可以采用两种方法来解决：迭代和递归。 首先，让我们详细讲解迭代的解题...
简单粗暴学习数据结构与算法——JS版（一）
06-13
这个教程“简单粗暴学习数据结构与算法——JS版（一）”很可能是通过一系列的实例和练习，用JavaScript来直观解释各种数据结构的实现和算法的应用。通过下载的多个rar文件，可能包含了不同章节的讲解、代码示例和...
简单粗暴学习数据结构与算法——JS版(二)
06-14
总的来说，这个"简单粗暴学习数据结构与算法——JS版(二)"教程可能是由多个部分组成，涵盖了各种数据结构和算法的实例和练习，旨在帮助学习者深入理解并熟练应用JavaScript中的数据结构与算法。通过学习这些内容，...
python数据结构——链表总结
半岛铁盒
08-04 1066
python数据结构——链表 文章目录python数据结构——链表单链表概述单向链表实现：单链表优化 单链表 概述 数据结构是计算机科学必须掌握的一门学科，在C语言中，可以使用“指针+结构体”来实现链表；而在python中，则可以采用“引用+类”来实现链表。 链表的定义：是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的链接。 链表的结构：data 为自定义的数据，next为下一个节点的地址，head为保存首位节点的地址： 单向链表实现： 单向链表(单链表)是链表的一
Python中关于‘self’的种种用法笔记
OneFine的技术博客
01-11 2527
方法中的 self 参数 给对象增加属性 先来看个例子： class Cat: def eat(self): print(&quot;%s 爱吃鱼&quot; % self.name) 在 Python 中，要 给对象设置属性，非常的容易，但是不推荐使用 tom.name = &quot;Tom&quot; lazy_cat.name = &quot;大懒猫&quot; 因为：对象属性的封装
LeetCode训练题--反转链表
小康的博客
12-09 374
这里用俩种方法解决 第一种方法，指针反转法 将 反转成 定义三个指针 n1=NULL，n2指向第一个节点，n3指向第三个节点. 反转的时候将n2指向n1,n2赋给n1，n3赋给n2，n3往后挪 终止条件为n2==NULL 返回n1 注意当第二次的时候n3就已经为NULL了，第三次的时候n3已经为野指针。 /** * Definition for singly-linked list. * struct ListNode { ...
链表相关面试算法总结实现
guihunkun的博客
09-06 314
链表相关算法总结实现 链表应该是面试过程中被提及最频繁的数据结构了，首先链表的结构简单，链表的创建，插入节点，删除节点等操作仅需要较短的代码就能实现。加上链表是一种动态数据结构，需要对指针进行操作，因此需要面试者有较好的编程功底。下面将给出与链表相关的算法题。皆用C++语言实现， 题目多来源于LeetCode。关于链表的题目关键是如下四个思路： 可以给链表加上一个头节点，对链表删除亦或其他操作都方便很多。 快慢指针是灵魂，对判断是否有环，返回倒数第k个节点很有帮助。 距离计算也是一大方法，如找到相交链表的
链表反转全家桶（二）：动画详解两两交换链表中的节点
我的的博客
10-01 470
上回说到面试中的一个高频题目：单链表反转，提到它的“难兄难弟”不是那么简单。今天就来分析一下它的二哥：“两两交换链表中的节点”。 题目描述如下。 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例: 给定 1->2->3->4, 你应该返回 2->1->4->3. 方法一：三指针迭代 有了上回单链表反转的双指针迭代法的基础，再来解决它二哥，就相对容易很多了。 “巧妇难为无米之炊”。题目中说的
10.Python修炼之路【14-链表】2018.05.11
youyouwuxin1234的博客
05-11 783
关键字 
数据结构-链表
weixin_45666566的博客
04-20 816
链表一.单链表1.1单链表的概念1.2单链表的基本实现 链表是由n个结点离散分配，彼此通过指针相连构成的。 专业术语： 首结点：第一个有限节点 尾结点：最后一个有效节点 头结点：头结点的数据类型和首节点（）类型一样。第一个有效节点之前的那个节点，头结点并不存放有效数据，加头结点的目的主要是为了方便对链表的操作。 头指针（head):指向第一个结点的地址 尾标志（尾结点tail):终端结点的指针域为...
人工智能3.3 -- python算法篇（三）链表
Acegem的博客
09-21 300
php转python及人工智能之路python，大数据，机器学习，深度学习，计算机视觉二、python算法篇（三）链表链表的提出前言链表的定义链表的好处分类python中变量标识的本质head，next python，大数据，机器学习，深度学习，计算机视觉 二、python算法篇（三）链表 链表的提出 前言 前面学了顺序表，但顺序表的存储地址是连续的，有时候处理起来不方便，因为顺序表在构建时需要预...
【链表】反转链表（剑指offer24！！！！必会题）
Pz_hh的博客
09-01 66
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 输入: 1->2->3->4->5->NULL 输出: NULL<-1<-2<-3<-4<-5 方法：头插法Time:O（N） Space：0 头插法：三步走（1暂存，2指向，3，归位） pre在第一个.
数据结构与算法分析——链表表示与信息处理
数据结构不仅包括数据的逻辑结构（如链表、数组），还包括物理结构（如内存布局）以及与这些结构相关的操作（如插入、删除、查找）。 1.1节中提到了数据结构的重要性，指出良好的数据结构能够提高算法的效率。例如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值