C# 线性表之单链表

最新推荐文章于 2018-07-13 15:29:06 发布
最新推荐文章于 2018-07-13 15:29:06 发布
阅读量612 收藏 3
点赞数
分类专栏： C# 数据结构与算法 文章标签： 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jason_520/article/details/59092408
版权

数据类：

namespace 单链表
{
    /// <summary>
    /// 结点
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Node<T>
    {
        private T data; //数据域
        private Node<T> next; //引用域（指针域）

        public Node(T val, Node<T> p)
        {
            data = val;
            next = p;
        }

        public Node(Node<T> p)
        {
            next = p;
        }

        public Node(T val)
        {
            data = val;
        }

        public Node()
        {
            data = default(T);
            next = null;
        }

        public T Data
        {
            get { return data; }
            set { data = value; }
        }

        public Node<T> Next
        {
            get { return next; }
            set { next = value; }
        } 
    }
}

单链表具体实现代码：

using System;
using 线性表;

namespace 单链表
{
    public class LinkList<T>:IListDS<T>
    {
        private Node<T> head;

        public Node<T> Head
        {
            get { return head; }
            set { head = value; }
        }

        public LinkList()
        {
            head = null;
        } 

        public int GetLength()
        {
            Node<T> p = head;

            int _len = 0;
            while (p!=null)
            {
                _len++;
                p = p.Next;
            }

            return _len;
        }

        public void Clear()
        {
            head = null;
        }

        public bool IsEmpty()
        {
            bool _isEmpty = head == null ? true : false;
            return _isEmpty;
        }

        public bool IsFull()
        {
            return false;
        }

        public void Append(T item)
        {
            Node<T> q = new Node<T>(item);
            Node<T> p = new Node<T>();

            if (head == null)
            {
                head = q;
                return;
            }

            p = head;
            while (p.Next!=null)
            {
                p = p.Next;
            }
            p.Next = q;
        }

        /// <summary>
        /// 在单链表前插入
        /// </summary>
        /// <param name="item"></param>
        /// <param name="index"></param>
        public void Insert(T item, int index)
        {
            if (IsEmpty() || index < 0 || index >= GetLength())
            {
                Console.WriteLine("List is empty or Position is error!");
                return;
            }

            Node<T> p = head;
            Node<T> r = new Node<T>();
            int j = 0;

            if (index == 0)
            {
                Node<T> q = new Node<T>(item);
                q.Next = p;
                head = q;
                return;
            }

            while (p.Next != null && j < index)
            {
                r = p;
                p = p.Next;
                j++;
            }
            if (j == index)
            {
                Node<T> q = new Node<T>(item);
                q.Next = p;
                r.Next = q;
            }
        }
        /// <summary>
        /// 后插入
        /// </summary>
        /// <param name="item"></param>
        /// <param name="index"></param>
        public void InsertPost(T item, int index)
        {
            if (IsEmpty() || index < 0 || index >= GetLength())
            {
                Console.WriteLine("List is empty or Position is error!");
                return;
            }

            Node<T> p = head;
            int j = 0;

            while (p.Next != null && j < index)
            {
                p = p.Next;
                j++;
            }
            if (j == index)
            {
                Node<T> q = new Node<T>(item);
                q.Next = p.Next;
                p.Next = q;
            }
        }

        public T Delete(int index)
        {
            if (IsEmpty() || index < 0 || index >= GetLength())
            {
                Console.WriteLine("List is empty or Position is error!");
                return default(T);
            }

            Node<T> q = new Node<T>();
            Node<T> p = head;
            int j = 0;

            if (index == 0)
            {
                q = head;
                head = head.Next;
                return q.Data;
            }

            while (p.Next != null && j < index)
            {
                q = p;
                p = p.Next;
                j++;
            }
            if (j == index)
            {
                q.Next = p.Next;
                return p.Data;
            }

            return default(T);
        }

        public T GetElem(int index)
        {
            Node<T> p = new Node<T>();
            p = head;
            int j = 0;

            while (p.Next != null && j < index)
            {
                p = p.Next;
                j++;
            }
            if (j == index)
                return p.Data;

            return default(T);
        }

        public int Locate(T value)
        {
            Node<T> p = new Node<T>();
            p = head;
            int j = 0;

            if (p.Data.Equals(value)) //要查找的值在索引0，
                return j;

            while (p.Next != null)
            {
                p = p.Next;
                j++;

                if (p.Data.Equals(value))
                    return j;
            }
            Console.WriteLine("Position is error!");
            return j;
        }

        public void Reverse()
        {
            Node<T> p = head;
            Node<T> q = new Node<T>();
            head = null;
            while (p != null)
            {
                q = p;
                p = p.Next;
                q.Next = head;
                head = q;
                Console.WriteLine(head.Data);
            }
        }
    }
}

