数据结构——C#实现泛型单链表

已于 2024-08-14 16:13:06 修改
阅读量190 收藏 6
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 c# 链表
于 2024-08-14 14:44:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64251659/article/details/141190110
版权

1.单链表功能速览

功能方法返回值备注
获取链表长度GetLength()int返回链表长度
清空链表Clear()void
判断链表是否为空IsEmpty()bool
添加元素Add(T item)void在链表尾添加元素
在指定位置插入元素Insert(T item,int index)void插入的元素就是第index位
删除指定位置元素Delete(int index)T
索引器this[int index]T类似数组的索引器
获取指定位置的值GetEle(int index)T以位取值
获取值所在的位置Locate(T value)int以值取位
打印输出单链表MToString()void打印链表

2.主要功能的设计简图

（1）元素的插入

（2）元素的删除

3.单链表结点类

/// <summary>
/// 单链表的结点
/// </summary>
/// <typeparam name="T"></typeparam>
class MyNode<T>
{
    T data;//数据域
    MyNode<T> next;//指针域，用来指向下一个元素
    public T Data
    {
        get { return data; }
        set { data = value; }
    }
    //MyNode的各种构造函数
    public MyNode<T> Next
    {
        get { return next; }
        set { next = value; }
    }
    public MyNode()
    {
        data = default(T);
        next = null;
    }
    public MyNode(T value)
    {
        data = value;
        next = null;
    }
    public MyNode(T value,MyNode<T> next)
    {
        data = value;
        this.next = next;
    }
    public MyNode(MyNode<T> next)
    {
        this.next = next;
    }
}

4.单链表类

/// <summary>
/// 单链表
/// </summary>
public class MyLinkList<T>
{
    private MyNode<T> head;//头结点
    int count = 0;//链表长度
    public MyLinkList()
    {
        head = null;
    }
}

5.单链表的功能实现

（1）获取链表长度

/// <summary>
/// 获取链表长度
/// </summary>
/// <returns></returns>
public int GetLength()
{
    return count;
}

（2）清空列表

/// <summary>
/// 清空列表
/// </summary>
public void Clear()
{
    head = null;
    count = 0;
}

（3）判断链表是否为空

/// <summary>
/// 判断链表是否为空
/// </summary>
/// <returns></returns>
public bool IsEmpty()
{
    return head == null;
}

（4）添加元素

/// <summary>
/// 在链表尾部插入一个结点
/// </summary>
/// <param name="item"></param>
public void Add(T item)
{
    //根据传过来的数据创建一个新的结点
    MyNode<T> newNode = new MyNode<T>(item);
    if (head == null)
    {
        head = newNode;
    }
    else
    {
        //把新结点放到链表的结尾
        MyNode<T> temp = head;
        while (temp.Next != null)
        {
            temp = temp.Next;
        }
        //新结点放到链表尾部
        temp.Next = newNode;
    }
    count++;
}

（5）在指定位置插入元素

/// <summary>
/// 在指定索引位置插入一个结点
/// </summary>
/// <param name="item">数据</param>
/// <param name="index">插入元素的索引位置/param>
public void Insert(T item,int index)
{
    if (index < 0 || index > count - 1) return;
    MyNode<T> newNode = new MyNode<T>(item);
    if (index == 0)//相当于头结点
    {
        newNode.Next = head;
        head = newNode;
    }
    else
    {
        MyNode<T> temp = head;
        //获取到需要插入结点的前一个位置
        for(int i = 1; i < index; i++)
        {
            temp = temp.Next;
        }
        MyNode<T> preNode = temp;
        MyNode<T> curNode = temp.Next;
        preNode.Next = newNode;
        newNode.Next = curNode;
    }
    count++;
}

（6）删除指定位置元素

