python数据结构之双向链表

最新推荐文章于 2024-04-24 21:16:44 发布
最新推荐文章于 2024-04-24 21:16:44 发布
阅读量862 收藏 1
点赞数
文章标签： 链表 数据结构 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51894865/article/details/122754055
版权

python数据结构之双向链表

  1. 双向链表可以是循环的也可以是不循环的；
  2. 主要有left前驱指针，right后驱指针；

代码部分

  1. 结点类的创建
class Node:
    def __init__(self, value):
        self.data = value
        self.prior = None
        self.after = None
  1. 初始化链表
def init_list(head_ptr: Node):
    data_arr = [10, 20, 30, 40, 50, 60]
    ptr = head_ptr
    for i in range(len(data_arr)):
        new_node = Node(data_arr[i])
        new_node.prior = ptr
        new_node.after = None
        ptr.after = new_node
        ptr = new_node
    ptr.after = head_ptr
    head_ptr.prior = ptr
  1. 增加单个数据结点
def add_node(head_ptr: Node, value: int):
    new_node = Node(value)
    ptr = head_ptr
    while ptr.after != head_ptr:
        ptr = ptr.after
    new_node.after = ptr.after
    new_node.prior = ptr
    ptr.after = new_node
  1. 通过索引插入数据结点
def Insert_Node_index(head_ptr, index: int, value: int):
    new_node = Node(value)
    index_loc = 0
    flag = True
    if index == 0:
        ptr = head_ptr
        new_node.after = head_ptr
        head_ptr.prior = new_node
        while ptr.after != head_ptr:
            ptr = ptr.after
        new_node.prior = ptr
        ptr.after = new_node
        head_ptr = new_node
        flag = False
    elif index > 0:
        ptr = head_ptr
        while True:
            if index_loc == (index - 1):
                new_node.after = ptr.after
                new_node.prior = ptr.prior
                ptr.after.prior = new_node
                ptr.after = new_node
                flag = False
                break
            index_loc += 1
            ptr = ptr.after
            if ptr == head_ptr:
                break
    if flag:
        new_node.after = head_ptr
        new_node.prior = head_ptr.prior
        head_ptr.prior.after = new_node
    return head_ptr
  1. 通过值的寻找插入
def Insert_Node_Value(head_ptr, find_value, new_value):
    new_node = Node(new_value)
    ptr = head_ptr
    while ptr.data != find_value:
        ptr = ptr.after
        if ptr == head_ptr:
            break
    new_node.after = ptr
    new_node.prior = ptr.prior
    ptr.prior.after = new_node
    ptr.prior = new_node
  1. 通过索引删除数据
def Del_Node_Index(head_ptr, index):
    index_loc = 0
    ptr = head_ptr
    if index == 0:
        head_ptr.prior.after = head_ptr.after
        head_ptr.after.prior = head_ptr.prior
        head_ptr = head_ptr.after
    elif index > 0:
        while True:
            if index == index_loc:
                ptr.prior.after = ptr.after
                ptr.after.prior = ptr.prior
                break
            index_loc += 1
            ptr = ptr.after
    return head_ptr
  1. 通过值寻找删除结点
def Del_Node_Value(head_ptr, find_value):
    ptr = head_ptr
    if head_ptr.data == find_value:
        head_ptr.prior.after = head_ptr.after
        head_ptr.after.prior = head_ptr.prior
        head_ptr = head_ptr.after
        return head_ptr
    else:
        while True:
            if ptr.data == find_value:
                ptr.prior.after = ptr.after
                ptr.after.prior = ptr.prior
                break
            ptr = ptr.after
            if ptr == head_ptr:
                break
    return head_ptr
  1. 查找所有节点数值
def Query_Index_Node(head_ptr, index):
    loc_index = 0
    find_data = -1
    ptr = head_ptr
    while True:
        if index == loc_index:
            find_data = ptr.data
            break
        loc_index += 1
        ptr = ptr.after
        if ptr == head_ptr:
            break
    return find_data
  1. 查找值的索引
def Query_Value_Index(head_ptr, find_data):
    index = -1
    find_index = -1
    ptr = head_ptr
    while True:
        index += 1
        if ptr.data == find_data:
            find_index = index
        ptr = ptr.after
        if ptr == head_ptr:
            break
    return find_index
  1. 输出数据
def Print_all(head_ptr):
    ptr = head_ptr
    while True:
        print(ptr.data, end="\t")
        ptr = ptr.after
        if ptr == head_ptr:
            break

结论

class Node:
    def __init__(self, value):
        self.data = value
        self.prior = None
        self.after = None


def init_list(head_ptr: Node):
    data_arr = [10, 20, 30, 40, 50, 60]
    ptr = head_ptr
    for i in range(len(data_arr)):
        new_node = Node(data_arr[i])
        new_node.prior = ptr
        new_node.after = None
        ptr.after = new_node
        ptr = new_node
    ptr.after = head_ptr
    head_ptr.prior = ptr