测试代码：

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

namespace 单链表
{
    class LinkListOperator
    {
        static void Main(string[] args)
        {
            LinkList<int> linkLists = new LinkList<int>();
            linkLists.Append(1);
            linkLists.Append(2);
            linkLists.Append(3);
            linkLists.Append(4);

            for (int i = 0; i < linkLists.GetLength(); i++)
            {
                Console.WriteLine(linkLists.GetElem(i));
            }

            Console.WriteLine("===== Insert =====");
            linkLists.Insert(888, 3);

            for (int i = 0; i < linkLists.GetLength(); i++)
            {
                Console.WriteLine(linkLists.GetElem(i));
            }

            Console.WriteLine("===== InsertPost =====");
            linkLists.InsertPost(777, linkLists.GetLength() - 1);

            for (int i = 0; i < linkLists.GetLength(); i++)
            {
                Console.WriteLine(linkLists.GetElem(i));
            }

            Console.WriteLine("===== Delete =====");
            linkLists.Delete(0);

            for (int i = 0; i < linkLists.GetLength(); i++)
            {
                Console.WriteLine(linkLists.GetElem(i));
            }

            Console.WriteLine("===== Locate =====");
            Console.WriteLine(linkLists.Locate(888));


            //Console.WriteLine("===== CreateListHead 输入要添加的值 =====");
            //LinkList<int> L = CreateListHead();
            //for (int i = 0; i < L.GetLength(); i++)
            //{
            //    Console.WriteLine(L.GetElem(i));
            //}



            //Console.WriteLine("===== CreateListTail 输入要添加的值 =====");
            //LinkList<int> L1 = CreateListTail();
            //for (int i = 0; i < L1.GetLength(); i++)
            //{
            //    Console.WriteLine(L1.GetElem(i));
            //}

            //Console.WriteLine("===== Reverse  =====");
            //L1.Reverse();
            //for (int i = 0; i < L1.GetLength(); i++)
            //{
            //    Console.WriteLine(L1.GetElem(i));
            //}
            //Console.WriteLine("===== Merge  =====");
            //LinkList<int>ha=new LinkList<int>();
            //LinkList<int>hb=new LinkList<int>();
            //ha.Append(1);
            //ha.Append(3);
            //ha.Append(5);
            //ha.Append(7);
            //hb.Append(2);
            //hb.Append(4);
            //hb.Append(8);
            //hb.Append(9);

            //LinkList<int> hc = Merge(ha, hb);
            //for (int i = 0; i < hc.GetLength(); i++)
            //{
            //    Console.WriteLine(hc.GetElem(i));
            //}
            Console.WriteLine("===== Purge  =====");
            LinkList<int> ha = new LinkList<int>();
            ha.Append(1);
            ha.Append(3);
            ha.Append(3);
            ha.Append(5);
            ha.Append(5);
            ha.Append(7);
            ha.Append(7);
            ha.Append(89);
            LinkList<int> hb = Purge(ha);
            for (int i = 0; i < hb.GetLength(); i++)
            {
                Console.WriteLine(hb.GetElem(i));
            }


            Console.ReadKey();
        }

        /// <summary>
        /// 在头部插入结点建立单链表的算法
        /// </summary>
        /// <returns></returns>
        static LinkList<int> CreateListHead()
        {
            int d;
            LinkList<int> L = new LinkList<int>();

            d = Int32.Parse(Console.ReadLine());

            while (d != -1)
            {
                Node<int> q = new Node<int>(d);
                q.Next = L.Head;
                L.Head = q;
                d = Int32.Parse(Console.ReadLine());
            }

            return L;
        }

        /// <summary>
        /// 在尾部插入结点建立单链表的算法
        /// </summary>
        /// <returns></returns>
        static LinkList<int> CreateListTail()
        {
            int d;
            LinkList<int> L = new LinkList<int>();

            d = Int32.Parse(Console.ReadLine());
            Node<int> R = new Node<int>();
            R = L.Head;

            while (d != -1)
            {
                Node<int> q = new Node<int>(d);
                if (L.Head == null)
                    L.Head = q;
                else
                    R.Next = q;

                R = q;
                d = Int32.Parse(Console.ReadLine());
            }

            if (R != null)
                R.Next = null;

            return L;
        }