/// <summary>
/// 删除指定索引的元素
/// </summary>
/// <param name="index">指定的索引</param>
/// <returns>被删除的数据</returns>
public T Delete(int index)
{
    T data = default(T);
    if (index < 0 || index > count - 1) return data;
    if (index == 0)//删除头结点
    {
        data = head.Data;
        head = head.Next;
    }
    else
    {
        MyNode<T> temp = head;
        //获取到需要删除结点的前一个位置
        for (int i = 1; i < index; i++)
        {
            temp = temp.Next;
        }
        MyNode<T> preNode = temp;
        MyNode<T> curNode = temp.Next;
        data = curNode.Data;
        MyNode<T> nextNode = temp.Next.Next;
        preNode.Next = nextNode;
    }
    count--;
    return data;
}

（7）索引器

/// <summary>
/// 索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T this[int index]
{
    get
    {
        MyNode<T> temp = head;
        for(int i = 1; i <= index; i++)
        {
            temp = temp.Next;
        }
        return temp.Data;
    }
}

（8）获取指定位置的值

/// <summary>
/// 获取指定索引位置的值
/// </summary>
/// <param name="index">指定的索引</param>
/// <returns></returns>
public T GetEle(int index)
{
    return this[index];
}

（9）获取值所在的位置

/// <summary>
/// 根据数据返回数据所在的索引位置
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public int Locate(T value)
{
    MyNode<T> temp = head;
    if (temp == null)
    {
        return -1;
    }
    else
    {
        int index = 0;
        while (true)
        {
            if (temp.Data.Equals(value))
            {
                return index;
            }
            else
            {
                if (temp.Next != null)
                {
                    temp = temp.Next;
                    index++;
                }
                else
                {
                    break;
                }
            }
        }
    }
    return -1;
}

（10）打印输出单链表

/// <summary>
/// 格式化打印输出单链表
/// </summary>
public void MToString()
{
    MyNode<T> temp = head;
    Console.Write("单链表输出为： ");
    while (temp.Next != null)
    {
        Console.Write(temp.Data + "->");
        temp = temp.Next;
    }
    Console.WriteLine(temp.Data + "->null");
}

6.测试单链表功能

测试代码：

static void Main(string[] args)
{
    //测试单链表
    MyLinkList<int> myLinkList = new MyLinkList<int>();
    myLinkList.Add(1);
    myLinkList.Add(2);
    myLinkList.Add(3);
    myLinkList.Add(4);
    myLinkList.Add(5);
    myLinkList.MToString();
    Console.WriteLine("单链表是否为空:" + myLinkList.IsEmpty());
    Console.WriteLine("单链表的长度为：" + myLinkList.GetLength());
    Console.WriteLine("获取索引为1的元素：" + myLinkList.GetEle(1));
    Console.WriteLine("通过索引器获取索引为2的元素：" + myLinkList[2]);
    Console.WriteLine("获取元素值为3的索引位置：" + myLinkList.Locate(3));
    myLinkList.Delete(2);
    Console.WriteLine("删除索引为2的结点 ");
    myLinkList.MToString();
    Console.WriteLine("在索引为2的位置插入一个元素100");
    myLinkList.Insert(100, 2);
    myLinkList.MToString();
    Console.WriteLine("清空列表");
    myLinkList.Clear();
    Console.WriteLine("清空列表后的列表长度" + myLinkList.GetLength());
    Console.WriteLine("单链表是否为空:" + myLinkList.IsEmpty());
    Console.ReadKey();
}

输出结果：

