C#实现的简单链表类实例

本文实例讲述了C#实现的简单链表类。分享给大家供大家参考。具体如下:

一、关于C#链表

C#链表可用类LinkedList来存放。本文中的类MyLinkedList只是实现了该类的最基本的功能。C#中没有指针,但因为C#中类在赋值时传递的是地址,因此仍然可以利用这点制作一个链表。

二、结点类Node和链表类MyLinkedList代码

/// <summary>
/// 链表结点
/// </summary>
class Node
{
  //结点数据,前后结点
  public object Data;
  public Node PreviousNode;
  public Node NextNode;
  //构造函数
  public Node(object data = null)
  {
    Data = data;
    PreviousNode = null;
    NextNode = null;
  }
  //输出结点信息
  public override string ToString()
  {
    return Data.ToString();
  }
}
/// <summary>
/// 链表类
/// </summary>
class MyLinkedList
{
  //首结点、尾结点
  public Node First;
  public Node Last;
  //下一个结点、上一个结点
  public Node NextNode(Node n) { return n.NextNode; }
  public Node PreviousNode(Node n) { return n.PreviousNode; }
  //结点总数
  public int Count;
  //构造函数
  public MyLinkedList()
  {
    this.First = null;
    this.Last = null;
    Count = 0;
  }
  /// <summary>
  /// 在结点node1之后增加结点node2,如果没有该结点则在最后增加
  /// </summary>
  /// <param name="node1">结点1</param>
  /// <param name="node2">结点2</param>
  public void AddAfter(Node node1, Node node2)
  {
    //链表为空的情况
    if (First == null)
    {
      Console.WriteLine("Linked-list is null! Can not find node1(" + node1 + ")");
      return;
    }
    Node temp = First;
    do
    {
      if (temp.Data.Equals(node1.Data))
      {
        //如果node1是尾结点
        if (node1.NextNode == null)
        {
          node2.NextNode = null;
          node2.PreviousNode = node1;
          node1.NextNode = node2;
        }
        else //如果node1不是尾结点
        {
          node2.NextNode = node1.NextNode;
          node2.PreviousNode = node1;
          node2.NextNode.PreviousNode = node2;
          node1.NextNode = node2; ;
        }
        Count++;
        Console.WriteLine("Node(" + node2 + "): Add Complete!");
        return;
      }
      temp = temp.NextNode;
    }
    while (temp != null);
    Console.WriteLine("Can not find node(" + node1 + "), Misson defeat");
  }
  /// <summary>
  /// 在链表尾部增加结点
  /// </summary>
  public void AddLast(Node node)
  {
    //链表为空的情况
    if (this.First == null)
    {
      node.NextNode = null;
      node.PreviousNode = null;
      this.First = node;
      this.Last = node;
    }
    else //链表不为空的情况
    {
      Node temp = First;
      while(temp.NextNode != null)
      {
        temp = temp.NextNode;
      }
      temp.NextNode = node;
      node.PreviousNode = temp;
      Last = node;
    }
    Count++;
    Console.WriteLine("Node(" + node + "): Add Complete!");
  }
  /// <summary>
  /// 删除指定结点
  /// </summary>
  /// <param name="node">被删除结点</param>
  public void Delete(Node node)
  {
    if (Count == 0)
    {
      Console.WriteLine("Can not find node(" + node + ")");
      return;
    }
    Node temp = First;
    do
    {
      //如果数据部分匹配,则删去该结点
      if (temp.Data.Equals(node.Data))
      {
        //temp是尾结点
        if (temp.NextNode == null)
        {
          temp.PreviousNode.NextNode = null;
          temp = null;
        }
        else //temp不是尾结点
        {
          temp.PreviousNode.NextNode = temp.NextNode;
          temp.NextNode.PreviousNode = temp.PreviousNode;
          temp = null;
        }
        Count--;
        Console.WriteLine("Node(" + node + "): Delete Complete!");
        return;
      }
      temp = temp.NextNode;
    }
    while (temp != null);
    Console.WriteLine("Can not find node(" + node + "), Misson defeat");
  }
  /// <summary>
  /// 修改结点值
  /// </summary>
  /// <param name="node">被修改结点</param>
  /// <param name="value">结点值</param>
  public void Modify(Node node, object value)
  {
    if (Count == 0)
    {
      Console.WriteLine("Can not find node(" + node + ")");
      return;
    }
    Node temp = First;
    do
    {
      if (temp.Data.Equals(node.Data))
      {
        Console.WriteLine("Node: " + temp.Data + " → " + value.ToString());
        temp.Data = value;
        return;
      }
      temp = temp.NextNode;
    }
    while (temp != null);
  }
  /// <summary>
  /// 打印链表
  /// </summary>
  public void Print()
  {
    if (First == null)
    {
      Console.WriteLine("No nodes in this linked-list.");
      return;
    }
    else
    {
      Console.WriteLine("Print the linked-list...");
      Node temp = First;
      do
      {
        Console.WriteLine(temp.ToString());
        temp = temp.NextNode;
      }
      while (temp != null);
      Console.WriteLine("Mission Complete!");
    }
  }
}

三、Main函数的调用示例