        /// <summary>
        /// 合并已经排序的单链表，并且再进行排序
        /// </summary>
        /// <param name="Ha"></param>
        /// <param name="Hb"></param>
        /// <returns></returns>
        static LinkList<int> Merge(LinkList<int> Ha, LinkList<int> Hb)
        {
            LinkList<int> Hc = new LinkList<int>();
            Node<int> p = Ha.Head.Next;
            Node<int> q = Hb.Head;
            Node<int> s = new Node<int>();

            Hc = Ha;
            Hc.Head.Next = null; //Hc为1

            while (p != null && q != null)
            {
                if (p.Data < q.Data)
                {
                    s = p;
                    p = p.Next;
                }
                else
                {
                    s = q;
                    q = q.Next;
                }
                Hc.Append(s.Data);
            }
            if (p == null)
            {
                p = q;
            } while (p != null)
            {
                s = p;
                p = p.Next;
                Hc.Append(s.Data);
            }
            return Hc;
        }
        static LinkList<int> Merge1(LinkList<int> Ha, LinkList<int> Hb)
        {
            LinkList<int> Hc = new LinkList<int>();
            Node<int> p = Ha.Head.Next;
            Node<int> q = Hb.Head;
            Node<int> s = new Node<int>();

            Hc = Ha;
            Hc.Head.Next = null; //Hc为1

            while (p != null && q != null)
            {
                if (p.Data < q.Data)
                {
                    s = p;
                    p = p.Next;
                }
                else
                {
                    s = q;
                    q = q.Next;
                }
                s.Next = Hc.Head.Next;
                Hc.Head.Next = s;
            }
            if (p == null)
            {
                p = q;
            } while (p != null)
            {
                s = p;
                p = p.Next;
                s.Next = Hc.Head.Next;
                Hc.Head.Next = s;
            }
            return Hc;
        }