def add_node(head_ptr: Node, value: int):
    new_node = Node(value)
    ptr = head_ptr
    while ptr.after != head_ptr:
        ptr = ptr.after
    new_node.after = ptr.after
    new_node.prior = ptr
    ptr.after = new_node


def Insert_Node_index(head_ptr, index: int, value: int):
    new_node = Node(value)
    index_loc = 0
    flag = True
    if index == 0:
        ptr = head_ptr
        new_node.after = head_ptr
        head_ptr.prior = new_node
        while ptr.after != head_ptr:
            ptr = ptr.after
        new_node.prior = ptr
        ptr.after = new_node
        head_ptr = new_node
        flag = False
    elif index > 0:
        ptr = head_ptr
        while True:
            if index_loc == (index - 1):
                new_node.after = ptr.after
                new_node.prior = ptr.prior
                ptr.after.prior = new_node
                ptr.after = new_node
                flag = False
                break
            index_loc += 1
            ptr = ptr.after
            if ptr == head_ptr:
                break
    if flag:
        new_node.after = head_ptr
        new_node.prior = head_ptr.prior
        head_ptr.prior.after = new_node
    return head_ptr


def Insert_Node_Value(head_ptr, find_value, new_value):
    new_node = Node(new_value)
    ptr = head_ptr
    while ptr.data != find_value:
        ptr = ptr.after
        if ptr == head_ptr:
            break
    new_node.after = ptr
    new_node.prior = ptr.prior
    ptr.prior.after = new_node
    ptr.prior = new_node


def Del_Node_Index(head_ptr, index):
    index_loc = 0
    ptr = head_ptr
    if index == 0:
        head_ptr.prior.after = head_ptr.after
        head_ptr.after.prior = head_ptr.prior
        head_ptr = head_ptr.after
    elif index > 0:
        while True:
            if index == index_loc:
                ptr.prior.after = ptr.after
                ptr.after.prior = ptr.prior
                break
            index_loc += 1
            ptr = ptr.after
    return head_ptr


def Del_Node_Value(head_ptr, find_value):
    ptr = head_ptr
    if head_ptr.data == find_value:
        head_ptr.prior.after = head_ptr.after
        head_ptr.after.prior = head_ptr.prior
        head_ptr = head_ptr.after
        return head_ptr
    else:
        while True:
            if ptr.data == find_value:
                ptr.prior.after = ptr.after
                ptr.after.prior = ptr.prior
                break
            ptr = ptr.after
            if ptr == head_ptr:
                break
    return head_ptr


def Query_Index_Node(head_ptr, index):
    loc_index = 0
    find_data = -1
    ptr = head_ptr
    while True:
        if index == loc_index:
            find_data = ptr.data
            break
        loc_index += 1
        ptr = ptr.after
        if ptr == head_ptr:
            break
    return find_data


def Query_Value_Index(head_ptr, find_data):
    index = -1
    find_index = -1
    ptr = head_ptr
    while True:
        index += 1
        if ptr.data == find_data:
            find_index = index
        ptr = ptr.after
        if ptr == head_ptr:
            break
    return find_index


def Print_all(head_ptr):
    ptr = head_ptr
    while True:
        print(ptr.data, end="\t")
        ptr = ptr.after
        if ptr == head_ptr:
            break


if __name__ == '__main__':
    head = Node(1)
    init_list(head)
    head = Insert_Node_index(head, 2, 80)
    Insert_Node_Value(head, 55, 9892)
    Print_all(head)

    head = Del_Node_Index(head, 0)
    head = Del_Node_Value(head, 10)
    print()
    Print_all(head)
    print()
    print(Query_Index_Node(head, 0))
    print(Query_Value_Index(head, 00))
    head_one = Node(8273)
    init_list(head_one)
