C# 实现双向链表

最新推荐文章于 2022-04-17 00:32:00 发布
最新推荐文章于 2022-04-17 00:32:00 发布
阅读量1.2k 收藏 16
点赞数 2
分类专栏： 数据结构学习笔记 文章标签： 链表 数据结构 c# 算法 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FHelloWorld/article/details/108474453
版权

双向链表

目录

节点代码

    class Node
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public string NickName { get; set; }
        public Node Next { get; set; }
        public Node Pre { get; set; }

        public Node(int iniID, string iniName, string iniNickName)
        {
            this.ID = iniID;
            this.Name = iniName;
            this.NickName = iniNickName;
        }

        public override string ToString()
        {
            return $"[ID: {ID}, Name: {Name}, NickName: {NickName}]";
        }
    }

双向链表与单链表相比只是多了一个指向前驱节点的pre。
单链表可参考C#实现单链表.

[注] 重写ToString 方法方便打印信息

代码框架

    class DoubleLinkedList
    {
        public Node Head { get; }

        public DoubleLinkedList()
        {
            this.Head = new Node(1, "", "");
        }

        //删除节点
        public void Delete(int ID)

        //修改节点内容，与单链表一样
        public void Update(Node newNode)
        
        //添加节点到双向链表的最后
        public void Add(Node NewNode)

        //根据ID大小插入
        public void InsertByOrder(Node newNode)

        //遍历双向链表
        public void Display()

    }

思路

遍历

与单链表一样，但是可以向前遍历。
通过一个辅助变量找到next为null的节点，即到达链表末尾

 //遍历双向链表
 public void Display()
 {
     if (Head.Next == null)
     {
         Console.WriteLine("链表为空");
         return;
     }

     Node temp = Head.Next;
     while (true)
     {
         if (temp == null)
         {
             break;
         }
         Console.WriteLine(temp.ToString());
         temp = temp.Next;
     }
 }

直接添加到链表末尾

通过一个辅助变量遍历单链表，找到next为null的节点
temp.next = newNode;
newNode.pre = temp;

 //添加节点到双向链表的最后
 public void Add(Node NewNode)
 {
     Node temp = Head;
     while (true)
     {
         if (temp.Next == null)
         {
             break;
         }
         temp = temp.Next;
     }
     //构成双向链表
     temp.Next = NewNode;
     NewNode.Pre = temp;
 }

依据编号顺序添加

修改代码为：

temp.Next.Pre = newNode;
newNode.Next = temp.Next;
newNode.Pre = temp;
temp.Next = newNode;

判断条件与单链表中依据编号顺序添加相同，只是在进行添加时，如果待插入位置是链表的末尾，此时temp.Next.Pre 是 null, 不需要对 “null.pre” 进行修改。

 //根据ID大小插入
 public void InsertByOrder(Node newNode)
 {
     Node temp = Head;
     bool flag = false;
     while (true)
     {
         if (temp.Next == null)
         {
             break;
         }
         if (temp.Next.ID > newNode.ID)
         {
             break;
         }
         else if (temp.Next.ID == newNode.ID)
         {
             flag = true;
             break;
         }
         temp = temp.Next;
     }
     if (flag)
     {
         Console.WriteLine("当前ID已存在");
     }
     else
     {
     	//如果temp是链表末尾的节点，则不需要执行if语句中的内容
         if (temp.Next != null)
         {
             temp.Next.Pre = newNode;
         }
         newNode.Next = temp.Next;
         newNode.Pre = temp;
         temp.Next = newNode;
     }
 }

修改

与单链表相同，用同一个bool类型的flag来表示是否找到，通过辅助变量找到待修改的节点，替换即可

 //修改节点内容，与单链表一样
 public void Update(Node newNode)
 {
     if (Head.Next == null)
     {
         Console.WriteLine("链表为空");
         return;
     }

     var temp = Head.Next;
     bool flag = false;
     while (true)
     {
         if (temp == null)
         {
             break;
         }
         if (temp.ID == newNode.ID)
         {
             flag = true;
             break;
         }
         temp = temp.Next;
     }
     if (flag)
     {
         temp.Name = newNode.Name;
         temp.NickName = newNode.NickName;
     }
     else
     {
         Console.WriteLine("未找到对应节点");
     }
 }

删除