        static LinkList<int> Purge(LinkList<int> ha)
        {
            for (int i = 0; i < ha.GetLength(); i++)
            {
                Console.WriteLine(ha.GetElem(i));
            }
            LinkList<int> Hb = new LinkList<int>();
            Node<int> p = ha.Head;
            Node<int> q = new Node<int>();
            Node<int> s = new Node<int>();
            s = p;
            p = p.Next;
            s.Next = null;
            Hb.Head = s;
            Console.WriteLine(ha.Head.Next);
            Hb.Head.Next = ha.Head.Next;
            while (p.Next != null)
            {
                s = p;
                p = p.Next;
                q = Hb.Head.Next;
                while (q.Next != null && q.Data != s.Data)
                {
                    q = q.Next;
                }
                if (q == null)
                {
                    s.Next = Hb.Head.Next;
                    Hb.Head.Next = s;
                }
            }

            return Hb;
        }
    }
}
阿童木yss
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 数据结构- 线性表的几种实现
路漫漫其修远兮
05-31 2338
什么是线性表 线性表是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即： （ 1）除第一个位置的数据元素外，其它数据元素位置的前面都只有一个数据元素； （ 2）除最后一个位置的数据元素外，其它数据元素位置的后面都只有一个元素。也就是说，数据元素是一个接一个的排列。...
C#实现线性链表（单链表）
qq_34639650的博客
06-26 358
单链表：用任意的存储单元存储线性表的数据元素； 优点：插入删除效率高 缺点：查询效率低，需要遍历链表 1.接口类： /// <summary> /// 该类为链表接口定义类，顺序链表和单链表都使用该接口 /// </summary> /// <typeparam name="T"></typeparam> interface IListDS<T> { /// <summary>
线性表的链式存储设计与实现(C语言版本)
小强博客
05-16 568
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct PStudent { int sid; char name[100]; char sex; }*Student,STU;//Student===&gt; struct PStudent* STU等价于struct PStudent void main(...
基本数据结构（C#实现）：单链表
lzuwds的专栏
04-23 797
线性表的链式存储结构：n个结点链接成一个链表，每个结点由两部分构成：数据元素本身信息和其直接后 继元素的存储位置。单链表：一个SingleLinkList类，里面封装所有关于链表的基本操作（方法）和头结点属性；一个LinkNode 类封装了value属性和指向其直接后继元素的（指针）信息。代码实现：单链表类class LinkList { pr
c#数据结构（2.1线性表， 顺序表，单链表，其它链表）
qq_40138785的博客
07-13 371
一，线性表     线性表是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即：（1）除第一个位置的数据元素外，其它数据元素位置的前面都只有一个数据元素；（2）除最后一个位置的数据元素外，其它数据元素位置的后面都只有一个元素。也就是说，数据元素是一个接一个的排列。因...
线性表之单链表
无他,唯手熟尔!
04-06 967
在链表存储结构中,每个节点用于存储线性表的一个元素,每个节点不仅包含有所存元素本身的信息(数据域),还包含元素之间逻辑关系的信息,即前驱节点包含后继节点的地址信息,称为指针域,这样可以比较方便的查找后继节点的位置.我们再次讨论的单链表为了方便链表的操作,都是默认带头结点的.只要我们拿到了头结点我们就等于拿到了整个链表的节点 一,基本操作 1,头插法建立单链表    这样得到的链表节点顺序和插入
C#实现单链表(线性表)完整实例
09-02
单链表是线性表的一种实现方式，其中每个元素（称为节点）包含数据部分和一个指向下一个元素的引用（称为指针或链接）。C# 是一种广泛使用的编程语言，它支持面向对象的编程，因此非常适合实现这样的数据结构。 ...
C#(数据结构与教程）单链表的实例应用程序
01-19
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
数据结构 C#实现 各种算法 线性表，树，单链表
12-02
使用C#语言实现单链表、双链表等不同类型的线性表，并探讨它们的应用场景。 - **栈和队列**：深入讲解栈和队列这两种特殊的线性表，包括它们的特点、操作方式及应用场景。例如，栈可以用于实现递归调用，队列则常...
01-绪论和线性表1
08-04
4. C/C++ 自定义线性表和链表：程序员可以自定义线性表结构，如单链表、双链表等，实现动态内存管理和元素操作。 选择哪种实现取决于具体需求，如是否需要快速随机访问，以及插入和删除的频率。 线性表在多种算法...
C# 二进制读写与序列化和反序列化
阿童木的博客
01-15 4064
可参考雨松大神：http://www.xuanyusong.com/archives/1919 http://www.xuanyusong.com/archives/1901文章将实现数据存储为二进制文件，然后通过二进制文件解析数据。二进制文件读写操作： //写入二进制文件 public static void WriteByteValues() {
C# 斐波那契数列
阿童木的博客
01-19 2581
斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F(0)=1，F(1)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*）。1. static int Func(int n) { if (n <=
C# 枚举类型的扩展
阿童木的博客
01-12 2365
随机获得一个枚举public static T RandomEnum<T>() { T[] results = Enum.GetValues(typeof(T)) as T[]; Random random = new Random(); T result = results[random.Next(0, results.Length)];
验证一个数是否为4的n次幂
阿童木的博客
02-22 1340
将4的幂次方写成二进制形式后，很容易就会发现有一个特点：二进制中只有一个1（1在奇数位置），并且1后面跟了偶数个0； 因此问题可以转化为判断1后面是否跟了偶数个0就可以了。 4的整数次幂的二进制数都为 (4)100、(16)10000、(64)1000000…… 另外，4的幂次方4^n也可以写为2^(2*n)，即也可以写为2的幂次方，当然就满足2的幂次方的条件了，即num & num-1==0。
C# 位运算符
阿童木的博客
01-19 1295
表：位运算符 A=60,B=13； 运算符 描述 实例 $ 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 (A & B) 将得到 12，即为 0000 1100 l 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 (A l B) 将得到 61，即为 0011 1101 ^ 如果存在于其中一个操作数中但不同时存在于两个
C# 正则表达式的使用
阿童木的博客
01-19 886
参考：http://www.cnblogs.com/youring2/archive/2009/11/07/1597786.html 在原文的基础上增加一些自己的理解实例。目前为止，许多编程语言和工具都包含对正则表达式的支持，C#也不例外，C#基础类库中包含有一个命名空间（System.Text.RegularExpressions）和一系列可以充分发挥规则表达式威力的类(Regex、Match、
C# 线性表之顺序存储结构
阿童木的博客
02-16 779
前言毕业大半年了，发现自己在数据结构与算法这一块的知识不扎实，所以重新回顾一下大学学的知识并且做一些笔记。谢谢大家。举例白羊座，金牛座，双子座，巨蟹座，狮子座，处女座，天秤座，天蝎座，射手座，摩羯座，水瓶座，双鱼座，12个星座是按顺序排列的，都有自己固定的位置，除了第一个白羊座没有前驱，和最后一个双鱼座没有后驱，其他的都有前驱和后驱。定义线性表可以说是最简单的数据结构，它的描述为：n个数据元素的有限
C# Lambda表达式
阿童木的博客
01-19 508
首先先看下委托：delegate int GuangChaoshi(int a); static void Main(string[] args) { GuangChaoshi gwl = JieZhang; Console.WriteLine(gwl(10) + ""); //打印20，委托的应用 Console.ReadKey(); }public sta
C#语言版数据结构详解
单链表是另一种线性表的实现，由一系列节点组成，每个节点包含元素和指向下一个节点的引用。这部分详细介绍了单链表的定义、操作实现以及示例应用。此外，还涉及了双向链表和循环链表，这两种链表扩展了单链表的概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值