单向链表练习

单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。

  1 using System;

  2 

  3 namespace LinkClass

  4 {

  5     class Program

  6     {

  7         static void Main(string[] args)

  8         {

  9             LinkedList lkList = new LinkedList("MyLinkList");

 10             lkList.AddNode("FirstNode");

 11             lkList.AddNode("SecondNode");

 12             lkList.AddNode("ThirdNode");

 13             lkList.AddNode("FourthNode");

 14             lkList.AddNode("FifthNode");

 15             lkList.AddNode("SixthNode");

 16             lkList.PrintAllNode();

 17             lkList.DeleteNode("FourthNode");

 18             lkList.PrintAllNode();

 19             lkList.AddNode("FourthNode", "ThirdNode");

 20             lkList.PrintAllNode();

 21             lkList.DeleteNode("FourtsssshNode");

 22             lkList.PrintAllNode();

 23             lkList.SearchNode("SeventhNode");

 24             lkList.PrintNode("FirstNode");

 25 

 26             Console.ReadLine();

 27         }

 28     }

 29 

 30     class Node

 31     {

 32         //单向链表的一个节点应该有三个字段，分别保存节点数据、节点名称和下一个节点

 33         private object data;

 34         private string name;

 35         private Node next;

 36 

 37         //属性

 38         public Node Next

 39         {

 40             get { return next; }

 41             set { next = value; }

 42         }

 43         public object Data

 44         {

 45             get { return data; }

 46             set { data = value; }

 47         }

 48         public string Name

 49         {

 50             get { return name; }

 51         }

 52 

 53         //构造函数

 54         public Node(string name)

 55         {

 56             this.name = name;

 57             this.data = null;

 58             this.next = null;

 59         }

 60         public Node()

 61         {

 62         }

 63     }

 64 

 65     class LinkedList

 66     {

 67         private int nodeCount;

 68         private Node headNode;

 69         private string listName;

 70 

 71         public LinkedList(string listName)

 72         {

 73             this.nodeCount = 1;

 74 

 75             this.headNode = new Node("HeadNode");

 76             //为headNode赋值，这样确保调用AddNode()方法的时候不会出现空引用异常。

 77             //当然AddNode()方法做过首节点的null判断后，就不需要这样定义构造函数了。

 78 

 79             this.listName = listName;

 80         }

 81 

 82 

 83         public void AddNode1(string nodeName)

 84         {

 85             Node newNode = new Node(nodeName);

 86             Node current = this.headNode;

 87             while (current.Next != null)

 88             {

 89                 current = current.Next;

 90             }

 91             //第一版：这样写是有错误的，若headNode为null，则current为null，

 92             //此时while循环会出现空引用异常。

 93             //所以对headNode必须先判断是否为空，或者在构造函数中为headNode赋值。

 94 

 95             current.Next = newNode;

 96             nodeCount++;

 97         }

 98 

 99 

         /// <summary>

         /// 第二版直接插入一个新节点，默认在最后插入，这是正确的实现:

         /// </summary>

         /// <param name="nodeName">要插入的节点的名称</param>

         public void AddNode(string nodeName)

         {

             Node newNode = new Node(nodeName);

 

             if (headNode == null)

             {

                 headNode = newNode;

                 nodeCount++;

             }

             else

             {

                 Node current = this.headNode;

                 while (current.Next != null)

                 {

                     current = current.Next;

                 }

 

                 current.Next = newNode;

                 nodeCount++;

             }

         }

 

         /// <summary>

         /// 在指定节点(名称)后插入新节点

         /// </summary>

         /// <param name="nodeName"></param>

         /// <param name="afterNode"></param>        

         //public void AddNode(string nodeName, Node afterNode)      

         //这是第一版定义的，位置节点参数是用node声明的，

         //那样不合理，因为链表中无法直接引用节点。

         public void AddNode(string nodeName, string afterNodeName)

         //这是第二版，用string类型传入节点名称，这个比较合理。

         {

             Node current = this.headNode;

             Node newNode = new Node(nodeName);

             while (current.Name != afterNodeName)

             {

                 current = current.Next;

             }

             newNode.Next = current.Next;

             current.Next = newNode;

             this.nodeCount++;  //第一版忘记处理计数器了

         }

 

         /// <summary>

         /// 删除某个节点

         /// </summary>

         /// <param name="nodeName">要删除的节点的名称</param>

         public void DeleteNode(string nodeName)

         {

             if (headNode.Name.Equals(nodeName))

             {

                 headNode = headNode.Next;

                 this.nodeCount--;

                 Console.WriteLine("Delete successfully!");

             }

             else

             {

                 Node current = new Node();

                 current = this.headNode;

                 while (!current.Next.Name.Equals(nodeName))

                 {

                     current = current.Next;

                     if (current.Next == null)

                     {

                         Console.WriteLine("Delete Failed!");

                         return;  //关键！

                     }

                 }

                 current.Next = current.Next.Next;

                 this.nodeCount--; //第一版忘记了把计数器减一

                 Console.WriteLine("Delete successfully!");

 

             }

         }

 

 

         /// <summary>

         /// 调用FindPreNode()方法实现的节点删除

         /// </summary>

         /// <param name="nodeName"></param>

         public void DeleteNode2(string nodeName)

         {

             Node preNode = FindPreNode(nodeName);

             if (preNode == null)

                 Console.WriteLine("Delete failed!");

             else

             {

                 preNode.Next = preNode.Next.Next;

                 nodeCount--;

                 Console.WriteLine("Delete successfully!");

             }

         }

 

 

         /// <summary>

         /// 查找某个节点

         /// </summary>

         /// <param name="nodeName">要查找的节点的名称</param>

         public void SearchNode(string nodeName) 

         {

             Node current = this.headNode;

             while (!current.Name.Equals(nodeName))

             {

                 current = current.Next;

                 if (current == null)  

                 //第二版增加的，查找到最后节点还没找到，则current值为null，必须先判断。

                 //第一版的没有做判断，若节点不存在，则会发生nullreferenceexception。

                 {

                     Console.WriteLine("The node {0} is not found!", nodeName);

                     return;      //如果为空，那就是没有找到，直接返回。

                 }

             }

             Console.WriteLine("The node {0} is found!", current.Name);

         }

 

         /// <summary>

         /// 利用find()方法实现节点搜索

         /// </summary>

         /// <param name="nodeName"></param>

         public void FindNode(string nodeName)

         {

             Node current = Find(nodeName);

             if (current == null)

             {

                 Console.WriteLine("The node {0} is not found!", nodeName);

             }

             else

             {

                 Console.WriteLine("The node {0} is found!", current.Name);

             }

         }

 

         /// <summary>

         /// 打印所有节点

         /// </summary>

         public void PrintAllNode()

         {

             Node current = new Node();

             current = this.headNode;

             Console.WriteLine("There are {0} nodes: ", nodeCount);

             Console.Write(headNode.Name + " -> ");

             while (current.Next != null)

             {

                 Console.Write(current.Next.Name + " -> ");

                 //这里用current.Next来判断，否则无法打印出最后一个节点，

                 //但是这样一来就无法打印出第一个节点，因此前面要先打印第一个节点。

 

                 current = current.Next;

             }

 

         }

 

         /// <summary>

         /// 类中有好几个方法都要查找节点，因此可以作为一个方法独立出来，利于复用

         /// </summary>

         /// <param name="nodeName"></param>

         /// <returns>返回找到的节点</returns>

         public Node Find(string nodeName)

         {

             Node current = this.headNode;

 

             while (!current.Name.Equals(nodeName))

             {

                 current = current.Next;

                 if (current == null) //current的值可能为null，所以必须加if判断。

                 {

                     //Console.WriteLine("{0} is not existed!", nodeName);

                     return null;     

                 }

             }

             return current;

         }

 

 

         /// <summary>

         /// 查找某节点的前一个节点

         /// </summary>

         /// <param name="curNodeName">某节点名称</param>

         /// <returns>该节点的前一个节点</returns>

         public Node FindPreNode(string curNodeName)

         {

             Node preNode = null;

             Node current = this.headNode;

             while (!current.Next.Name.Equals(curNodeName))

             {

                 current = current.Next;

                 if (current == null)

                 {

                     //Console.WriteLine("Not find!");

                     return null;

                 }

             }

             preNode = current;

             return preNode;

         }

 

 

         /// <summary>

         /// 利用Find()方法实现的索引器

         /// </summary>

         /// <param name="nodeName"></param>

         /// <returns></returns>

         public Node this[string nodeName]

         {

             get

             {

                 Node current = Find(nodeName);

                 return current;

             }

         }

         

         /// <summary>

         /// 利用索引器打印某个节点

         /// </summary>

         /// <param name="nodeName"></param>

         public void PrintNode(string nodeName)

         {

             Console.WriteLine(this[nodeName].Name);

         }

     }

 }