C#数据结构04:双链表

已于 2024-07-21 14:50:39 修改
阅读量301 收藏 4
点赞数 11
分类专栏： C#数据结构 文章标签： c# 数据结构 算法
于 2024-07-21 11:05:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78736909/article/details/140583576
版权

说明
（此系列帖子记录数据结构学习成果)

了解双链表

相比于单链表，双链表只是内部多了一个用于指向前继节点的指针，其他实现逻辑基本相似，只需要做下修改即可

双链表的构成

public T data; //实际存储的数据
public Node prev;//用来指向前一个节点
public Node next;//用来指向下一个节点

双链表基本结构

 class DoubleLinkedList<T>
 {
     //内部节点类
     private class Node
     {
         public T data;   //实际存储的数据
         public Node prev;//用来指向前一个节点
         public Node next;//用来指向下一个节点

         //构造函数,初始化链表
         public Node(T data ,Node prev ,Node next)
         {
             this.data= data;
             this.prev= prev;
             this.next= next;
         }
         public Node(T data)
         {
             this.data = data;
             this.prev = null;
             this.next = null;
         }

         //重写ToString
         public override string ToString()
         {
             return data.ToString();
         }
     }

     private Node Head; //记录链表得头部
     private Node Tail; //记录链表的尾部
     private int N;     //链表存储多少元素

     public DoubleLinkedList()
     {
         //初始化链表,此时全为null
         Head = null;
         Tail = null;
         N = 0;
     }

     //访问链表元素数量
     public int Count => N;
     //判断链表是否为空
     public bool IsEmpty => N == 0;
}

在Add方法中，插入中间节点

在这里插入图片描述

在定义cuurrent节点后，我们需要把current指向插入节点的位置。newNode节点是我们需要插入的节点

  • 我们需要把newNode节点先和链表建立联系，即①②
  • 再将newNode节点与表中节点建立连接后，方可执行断联操作，即③④

删除中间节点

  • 同样的道理，我们需要将删除节点的prev节点和next节点建立联系，再执行删除当前节点的操作
  • 即 current.prev.next = current.next; current.next.prev = current.prev;

增

        public void Add(int index, T t)
        {
            if (index <0 || index >N)
                throw new ArgumentOutOfRangeException("非法索引");

            //插入头部
            if (index == 0)
            {
                Node newNode = new Node(t);
                if (Head != null)
                {
                    Head.prev = newNode;
                    newNode.next = Head;
                }
                Head = newNode;
                //如果这是唯一一个节点，更新尾部
                if (Tail == null)
                    Tail = Head;
            }
            //尾部插入
            else if (index == N)
            {
                Node newNode = new Node(t);
                if (Tail != null)
                {
                    Tail.next = newNode;
                    newNode.prev = Tail;
                }
                Tail = newNode;
                //如果这是唯一一个节点，更新头部
                if (Head == null)
                    Head = Tail;
            }
            //链表中间插入
            else
            {
                Node newNode = new Node(t);

                //遍历节点,找到要插入位置的前一个节点
                Node current = Head;
                for (int i = 0; i < index;i++)
                    current = current.next;//此时current指向要插入的位置
                //连接节点
                newNode.prev = current.prev;
                newNode.next = current;
                current.prev.next = newNode;
                current.prev = newNode;
            }
            //增加链表长度
            N++;
        }

总代码

using System;
using System.Text;

namespace List
{
    class DoubleLinkedList<T>
    {
        //内部节点类
        private class Node
        {
            public T data;   //实际存储的数据
            public Node prev;//用来指向前一个节点
            public Node next;//用来指向下一个节点

            //构造函数,初始化链表
            public Node(T data ,Node prev ,Node next)
            {
                this.data= data;
                this.prev= prev;
                this.next= next;
            }
            public Node(T data)
            {
                this.data = data;
                this.prev = null;
                this.next = null;
            }

            //重写ToString
            public override string ToString()
            {
                return data.ToString();
            }
        }

        private Node Head; //记录链表得头部
        private Node Tail; //记录链表的尾部
        private int N;     //链表存储多少元素

        public DoubleLinkedList()
        {
            //初始化链表,此时全为null
            Head = null;
            Tail = null;
            N = 0;
        }

        //访问链表元素数量
        public int Count => N;
        //判断链表是否为空
        public bool IsEmpty => N == 0;

        //在指定位置插入一个元素
        public void Add(int index, T t)
        {
            if (index <0 || index >N)
                throw new ArgumentOutOfRangeException("非法索引");

            //插入头部
            if (index == 0)
            {
                Node newNode = new Node(t);
                if (Head != null)
                {
                    Head.prev = newNode;
                    newNode.next = Head;
                }
                Head = newNode;
                //如果这是唯一一个节点，更新尾部
                if (Tail == null)
                    Tail = Head;
            }
            //尾部插入
            else if (index == N)
            {
                Node newNode = new Node(t);
                if (Tail != null)
                {
                    Tail.next = newNode;
                    newNode.prev = Tail;
                }
                Tail = newNode;
                //如果这是唯一一个节点，更新头部
                if (Head == null)
                    Head = Tail;
            }
            //链表中间插入
            else
            {
                Node newNode = new Node(t);

                //遍历节点,找到要插入位置的前一个节点
                Node current = Head;
                for (int i = 0; i < index;i++)
                    current = current.next;//此时current指向要插入的位置
                //连接节点
                newNode.prev = current.prev;
                newNode.next = current;
                current.prev.next = newNode;
                current.prev = newNode;
            }
            //增加链表长度
            N++;
        }
        //在头部插入
        public void AddFirst(T t) => Add(0, t);
        //在尾部插入
        public void AddLast(T t) => Add(N, t);