dio&jojo
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python 算法基础篇：链表和双向链表的实现与应用
小蓝枣的博客
07-24 482
链表和双向链表是常用的线性数据结构，它们在算法和程序设计中有着广泛的应用。本篇博客将重点介绍链表和双向链表的原理、实现以及它们在不同场景下的应用。我们将使用 Python 来演示链表和双向链表的实现，并通过实例展示每一行代码的运行过程。
数据结构与算法之Python实现——循环链表、双向循环链表
weixin_62917800的博客
11-05 2151
循环链表及双向循环链表保姆级讲解，一步一代码，并且最后还有具体应用的实现，进来看一下呗~
LeetCode讲解算法3-数据结构[链表]（Python版）
最新发布
总裁余（余登武）博客
04-24 706
带头节点的单链表。
python之双链表
xiaoyang01234的博客
12-18 520
这里讲解一个双链表节点添加的例子，我们看到10，15，20这三个点的位置，其中原本是10和20相互连接，首先，我们要先将15的next指向20，因为，如果我们现将10的next指向15的话，那20的地址就会消失，这要就会导致我们的数据丢失，所以要先连接15和20，然后就是把20的prior(前驱)指向15，最后再是15的prior(前驱)指向10,10的next指向15，这样我们就完成插入的程序了。
python——链表、双链表、链栈、链队列
m0_58820574的博客
11-02 827
一、链表 链表类的定义： 创建链表——头插法 创建链表——尾插法 二、双链表 定义双链表 双链表——插入p节点 双链表——删除 小结 三、链栈 四、链队列
Python实现双向链表：从基础到应用
欢迎来到“Python算法探索”，我是GT算法工程师，一名热爱计算机算法的博主。在这里，我们将一起深入探索Python世界中的各种算法，从基础到高级，从理论到实践。我参加过很多算法比赛，积累了丰富的经验，希望通过这个播客与你分享。让我们一起用Python探
03-01 383
本文将介绍如何使用Python实现一个简单的双向链表数据结构，包括节点的定义、链表的创建、插入、删除和遍历等功能。双向链表在数据结构中具有特殊的意义，因为它允许我们从两个方向遍历链表。通过实际代码示例，我们将逐步解释每个部分的含义和作用，并讨论双向链表在实际应用中的优势和用例。
Python数据结构之双向链表的定义与使用方法示例
09-20
Python中的双向链表是一种线性数据结构，与单链表相比，它在每个节点中不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这使得双向链表可以在正向和反向两个方向上进行遍历，提高了操作的灵活性。 ...
Python单向链表和双向链表原理与用法实例详解
09-20
Python实现链表时，可以使用内置的类来简化操作，如`collections`模块中的`deque`可以用来模拟双向链表，但通常我们会选择自定义数据结构，以便更好地理解和控制链表的行为。 总的来说，链表在内存效率和动态性方面...
（Python3）数据结构–双向链表的原理及实现
01-20
学过数据结构那自然是最好的 原理和需要注意的点 双向链表 双向链表和单链表的差别在哪？双向链表的节点和单链表的节点是不一样的。单链表的节点有item和next，而双向链表的节点还必须有一个指向前一个节点的prior...
python数据结构之链表的实例讲解
09-21
链表是一种重要的数据结构，尤其在Python编程中，它提供了高效的数据操作方式。本文将深入讲解链表的概念、特点以及如何在Python中实现链表。 首先，链表是一种线性数据结构，它由一系列节点组成，每个节点包含两...
python 双向链表_python双向链表
weixin_39622562的博客
11-26 247
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！usrbinenv python #-*- coding:utf-8 -*- @author:yzk13 @time:20180418双向链表https:blog.csdn.netqq490691606articledetails49948263 class node(object)...
LinkLink_curd_Python双向链表_游标排序_
09-29
Python双向链表
Python 数据结构之双向链表的实现
haeasringnar的博客
02-06 624
双向链表： 即每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。当节点既是头结点又是尾节点时，两个链接均为空值。 # 双向链表基于Python语言的实现 ''' 双向链表需要实现的方法： is_empty() 链表是否为空 len() 链表长度 travel() 遍历整个链表 add(item) 链表头部添加元...
python语言实现双向链表
bkr129的博客
12-26 492
python语言实现双向链表 双向链表顾名思义，存在两个指针：头指针和尾指针，分别指向前驱节点和后续节点。 双向链表所包含的操作如下： is_empty() 链表为空 length() 链表长度 trvael() 便利链表 add(item) 头部添加元素 append(item) 尾部添加元素 insert(pos, item) 指定位置添加元素 remove(item) 删除节点 sear...
【数据结构Python描述】双向链表简介、Python实现及应用
weixin_37780776的博客
08-31 1917
双向链表简介、Python实现及应用
python数据结构--双端链表的实现
qq_23387055的博客
04-30 285
''' 双链表的实现 ''' class Node(object): def __init__(self,value=None,prev=None,next=None): self.value = value self.prev = prev self.next = next class CircualDoubleLinedList(ob...
Python实现双向链表
a6694792的博客
07-18 212
Python双向链表 class DwLinkedList: class Node: """ 结点类 用于存放数值以及前后指针 """ def __init__(self, value, last, next=None): self.value = value self.last = last self.next = next def __init__(
python实现双向链表
qq_39112101的博客
06-12 476
双向链表示意图如下： 在头部插入元素如下图所示： 让node的next指向值为100的节点，也就是让node.next = self.__head。 让头（蓝色区域）指向node节点，也就是self.__head =node 让值为100区域的prev指向node节点，也就是node.next.prev = node 在尾部插入元素如下图所示： node.nex...
python数据结构之双向链表的实现
Darkman_EX的博客
01-14 350
python数据结构之双向链表的实现 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 class Node(object): """节点""" def __init__(self, item): self.item = item ...
Python数据结构双循环链表
11-15
双向循环链表是一种常见的数据结构，它与单向链表的区别在于每个节点都有两个指针，一个指向前一个节点，一个指向后一个节点。而循环链表则是在单向或双向链表的基础上，将最后一个节点的指针指向头节点，形成一个环...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值