7.单链表完整代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 单链表
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //测试单链表
            MyLinkList<int> myLinkList = new MyLinkList<int>();
            myLinkList.Add(1);
            myLinkList.Add(2);
            myLinkList.Add(3);
            myLinkList.Add(4);
            myLinkList.Add(5);
            myLinkList.MToString();
            Console.WriteLine("单链表是否为空:" + myLinkList.IsEmpty());
            Console.WriteLine("单链表的长度为：" + myLinkList.GetLength());
            Console.WriteLine("获取索引为1的元素：" + myLinkList.GetEle(1));
            Console.WriteLine("通过索引器获取索引为2的元素：" + myLinkList[2]);
            Console.WriteLine("获取元素值为3的索引位置：" + myLinkList.Locate(3));
            myLinkList.Delete(2);
            Console.WriteLine("删除索引为2的结点 ");
            myLinkList.MToString();
            Console.WriteLine("在索引为2的位置插入一个元素100");
            myLinkList.Insert(100, 2);
            myLinkList.MToString();
            Console.WriteLine("清空列表");
            myLinkList.Clear();
            Console.WriteLine("清空列表后的列表长度" + myLinkList.GetLength());
            Console.WriteLine("单链表是否为空:" + myLinkList.IsEmpty());
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 单链表的结点
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class MyNode<T>
    {
        T data;//数据域
        MyNode<T> next;//指针域，用来指向下一个元素
        public T Data
        {
            get { return data; }
            set { data = value; }
        }
        //MyNode的各种构造函数
        public MyNode<T> Next
        {
            get { return next; }
            set { next = value; }
        }
        public MyNode()
        {
            data = default(T);
            next = null;
        }
        public MyNode(T value)
        {
            data = value;
            next = null;
        }
        public MyNode(T value,MyNode<T> next)
        {
            data = value;
            this.next = next;
        }
        public MyNode(MyNode<T> next)
        {
            this.next = next;
        }
    }
    /// <summary>
    /// 单链表
    /// </summary>
    public class MyLinkList<T>
    {
        private MyNode<T> head;//头结点
        int count = 0;//链表长度
        public MyLinkList()
        {
            head = null;
        }
        /// <summary>
        /// 获取链表长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return count;
        }
        /// <summary>
        /// 清空列表
        /// </summary>
        public void Clear()
        {
            head = null;
            count = 0;
        }
        /// <summary>
        /// 判断链表是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return head == null;
        }
        /// <summary>
        /// 在链表尾部插入一个结点
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            //根据传过来的数据创建一个新的结点
            MyNode<T> newNode = new MyNode<T>(item);
            if (head == null)
            {
                head = newNode;
            }
            else
            {
                //把新结点放到链表的结尾
                MyNode<T> temp = head;
                while (temp.Next != null)
                {
                    temp = temp.Next;
                }
                //新结点放到链表尾部
                temp.Next = newNode;
            }
            count++;
        }
        /// <summary>
        /// 在指定索引位置插入一个结点
        /// </summary>
        /// <param name="item">数据</param>
        /// <param name="index">插入元素的索引位置/param>
        public void Insert(T item, int index)
        {
            if (index < 0 || index > count - 1) return;
            MyNode<T> newNode = new MyNode<T>(item);
            if (index == 0)//相当于头结点
            {
                newNode.Next = head;
                head = newNode;
            }
            else
            {
                MyNode<T> temp = head;
                //获取到需要插入结点的前一个位置
                for(int i = 1; i < index; i++)
                {
                    temp = temp.Next;
                }
                MyNode<T> preNode = temp;
                MyNode<T> curNode = temp.Next;
                preNode.Next = newNode;
                newNode.Next = curNode;
            }
            count++;
        }
        /// <summary>
        /// 删除指定索引的元素
        /// </summary>
        /// <param name="index">指定的索引</param>
        /// <returns>被删除的数据</returns>
        public T Delete(int index)
        {
            T data = default(T);
            if (index < 0 || index > count - 1) return data;
            if (index == 0)//删除头结点
            {
                data = head.Data;
                head = head.Next;
            }
            else
            {
                MyNode<T> temp = head;
                //获取到需要删除结点的前一个位置
                for (int i = 1; i < index; i++)
                {
                    temp = temp.Next;
                }
                MyNode<T> preNode = temp;
                MyNode<T> curNode = temp.Next;
                data = curNode.Data;
                MyNode<T> nextNode = temp.Next.Next;
                preNode.Next = nextNode;
            }
            count--;
            return data;
        }
        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index]
        {
            get
            {
                MyNode<T> temp = head;
                for(int i = 1; i <= index; i++)
                {
                    temp = temp.Next;
                }
                return temp.Data;
            }
        }
        /// <summary>
        /// 获取指定索引位置的值
        /// </summary>
        /// <param name="index">指定的索引</param>
        /// <returns></returns>
        public T GetEle(int index)
        {
            return this[index];
        }
        /// <summary>
        /// 根据数据返回数据所在的索引位置
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int Locate(T value)
        {
            MyNode<T> temp = head;
            if (temp == null)
            {
                return -1;
            }
            else
            {
                int index = 0;
                while (true)
                {
                    if (temp.Data.Equals(value))
                    {
                        return index;
                    }
                    else
                    {
                        if (temp.Next != null)
                        {
                            temp = temp.Next;
                            index++;
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }
            return -1;
        }
        /// <summary>
        /// 格式化打印输出单链表
        /// </summary>
        public void MToString()
        {
            MyNode<T> temp = head;
            Console.Write("单链表输出为： ");
            while (temp.Next != null)
            {
                Console.Write(temp.Data + "->");
                temp = temp.Next;
            }
            Console.WriteLine(temp.Data + "->null");
        }
    }
}
清秋Ccc
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#_数据结构
weixin_42137574的博客
04-18 1730
为什么学习数据结构 同样的问题，有的人写出来的程序效率高，有的人却用很复杂的方法解决。 学习数据结构能用最有效的方法解决绝大多数的问题。 基本概念和术语 1、 数据(Data) 计算机程序处理各种各样的数据，可以是数值数据，如整数、实数或复数；也可以是非数值数据，如字符、文字、图形、图像、声音等。 2、 数据元素(Data Element)和数据项(Data Item) 数据元素是数据的基本单位，在计算机程序中通常被作为一个整体进行考虑和处理。一个数据元素可由若干个数据项(Data Item)组成。
【数据结构】C#代码实现【顺序表】和【链表】
weixin_48343145的博客
04-24 2560
第一、创建一个接口 为了统一顺序表和链表的方法命名，先创建一个接口，里面定义了一般线性表所有方法的名称。 定义接口的原因：1.外部对不论顺序表还是链表的操作是一样的；2.但是顺序表和链表的具体方法实现不一样 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace case1 {//这是一个接口，头字母用I
C#——实现泛型顺序栈和链栈
Jeff的博客
09-11 450
使用C#进行了泛型栈的实现，内部以List&amp;amp;lt;&amp;amp;gt;作为储存器； class CStack&amp;amp;lt;T&amp;amp;gt; { int p_Index; List&amp;amp;lt;T&amp;amp;gt; list; //构造方法 public CStack() { list
C#——实现泛型顺序队列和链式队列
Jeff的博客
09-13 1210
顺序队列，使用List为存储器 /// 顺序队列 class MyQueue&amp;lt;T&amp;gt; { List&amp;lt;T&amp;gt; list; public MyQueue() { list = new List&amp;lt;T&amp;gt;(); } //入队 public...
c#数据结构——顺序表
miku_weilai的博客
12-06 363
简单的说明  首先，这是本人第一次在网上写文章，主要的目的是记录一下学习的进度，(⊙v⊙)，就当着从零的开始的数据结构，语言是用c#，但数据结构是通用的。  数据结构是干什么？数据结构是数据的集合，就像人身体的细胞一样，细胞集合在一起构成组织，数据结构就是描述数据之间的关系。  我们通常把数据结构分为 4种基本类型：  （1） 集合 （2）线性结构 （3）树状结构 （4）图状结构
C#数据结构与算法
qq_41603955的博客
03-15 7542
一、数据结构介绍 为什么学习数据结构？ 对于同样的问题，有的人写出来的程序效率高，而有的人却用很复杂的方法解决。 学习数据结构的目的是：能用最有效的方法解决绝大多数的问题。 学习数据结构的三个目的： 1.讲授常用的数据结构 这些数据结构形成了程序员基本数据结构工具箱(toolkit)。对于许多常见的问题，工具箱里的数据结构是理想的选择。就像.NET Framework 中 Windows 应用程序开发中的工具箱，程序员可以直接拿来或经过少许的修改就可以使用，非常方便。 2.讲授常用的算法 它和
Unity_C#数据结构之单向链表
qq_51147038的博客
02-19 713
说起数据结构想必大家都已经耳熟能详了吧，无论是最基础的“数组”，还是“列表”以及“字典”，它们都是数据结构，而我今天要说的“链表”也是一种数据结构。 什么是链表？ 简单来说就是多个数据每两两之间就会通过一根“链条”连接，这就是链表，就跟自行车的那根铁链条一样。 什么是单向链表？什么是双向链表？什么又是循环链表？ 这个也很容易理解，拿交通来说，单行道就是单向链表；双行道是双向链表；至于循环链表可能就是那种大转盘小转盘吧。 ——单向链表可以通过一个数据找到下一个数据，再通过下一个数据找到下下个数..
C#——数据结构(一)数组、集合
Jeff的博客
09-01 723
1.Array数组 数组可以直接通过下标访问。 array[i] 常规操作： 分配存储空间。 如：声明一个数组 int[] array = new int[5]; 访问数组中的元素数据。 通过下标来获取。 int[ ] array = new int [5] {1,2,3,4,5}; int[ , ] secDimeArray = new int[2,3]; int[ ] ...
Unity游戏开发客户端面经——数据结构（初级）
Sea3752的博客
10-25 8687
Unity游戏开发客户端面经 之 数据结构篇
C#实现泛型List分组输出元素的方法
08-28
同时，本文也对C#相关内容进行了总结，包括C#常见控件用法教程、WinForm控件用法总结、C#数据结构与算法教程、C#面向对象程序设计入门教程及C#程序设计之线程使用技巧总结等，希望能够对大家C#程序设计有所帮助。
《数据结构——C++实现》（第二版）课本源代码
10-30
C++是一种强大的面向对象编程语言，它允许程序员直接控制硬件资源，因此在实现数据结构时可以实现高效且灵活的设计。在C++中，我们可以使用类来封装数据结构的实现，利用模板来实现泛型编程，提高代码的重用性。 ...
C#数据结构之单链表(LinkList)实例详解
09-03
单链表（LinkList）是计算机科学中一种基础的数据结构，尤其在编程语言如C#中，它提供了灵活且高效的方式来存储和操作序列数据。单链表的主要特点是每个节点包含两个部分：数据部分（data）和一个指向下一个节点的...
c#自定义泛型类的实现
09-05
在C#编程语言中，自定义泛型类是一种强大的工具，它允许我们创建可以处理多种数据类型的类。泛型提供了一种方式，让我们能够在编写代码时推迟对具体数据类型的决定，直到实例化类或者调用方法时。这提高了代码的重用...
数据结构 堆的实现（泛型）
08-23
数据结构 堆的泛型实现，可以支持对的各种操作（包括建堆，弹出，插入，取顶，删除堆中的某一个元素）等等，同时可以传入函数对象定义大顶/小顶堆（默认小顶），使用更灵活！
【数据结构-前缀哈希】力扣1124. 表现良好的最长时间段
最新发布
sjsjs11的博客
08-14 201
表现良好的时间段”有两种情况，一种是当前的sum能在哈希表中匹配到sum - 1时（如果是匹配sum的话，这个子段是「劳累的天数」等于「不劳累的天数」。这一题前缀+哈希并不是空间最优，最优空间是使用贪心+栈的做法，虽然空间复杂度都是O(n)，但是实际的空间使用可能高于 O(n)，因为当哈希表需要扩展时，会预留更多的空间以减少哈希冲突。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。输入：hours = [9,9,6,0,6,6,9]
C语言实现排序之快速排序算法
2403_83044722的博客
08-14 289
快速排序（Quick Sort）是一种非常高效且实用的排序算法，它采用分治法（Divide and Conquer）的思想来完成排序。
常见8种数据结构
qq_43575301的博客
08-08 2162
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
数据结构（学习）2024.8.9（双向链表）
何物爱惜雨的博客
08-09 636
双向链表的创建，插入，遍历，删除
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值