        // 查找链表是否包含元素
        public bool Contains(T t)
        {
            Node current =Head;
            while (current != null)
            {
                if (current.data.Equals(t))
                    return true;
                current = current.next;
            }
            return false;
        }
        //查询索引处的元素
        public T Get(int index)
        {
            if (index < 0 || index >= N)
                throw new ArgumentOutOfRangeException("非法索引");

            Node current = Head;
            for (int i = 0; i < index; i++)
                current = current.next;

            return current.data;
        }

        //修改元素
        public void Set(int index, T newt)
        {
            if (index < 0 || index >= N)
                throw new ArgumentOutOfRangeException("非法索引");

            Node current = Head;
            for (int i = 0; i < index; i++)
                current = current.next;

            current.data = newt;
        }

        //删除指定位置元素
        public T RemoveAt(int index)
        {
            if (index < 0 || index >= N)
                throw new ArgumentOutOfRangeException("非法索引");

            Node current = Head;
            if (index == 0)
            {
                //删除头部
                Head = Head.next;
                if (Head !=null)
                    Head.prev = null;
                else
                    Tail = null;
            }
            else if (index == N - 1)
            {
                //删除尾部
                Tail = Tail.prev;
                if (Tail != null)
                    Tail.next = null;
                else
                    Head = null;
            }
            else
            {
                //删除中间
                for (int i = 0; i < index; i++)
                    current = current.next;

                current.prev.next = current.next;
                current.next.prev = current.prev;
            }

            N--;
            return current.data;
        }
        //查找元素删除
        public void Remove(T t)
        {
            Node current = Head;

            while (current != null)
            {
                //找到元素
                if (current.data.Equals(t))
                {
                    if (current.prev != null)
                        current.prev.next = current.next;
                    else
                        Head = current.next;

                    if (current.next != null)
                        current.next.prev = current.prev;
                    else
                        Tail = current.prev;

                    N--;
                }
                current = current.next;
            }
        }
        //重写Tostring()
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            Node current = Head;
            while (current != null)
            {
                sb.Append(current.data + "<->");
                current = current.next;
            }
            sb.Append("Null");
            return sb.ToString();
        }
    }
}
4463fger
关注
  • 11
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#数据结构之双向链表(DbLinkList)实例详解
09-03
在C#中，双向链表（Double-Linked List，简称DbLinkList）是一种重要的数据结构，它允许在列表中的每个元素都有两个链接：一个指向前一个元素，另一个指向后一个元素。这种数据结构使得在链表中进行前向和后向遍历变...
C#模拟链表数据结构的实例解析
09-02
总结起来，链表数据结构在C#中的模拟涉及创建表示节点的类和管理链表的类。链表提供了一种灵活的方式处理动态数据，尤其是对于插入和删除操作，其性能优于固定大小的数组。同时，理解和掌握链表结构对于提升编程能力...
C#数据结构(2) 链表
weixin_43441742的博客
03-24 907
导言 GitHub项目地址：https://github.com/HarmoniaLeo/CSharp-DS 线性表家族除了我们上次分享的顺序表外,另一位重要成员就是链表。链表是一串结点，每个结点维护着自己的数值，以及指向其他结点的指针。指针将结点像锁链的一环一环一样扣在一起，在从一个结点访问另一个结点时，就通过指针来“穿梭”。 链表根据拥有指针的不同，分为只有指向下一个结点指针的单向链表，和同时...
[数据结构]链表之双链表
beenles的博客
06-29 871
双向链表（Doubly Linked List）是一种常见的数据结构，与单链表相比，它增加了一个指向前驱节点的指针，因此每个节点除了有指向后继节点的指针外，还有一个指向前驱节点的指针。双向链表是一种常见的数据结构，与单向链表相比，它增加了一个指向前驱节点的指针，因此每个节点除了有指向后继节点的指针外，还有一个指向前驱节点的指针。与栈比较：双向链表和栈都可以实现FILO（先进后出）的数据结构，但是双向链表相比栈更加灵活，可以支持在任意位置插入和删除节点，而栈只能在栈顶插入和删除元素。时间复杂度为O(n)。
C#双向链表实现：揭秘双向链表内实现诸多方法的那些事
wenchm的博客
03-02 337
在双向链表中，每个节点有两个指针域，一个指向它的前一个节点（即直接前驱），另一个指向它的后一个节点（即直接后继）。这种设计使得双向链表可以进行双向遍历，即可以从头节点开始向前遍历，也可以从尾节点开始向后遍历。// 数据域int data;// 指向直接前驱的指针Node* prev;// 指向直接后继的指针Node* next;
数据结构经典面试之链表——C#和C++篇
qq_35320456的博客
06-21 758
链表是一种常见的基础数据结构，它由一系列节点组成，每个节点包含数据域和指向下一个节点的指针。链表与数组不同，它不要求节点在内存中连续存储，这使得链表在插入和删除操作时具有较高的效率
C#数据结构-双链表
mango_love的专栏
04-08 874
据说单链表没有回路，那么双链表也出现了，既包括后继指针，又加入了前驱指针，某个元素可以寻找他上面一个元素，也可以寻找到下一个元素。当然双链表也是链表的一种。物理存储结构：不一定是连续的存储区域逻辑存储结构：逻辑上存储是连续的使用场景：跟单链表一样，适用于对数据的大量新增和删除元素，对访问元素无要求，预先无法确定数据量的程序首先创建存储元素结构/// &lt;summary&gt; /// ...
数据结构：链表
梁辰兴的博客
09-17 362
链表（Linked List）是Java中常见的一种数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的引用。链表可以分为单向链表、双向链表和循环链表三种类型。简介链表是一种线性数据结构，用于存储有序的元素集合。链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用（指针）。链表中的元素可以通过遍历链表来访问，每个节点都有一个指向下一个节点的引用，直到达到链表的末尾。链表可以分为单向链表、双向链表和循环链表三种类型。
数据结构之双向链表
技术分享博客
09-07 544
系统开发时缓存的LRU算法就是双向链表的运用场景之一。
C++ 数据结构之-双向链表(link_list)
who_I_am__的博客
09-28 1050
双向链表（Doubly Linked List）是一种常见的数据结构，它与单向链表相似，但每个节点有两个指针，一个指向前一个节点（前驱节点），一个指向后一个节点（后继节点）。前向和后向遍历：由于每个节点都有前驱和后继指针，双向链表可以从头节点或尾节点开始，沿着不同的方向遍历整个链表。维护复杂性：因为每个节点有两个指针，所以在插入、删除或修改节点时，需要同时更新相关节点的前驱和后继指针，这增加了链表的维护复杂性。4、bool contains(T t) const // 判断元素t是否在list中。
C#数据结构学习：非线性结构之广义表和多重链表
LIN943168247的博客
01-16 975
我们通过一元多项式的例子认识了链表和顺序表，但是遇到了二元多项式的时候又该如何表示呢？ 比如，给定二元多项式： 遇到这种问题，有两种解决办法： ①重新定义一个符合需求的链表（本文以链表来说明广义表），但是每次都遇到不同需求都要定义不同链表，这实在是太麻烦了。所以不推荐 ②可以将上述二元多项式看成关于X的一元多项式 然后前面系数a，b，c又是一个一元多项式，因此我们可以在原来的代码中Value1...
C#数据结构与算法揭秘四 双向链表
09-05
《C#数据结构与算法揭秘四：双向链表》 双向链表是一种高级的数据结构，它在单链表的基础上增加了对前驱节点的引用，使得在链表中进行前后移动变得更为便捷。在C#中，我们可以定义一个名为`DbNode<T>`的类来表示...
C#中的栈和队列
最新发布
weixin_64532720的博客
07-20 565
栈和队列是非常重要的两种数据结构,在软件设计中应用很多。栈和队列也是线性结构,线性表、栈和队列这三种数据结构的数据元素以及数据元素间的逻辑关系完全相同,差别是线性表的操作不受限制,而栈和队列的操作受到眼制。栈的操作只能在表的一端进行,队列的插入操作在表的一端进行而其它操作在表的另一端进行,所以,把栈和队列称为操作受限的线性表。BCL中的栈​namespace 栈T Pop();T Peek();​​​​namespace 栈​​top = -1;
C# 删除DataTable里符合条件的行
Pei_hua100的专栏
07-20 90
有时候我们需要删除DataTable里指定的某些行时，常用的做法是foreach遍历。当DataTable的rows.count少时并不会影响效率，但是当行数多时，效率会下降。所以，使用DataTable内置的Select方法来条件筛选就是一个不错的选择。
C# 3.数组遍历和储存对象
weixin_73535261的博客
07-17 315
练习：练习：for循环存放 10 20 30 ……100 遍历数组 计算每一个和元素相加的和10+20+……public string GirlName { get;总结： 1 数组for循环存放对象2 数组for循环遍历元素。创建数组对象，存放10个学生对象；控件：按钮button，label文本。项目目的添加10个学生并展示。
c#中匿名方法的定义和使用
weixin_64532720的博客
07-16 202
在Action里面传入参数变量 action是不需要返回值的。在Func里面也要传入参数变量 但是最后一个是返回值类型。t2("你好",250);
PLC中的高低字节如何理解？
qq_41184334的博客
07-16 292
双字（Double Word，通常是32位整数）的高低字节定义可能会因具体的PLC型号和通信协议而有所不同。通常，双字可以被划分为两个16位字，每个16位字又分为高字节和低字节。
【C#】计算两条直线的交点坐标
wangnaisheng的专栏
07-17 378
【C#】计算两条直线的交点坐标

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值