与单链表不同，双向链表可以实现“自我删除”，不需要通过待删除节点的上一节点来进行删除。

找到待删除的节点，执行接下来的代码：
temp.pre.next = temp.next;
temp.next.pre = temp.pre

需要注意的是，当待删除节点是链表的最后一个节点时，此时temp.next指向的时null，因此不需要执行temp.next.pre = temp.pre; 这一句

 //删除节点
 public void Delete(int ID)
 {
     if (Head.Next == null)
     {
         Console.WriteLine("链表为空");
         return;
     }

     var temp = Head.Next;
     var flag = false;

     while (true)
     {
         if (temp == null)
         {
             break;
         }
         if (temp.ID == ID)
         {
             flag = true;
             break;
         }
         temp = temp.Next;
     }

     if (flag)
     {
         temp.Pre.Next = temp.Next;

         if (temp.Next != null)
         {
             //这里有风险，如果删除的节点是最后一个，
             //会出问题，如果是最后一个节点，
             //不需要执行下面的语句
             temp.Next.Pre = temp.Pre;
         }
     }
     else
     {
         Console.WriteLine("未找到");
     }
 }

完整代码(包含测试)

using System;

namespace DoubleLinkedListDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("双向链表测试");
            Node node1 = new Node(1, "宋江", "及时雨");
            Node node2 = new Node(2, "卢俊义", "玉麒麟");
            Node node3 = new Node(3, "吴用", "智多星");
            Node node4 = new Node(4, "林冲", "豹子头");

            DoubleLinkedList list = new DoubleLinkedList();
            list.InsertByOrder(node1);
            list.InsertByOrder(node2);
            list.InsertByOrder(node3);
            list.InsertByOrder(node4);

            list.Display();

            Wrap("修改");
            Node newNode = new Node(4, "公孙胜", "入云龙");
            list.Update(newNode);
            list.Display();

            Wrap("删除");
            list.Delete(3);
            list.Display();
        }

        static void Wrap(string info)
        {
            Console.WriteLine("\n\n\n" + info);
        }
    }
    class Node
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public string NickName { get; set; }
        public Node Next { get; set; }
        public Node Pre { get; set; }

        public Node(int iniID, string iniName, string iniNickName)
        {
            this.ID = iniID;
            this.Name = iniName;
            this.NickName = iniNickName;
        }

        public override string ToString()
        {
            return $"[ID: {ID}, Name: {Name}, NickName: {NickName}]";
        }
    }

    class DoubleLinkedList
    {
        public Node Head { get; }

        public DoubleLinkedList()
        {
            this.Head = new Node(1, "", "");
        }

        //删除节点
        public void Delete(int ID)
        {
            if (Head.Next == null)
            {
                Console.WriteLine("链表为空");
                return;
            }

            var temp = Head.Next;
            var flag = false;

            while (true)
            {
                if (temp == null)
                {
                    break;
                }
                if (temp.ID == ID)
                {
                    flag = true;
                    break;
                }
                temp = temp.Next;
            }

            if (flag)
            {
                temp.Pre.Next = temp.Next;

                if (temp.Next != null)
                {
                    //这里有风险，如果删除的节点是最后一个，会出问题，如果是最后一个节点，不需要执行下面的语句
                    temp.Next.Pre = temp.Pre;
                }
            }
            else
            {
                Console.WriteLine("未找到");
            }
        }

        //修改节点内容，与单链表一样
        public void Update(Node newNode)
        {
            if (Head.Next == null)
            {
                Console.WriteLine("链表为空");
                return;
            }

            var temp = Head.Next;
            bool flag = false;
            while (true)
            {
                if (temp == null)
                {
                    break;
                }
                if (temp.ID == newNode.ID)
                {
                    flag = true;
                    break;
                }
                temp = temp.Next;
            }
            if (flag)
            {
                temp.Name = newNode.Name;
                temp.NickName = newNode.NickName;
            }
            else
            {
                Console.WriteLine("未找到对应节点");
            }
        }

        //添加节点到双向链表的最后
        public void Add(Node NewNode)
        {
            Node temp = Head;
            while (true)
            {
                if (temp.Next == null)
                {
                    break;
                }
                temp = temp.Next;
            }
            //构成双向链表
            temp.Next = NewNode;
            NewNode.Pre = temp;
        }

        //根据ID大小插入
        public void InsertByOrder(Node newNode)
        {
            Node temp = Head;
            bool flag = false;
            while (true)
            {
                if (temp.Next == null)
                {
                    break;
                }
                if (temp.Next.ID > newNode.ID)
                {
                    break;
                }
                else if (temp.Next.ID == newNode.ID)
                {
                    flag = true;
                    break;
                }
                temp = temp.Next;
            }
            if (flag)
            {
                Console.WriteLine("当前ID已存在");
            }
            else
            {
                if (temp.Next != null)
                {
                    temp.Next.Pre = newNode;
                }
                newNode.Next = temp.Next;
                newNode.Pre = temp;
                temp.Next = newNode;
            }
        }

        //遍历双向链表
        public void Display()
        {
            if (Head.Next == null)
            {
                Console.WriteLine("链表为空");
                return;
            }

            Node temp = Head.Next;
            while (true)
            {
                if (temp == null)
                {
                    break;
                }
                Console.WriteLine(temp.ToString());
                temp = temp.Next;
            }
        }


    }


}
Roy Summy
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构-C】双向循环链表基本操作及图解分析
qq_52763385的博客
02-04 4385
目录 ????双向链表介绍 ????双向链表的基本操作及图解分析 ????1.双向链表创建新的结点 ????2.双向链表初始化 ????3.双向链表的尾插 ????4.双向链表的头插 ????5.双向链表的头删 ????6.双向链表的尾删 ????7.查找某个结点并返回该节点地址 ????8.在某结点前插入一个新的结点 ????9.删除某个结点 ????10.销毁双向链表 总结 ????双向链表介绍 双向链表的结点：指针域1+数据域+指针域2 ????指针域1：指向该结点
C# 单链表 | 双链表 | 循环链表的原理和代码实现
Liyager的博客
02-04 1839
C#用代码实现一个单向链表，纯手搓。
C#单向链表和双向链表(1)
ylq1045的专栏
02-10 672
C#中 类 System.Collections.Generic.LinkedList<T> 代表双向链表，默认并没有定义单向链表。当然：双向链表可以实现单向链表的所有功能。 双向链表LinkedList<T>的C#源代码地址： https://referencesource.microsoft.com/#System/compmod/system/collections/generic/linkedlist.cs,baf7f8812f420a83 单向链表SingleLink
图解双向链表(含完整C代码)+剖析STL顺序容器List(C++)
weixin_54186646的博客
03-19 3740
双向链表动图解析，对比双向链表在STL中的操作，内含完整代码
C#双向链表LinkedList排序实现方法
09-03
在C#编程语言中，双向链表（LinkedList）是一种数据结构，它允许在列表的任一侧进行插入和删除操作，而不像数组那样需要移动大量元素。LinkedList类是.NET框架提供的，它包含两个指针：一个指向前一个节点，另一个...
C#实现双向链表C#，.net 链表 双向链表
06-02
实现双向链表，符合双向链表的思路且易懂，拓展方便。
c#版的双向链表实现
09-17
总结，C#版的双向链表实现涉及到泛型、接口和类设计等多个核心编程概念。通过这些工具，我们可以创建一个灵活、高效且可复用的数据结构，以满足各种程序需求。在实际开发中，理解和掌握这些概念对于提升代码质量至关...
C#，双向链表（Doubly Linked List）归并排序（Merge Sort）算法与源代码
最新发布
03-24
C#，双向链表（Doubly Linked List）归并排序（Merge Sort）算法与源代码 1 双向链表 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一...
C# 数据结构与算法 -双向链表
CAI____NIAO的博客
04-17 293
interface IlistDS<T> { int GetLength(); void Clear(); bool IsEmpty(); void Add(T item); void Insert(T item, int index); T Delete(int index); T this[int index] { get; } T GetEle(i...
C++实现双向链表（完整代码）
05-10
使用面向对象实现的双向链表，适合初学者的学习与借鉴。（完整代码已测试）
【 C# 】（一） --------- 泛型带头节点的单链表，双向链表实现
爱喝柠檬的二哈的博客
09-24 612
在编程领域，数据结构与算法向来都是提升编程能力的重点。而一般常见的数据结构是链表，栈，队列，树等。事实上C#也已经封装好了这些数据结构，在头文件 System.Collections.Generic 中，直接创建并调用其成员方法就行。不过我们学习当然要知其然，亦知其所以然。 本文实现的是链表中的单链表和双向链表，并且实现了一些基本方法 一. 定义一个链表接口 MyList 接口里声明了...
数据结构1.2.1 - 双链表完整代码
qq_1403034144的博客
05-02 242
#include<bits/stdc++.h> #define num 100 using namespace std; typedef struct DLNode { int data; struct DLNode *prior; struct DLNode *next; }*DLink,DLNode; void init(DLink &L) //初始化 ,有头结点...
数据结构——双向循环链表（二）双向动态链表
chenchen_fcj程序猿的博客
07-24 393
双向动态链表才是关键，直接看例子和图示既就可以，主要是自己会画图，然后根据图来写代码 dlist.h  //头文件 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct _node {         int data;         struct  _node* next;         struct  _nod...
双向循环链表的实现详解
旧时佑忆的空间
05-09 2403
双向循环链表直接体现为 双向和循环，一般的单链表只有节点数据data和next指向地址(应该也是引用的意思)，而在此需要增加前面部分的pre指向地址，同时还需要循环 循环则在定义节点时可以解决，如下所示 即假想只有一个节点的时候，不论是上一个节点的指向还是下一个节点的指向都是自己。 双向可以假想三个节点，实际上就是3个节点之间完成pre和next的指向替换，如下图所示 ...
循环双向链表的创建方法 最简单的循环双向链表
Code Art
06-06 4634
首先讲循环链表，简单来说就是让链表首尾相连，形成一个环，因为一般的链表都是单向的，任意给出的一个节点是不能访问前面的链节，这就导致了单向链表的局限性，循环链表从一定程度上来说就解决了这一问题，通过表头指针的移动，因为环的特性，可以访问完整个链表； 但是我们不禁会想，如果只是为了访问已知链节的前一个节点，通过循环虽然达到了访问的目的，但是走遍整个链表岂不是太花费时间了么，就好比北京——天津——上海
双向链表的代码实现
qq_42557052的博客
11-14 691
#include <corecrt_malloc.h> constexpr auto OK = 1; constexpr auto Error = 0; constexpr auto True = 1; constexpr auto False = 0; typedef int Status; typedef int ElemType; //定义双链表结构体 typedef stru...
双向链表代码实现
weixin_44001521的博客
12-26 246
#include<iostream> using namespace std; typedef int ElementType;//定义类型 typedef struct DuLNode { ElementType data; struct DuLNode * prior;//前继 struct DuLNode * next;//后继 }DuLNode,* DuLinkLi...
C#实现队列及环形队列(数组)
RoySummy的博客
09-04 2769
队列(Queue) 介绍 队列是一种有序列表，只允许对队尾(rear)进行删除操作，对队首(front)进行删除操作，即先入先出(FIFO)。 实现队列需要的内部元素 元素 含义 maxSize 代表能够存储的数据的个数 front 指向队首 rear 指向队尾 array[] 用于存储数据 void Enqueue(int n) 将元素n入队 int Dequeue() 将队尾元素出队，同时元素个数-1 int Peek() 返回队尾元素，元素个数不变 bool
CShap 双向链表 源代码
04-01
以下是C#双向链表的源代码示例： ``` using System; class Node { public int data; public Node next; public Node prev; public Node(int d) { data = d; next = null; prev = null; } } class DoublyLinkedList { private Node head; public DoublyLinkedList() { head = null; } public void Add(int d) { Node newNode = new Node(d); if (head == null) { head = newNode; return; } Node current = head; while (current.next != null) { current = current.next; } current.next = newNode; newNode.prev = current; } public void Remove(int d) { if (head == null) { return; } Node current = head; while (current != null) { if (current.data == d) { if (current.prev != null) { current.prev.next = current.next; } else { head = current.next; } if (current.next != null) { current.next.prev = current.prev; } return; } current = current.next; } } public void Print() { Node current = head; while (current != null) { Console.Write(current.data + " "); current = current.next; } Console.WriteLine(); } } class Program { static void Main(string[] args) { DoublyLinkedList list = new DoublyLinkedList(); list.Add(1); list.Add(2); list.Add(3); list.Add(4); list.Add(5); list.Print(); list.Remove(3); list.Print(); } } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值