static void Main(string[] args)
{
  MyLinkedList ll = new MyLinkedList();
  //添加三个结点 1 2(在1后) 3(在2后)
  Node n1 = new Node("node1");
  Node n2 = new Node("node2");
  Node n3 = new Node("node3");
  ll.AddLast(n1);
  ll.AddLast(n2);
  ll.AddLast(n3);
  //添加三个结点 1.5(在1后) 2.5(在2后) 3.5(在3后)
  Node n1dot5 = new Node("node1dot5");
  Node n2dot5 = new Node("node2dot5");
  Node n3dot5 = new Node("node3dot5");
  ll.AddAfter(n1, n1dot5);
  ll.AddAfter(n2, n2dot5);
  ll.AddAfter(n3, n3dot5);
  Console.WriteLine("========================");
  //打印链表
  ll.Print();
  Console.WriteLine("========================");
  //删除结点 2 和 3,将结点 2.5 的值改为 "ThisNodeIsModified!"
  ll.Delete(n2);
  ll.Delete(n3);
  ll.Modify(n2dot5, "ThisNodeIsModified!");
  Console.WriteLine("========================");
  //打印链表
  ll.Print();
  Console.ReadLine();
}

四、运行结果

希望本文所述对大家的C#程序设计有所帮助。

(0)

相关推荐

  • C#定义并实现单链表实例解析

    本文以实例详细描述了C#定义并实现单链表的过程及原理.一般来说C#定义并实现单链表,代码包括构成链表的结点定义.用变量来实现表头.清空整个链表 .链表复位,使第一个结点成为当前结点.判断链表是否为空.判断当前结点是否为最后一个结点.返回当前结点的下一个结点的值,并使其成为当前结点.将当前结点移出链表,下一个结点成为当前结点等内容. 具体实现代码如下所示: using System; using System.IO; // 构成链表的结点定义 public class Node { public

  • c# 自定义泛型链表类的详解

    (1)自定义泛型链表类. 复制代码 代码如下: public class GenericList<T>    {        private class Node        {            //当前节点值            private T data;            public T Data            {                get { return data; }                set { data = value; } 

  • C#数据结构之循环链表的实例代码

    复制代码 代码如下: public class Node    {        public object Element;        public Node Link; public Node()        {            Element = null;            Link = null;        } public Node(object theElement)        {            Element = theElement;      

  • c#泛型学习详解 创建线性链表

    术语表 generics:泛型type-safe:类型安全collection: 集合compiler:编译器run time:程序运行时object: 对象.NET library:.Net类库value type: 值类型box: 装箱unbox: 拆箱implicity: 隐式explicity: 显式linked list: 线性链表node: 结点indexer: 索引器 泛型是什么? 很多人觉得泛型很难理解.我相信这是因为他们通常在了解泛型是用来解决什么问题之前,就被灌输了大量的理论

  • C#实现单链表(线性表)完整实例

    本文实例讲述了C#实现单链表(线性表)的方法.分享给大家供大家参考,具体如下: 顺序表由连续内存构成,链表则不同.顺序表的优势在于查找,链表的优势在于插入元素等操作.顺序表的例子:http://www.jb51.net/article/87605.htm 要注意的是,单链表的Add()方法最好不要频繁调用,尤其是链表长度较长的时候,因为每次Add,都会从头节点到尾节点进行遍历,这个缺点的优化方法是将节点添加到头部,但顺序是颠倒的. 所以,在下面的例子中,执行Purge(清洗重复元素)的时候,没有

  • C#如何自定义线性节点链表集合

    本例子实现了如何自定义线性节点集合,具体代码如下: using System; using System.Collections; using System.Collections.Generic; namespace LineNodeDemo { class Program { static void Main(string[] args) { LineNodeCollection lineNodes = new LineNodeCollection(); lineNodes.Add(new

  • C#双向链表LinkedList排序实现方法

    本文实例讲述了C#双向链表LinkedList排序实现方法.分享给大家供大家参考.具体如下: 1.函数 打印链表函数PrintLinkedList 和 排序函数SortLinkedList 注:下面代码中的链表每项都是double类型,如果换做其他的类型或结构,则需要适当修改 /// <summary> /// 打印链表各结点信息 /// </summary> /// <param name="ll"></param> private s

  • C#数据结构与算法揭秘三 链表

    上文我们讨论了一种最简单的线性结构--顺序表,这节我们要讨论另一种线性结构--链表. 什么是链表了,不要求逻辑上相邻的数据元素在物理存储位置上也相邻存储的线性结构称之为链表.举个现实中的例子吧,假如一个公司召开了视频会议的吧,能在北京总公司人看到上海分公司的人,他们就好比是逻辑上相邻的数据元素,而物理上不相连.这样就好比是个链表. 链表分为①单链表,②单向循环链表,③双向链表,④双向循环链表. 介绍各种各样链表之前,我们要明白这样一个概念.什么是结点.在存储数据元素时,除了存储数据元素本身的信息

  • C#数据结构之单链表(LinkList)实例详解

    本文实例讲述了C#数据结构之单链表(LinkList)实现方法.分享给大家供大家参考,具体如下: 这里我们来看下"单链表(LinkList)".在上一篇<C#数据结构之顺序表(SeqList)实例详解>的最后,我们指出了:顺序表要求开辟一组连续的内存空间,而且插入/删除元素时,为了保证元素的顺序性,必须对后面的元素进行移动.如果你的应用中需要频繁对元素进行插入/删除,那么开销会很大. 而链表结构正好相反,先来看下结构: 每个元素至少具有二个属性:data和next.data

  • C#数据结构与算法揭秘四 双向链表

    首先,明白什么是双向链表.所谓双向链表是如果希望找直接前驱结点和直接后继结点的时间复杂度都是 O(1),那么,需要在结点中设两个引用域,一个保存直接前驱结点的地址,叫 prev,一个直接后继结点的地址,叫 next,这样的链表就是双向链表(Doubly Linked List).双向链表的结点结构示意图如图所示. 双向链表结点的定义与单链表的结点的定义很相似, ,只是双向链表多了一个字段 prev.其实,双向链表更像是一根链条一样,你连我,我连你,不清楚,请看图. 双向链表结点类的实现如下所示

随机推荐