C#完成單鏈表(線性表)完全實例

C#完成單鏈表(線性表)完全實例。本站提示廣大學習愛好者：（C#完成單鏈表(線性表)完全實例）文章只能為提供參考，不一定能成為您想要的結果。以下是C#完成單鏈表(線性表)完全實例正文

本文實例講述了C#完成單鏈表(線性表)的辦法。分享給年夜家供年夜家參考，詳細以下：

次序表由持續內存組成，鏈表則分歧。次序表的優勢在於查找，鏈表的優勢在於拔出元素等操作。次序表的例子：http://www.jb51.net/article/87605.htm

要留意的是，單鏈表的Add（）辦法最好不要頻仍挪用，特別是鏈表長度較長的時刻，由於每次Add，都邑從頭節點到尾節點停止遍歷，這個缺陷的優化辦法是將節點添加到頭部，但次序是倒置的。

所以，鄙人面的例子中，履行Purge（清洗反復元素）的時刻，沒有應用Add（）辦法去添加元素，而是界說一個節點，讓它一直指向目的單鏈表的最初一個節點，如許就不消每次都從頭至尾遍歷。

另外，鏈表還可以做成輪回鏈表，即最初一個結點的next屬性等於head，重要操作與單鏈表類似，斷定最初一個結點，不是等於null，而是等於head

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace LinearList
{
  //界說線性表的行動，可供次序表類和單鏈表類繼續
  public interface IListDS<T>
  {
    int GetLength();
    void Insert(T item, int i);
    void Add(T item);
    bool IsEmpty();
    T GetElement(int i);
    void Delete(int i);
    void Clear();
    int LocateElement(T item);
    void Reverse();
  }
  //鏈表節點類
  class Node<T>
  {
    private T tData;
    private Node<T> nNext;
    public T Data
    {
      get { return this.tData; }
      set { this.tData = value; }
    }
    public Node<T> Next
    {
      get { return this.nNext; }
      set { this.nNext = value; }
    }
    public Node()
    {
      this.tData = default(T);
      this.nNext = null;
    }
    public Node(T t)
    {
      this.tData = t;
      this.nNext = null;
    }
    public Node(T t,Node<T> node)
    {
      this.tData = t;
      this.nNext = node;
    }
  }
  //該列舉表現單鏈表Add元素的地位，分頭部和尾部兩種
  enum AddPosition {Head,Tail};
  //單鏈表類
  class LinkedList<T>:IListDS<T>
  {
    private Node<T> tHead;//單鏈表的表頭
    public Node<T> Head
    {
      get { return this.tHead; }
      set { this.tHead = value; }
    }
    public LinkedList()
    {
      this.tHead = null;
    }
    public LinkedList(Node<T> node)
    {
      this.tHead = node;
    }
    public void Add(T item,AddPosition p)//選擇添加地位
    {
      if (p == AddPosition.Tail)
      {
        this.Add(item);//默許添加在末尾
      }
      else//從頭部添加會節儉查找的開支，時光龐雜度為O(1)不用每次都輪回到尾部，這正好是次序表的長處
      {
        Node<T> node = this.Head;
        Node<T> nodeTmp = new Node<T>(item);
        if (node == null)
        {
          this.Head = nodeTmp;
        }
        else
        {
          nodeTmp.Next = node;
          this.tHead = nodeTmp;
        }
      }
    }
    #region IListDS<T> 成員
    public int GetLength()
    {
      Node<T> node = new Node<T>();
      int count = 0;
      node = this.tHead;
      while (node != null)
      {
        count++;
        node = node.Next;
      }
      return count;
    }
    public void Insert(T item, int i)//i最小從1開端
    {
      Node<T> insertNode = new Node<T>(item, null);//實例化待添加的Node
      if (this.tHead == null && i == 1)
      {
        this.tHead = insertNode;
        return;
      }
      if (i < 1 || i > this.GetLength() || (this.tHead == null && i != 1))
      {
        Console.WriteLine("There are no elements in this linked list!");
        return;
      }
      int j = 1;
      Node<T> node = this.tHead;
      Node<T> nodeTmp;
      while (node != null && j < i)//輪回停止時，包管node為第i個node
      {
        node = node.Next;
        j++;
      }
      nodeTmp = node.Next;//本來的單鏈表的第i+1個node
      node.Next = insertNode;//第i個node後的node修正為待拔出的node
      insertNode.Next = nodeTmp;//待拔出的node拔出後，厥後繼node為本來鏈表的第i+1個node
    }
    public void Add(T item)//添加至尾部，時光龐雜度為O(n)，假如添加至頭部，則會節儉輪回的開支
    {
      Node<T> LastNode = new Node<T>(item, null);//實例化待添加的Node
      if (this.tHead == null)
      {
        this.tHead = LastNode;
      }
      else
      {
        Node<T> node = this.tHead;
        while (node.Next != null)
        {
          node = node.Next;
        }
        node.Next = LastNode;
      }
    }
    public bool IsEmpty()
    {
      return this.tHead == null;
    }
    public T GetElement(int i)//設i最小從1開端
    {
      if (i < 1 || i > this.GetLength())
      {
        Console.WriteLine("The location is not right!");
        return default(T);
      }
      else
      {
        if (i == 1)
        {
          return this.tHead.Data;
        }
        else
        {
          Node<T> node = this.tHead;
          int j = 1;
          while (j < i)
          {
            node = node.Next;
            j++;
          }
          return node.Data;
        }
      }
    }
    public void Delete(int i)//設i最小從1開端
    {
      if (i < 1 || i > this.GetLength())
      {
        Console.WriteLine("The location is not right!");
      }
      else
      {
        if (i == 1)
        {
          Node<T> node = this.tHead;
          this.tHead = node.Next;
        }
        else
        {
          Node<T> node = this.tHead;
          int j = 1;
          while (j < i-1)
          {
            node = node.Next;
            j++;
          }
          node.Next = node.Next.Next;
        }
      }
    }
    public void Clear()
    {
      this.tHead = null;//講thead設為null後，則一切後繼結點因為掉去援用，期待GC主動收受接管
    }
    public int LocateElement(T item)//前往值最小從1開端
    {
      if (this.tHead == null)
      {
        Console.WriteLine("There are no elements in this linked list!");
        return -1;
      }
      Node<T> node = this.tHead;
      int i = 0;
      while (node != null)
      {
        i++;
        if (node.Data.Equals(item))//假如Data是自界說類型，則其Equals函數必需override
        {
          return i;
        }
        node = node.Next;
      }
      Console.WriteLine("No found!");
      return -1;
    }
    public void Reverse()
    {
      if (this.tHead == null)
      {
        Console.WriteLine("There are no elements in this linked list!");
      }
      else
      {
        Node<T> node = this.tHead;
        if (node.Next == null)//假如只要頭節點，則不作任何修改
        {
        }
        else
        {
          Node<T> node1 = node.Next;
          Node<T> node2;
          while (node1 != null)
          {
            node2 = node.Next.Next;
            node.Next = node2;//可以發明node一直未變，一直是本來的誰人頭節點
            node1.Next = this.tHead;
            this.tHead = node1;
            node1 = node2;
          }
        }
      }
    }
    #endregion
  }
  class Program
  {
    static void Main(string[] args)
    {
      /*測試單鏈表的清空
      lList.Clear();
      Node<int> n = new Node<int>();
      n = lList.Head;
      while (n != null)
      {
        Console.WriteLine(n.Data);
        n = n.Next;
      }
      Console.ReadLine();
       */
      /*測試單鏈表前往元素個數
      LinkedList<int> lList = new LinkedList<int>();
      lList.Add(3);
      Console.WriteLine(lList.GetLength());
      Console.ReadLine();
      */
      /*測試單鏈表拔出
      LinkedList<int> lList = new LinkedList<int>();
      lList.Insert(0,1);
      lList.Add(1);
      lList.Add(2);
      lList.Add(3);
      lList.Add(4);
      lList.Insert(99,3);
      Node<int> n = new Node<int>();
      n = lList.Head;
      while (n != null)
      {
        Console.WriteLine(n.Data);
        n = n.Next;
      }
      Console.ReadLine();
      */
      /*測試單鏈表獲得某地位的值
      LinkedList<int> lList = new LinkedList<int>();
      lList.Add(1);
      lList.Add(2);
      lList.Add(3);
      lList.Add(4);
      Console.WriteLine(lList.GetElement(1));
      Console.ReadLine();
       */
      /*測試單鏈表刪除某地位的值
      LinkedList<int> lList = new LinkedList<int>();
      lList.Add(1);
      lList.Add(2);
      lList.Add(3);
      lList.Add(4);
      Node<int> n = new Node<int>();
      n = lList.Head;
      while (n != null)
      {
        Console.WriteLine(n.Data);
        n = n.Next;
      }
      Console.ReadLine();
      lList.Delete(2);
      Node<int> m = new Node<int>();
      m = lList.Head;
      while (m != null)
      {
        Console.WriteLine(m.Data);
        m = m.Next;
      }
      Console.ReadLine();
      */
       /*測試單鏈表按值查找元素地位
      LinkedList<int> lList = new LinkedList<int>();
      lList.Add(1);
      lList.Add(2);
      lList.Add(3);
      lList.Add(4);
      Console.WriteLine(lList.LocateElement(3));
      Console.ReadLine();
      */
      /*測試單鏈表Reverse操作（逆序）
      LinkedList<int> lList = new LinkedList<int>();
      lList.Add(1);
      lList.Add(2);
      lList.Add(3);
      lList.Add(4);
      lList.Add(5);
      Node<int> m = new Node<int>();
      m = lList.Head;
      while (m != null)
      {
        Console.WriteLine(m.Data);
        m = m.Next;
      }
      Console.ReadLine();
      lList.Reverse();
      Node<int> n = new Node<int>();
      n = lList.Head;
      while (n != null)
      {
        Console.WriteLine(n.Data);
        n = n.Next;
      }
      Console.ReadLine();
      */
      /*測試單鏈表從頭部添加元素
      LinkedList<int> lList = new LinkedList<int>();
      lList.Add(1,AddPosition.Head);
      lList.Add(2, AddPosition.Head);
      lList.Add(3, AddPosition.Head);
      lList.Add(4, AddPosition.Head);
      lList.Add(5, AddPosition.Head);
      Node<int> m = new Node<int>();
      m = lList.Head;
      while (m != null)
      {
        Console.WriteLine(m.Data);
        m = m.Next;
      }
      Console.ReadLine();
      */
      /*測試對單鏈表消除反復元素操作（前往另外一鏈表）。這個例子中防止應用Add（）辦法，由於每一個Add（）都要從頭至尾停止遍歷，不實用Add（）辦法
       就請求對目的鏈表的最初一個元素及時保留。另外一種防止的辦法在於從頭部Add，但如許的終究成果為倒序
      LinkedList<int> lList = new LinkedList<int>();//原鏈表
      LinkedList<int> lList2 = new LinkedList<int>();//保留成果的鏈表
      lList.Add(1);
      lList.Add(2);
      lList.Add(1);
      lList.Add(3);
      lList.Add(3);
      lList.Add(4);
      lList.Add(5);
      Node<int> m = new Node<int>();
      m = lList.Head;
      while (m != null)
      {
        Console.WriteLine(m.Data);
        m = m.Next;
      }
      Console.ReadLine();
      Node<int> node1 = lList.Head;//標識原鏈表確當前要介入比擬年夜小的元素，便可能放入鏈表2中的元素
      Node<int> node2;//標識成果單鏈表的最初一個元素，防止應用Add函數形成屢次遍歷
      Node<int> node3;//對node1的後繼停止臨時保留，並終究付給node1
      node3 = node1.Next;
      lList2.Head = node1;//鏈表1的頭結點確定要參加鏈表2
      node2 = lList2.Head;//node2表現鏈表2的最初一個元素，此時最初一個元素為頭結點
      node2.Next = null;//因為是把node1賦給了鏈表2的頭結點，必需把它的後續結點設為null，不然會一路帶過去
      node1 = node3;//假如沒有node3暫存node1的後繼，對lList2.Head後繼賦為null的就會同時修正node1的後繼，由於二者指向統一塊內存
      while (node1 != null)
      {
        //在iList2中比擬年夜小
        Node<int> tmp = lList2.Head;
        if (node1.Data.Equals(tmp.Data))
        {
          node1 = node1.Next;
          continue;//若相等，則node1向後移一名，從新盤算
        }
        else
        {
          Node<int> tmp2 = tmp;
          tmp = tmp.Next;//tmp標識鏈表2的用於輪回的節點，與node比擬
          if (tmp == null)//當鏈表2中現有元素與node1都不相等時
          {
            node3 = node1.Next;
            node2.Next = node1;
            node2 = node1;
            node2.Next = null;
            node1 = node3;
            continue;
          }
          while (tmp != null)//tmp不為null時，一向輪回到它為null
          {
            if (node1.Data.Equals(tmp.Data))
            {
              node1 = node1.Next;
            }
            else
            {
              tmp2 = tmp;
              tmp = tmp.Next;
              if (tmp == null)
              {
                node3 = node1.Next;
                node2.Next = node1;
                node2 = node1;
                node2.Next = null;
                node1 = node3;
              }
            }
          }
        }
      }
      //輸入消除反復處置後的數組
      Node<int> n = new Node<int>();
      n = lList2.Head;
      while (n!= null)
      {
        Console.WriteLine(n.Data);
        n = n.Next;
      }
      Console.ReadLine();
      */
    }
  }
}

願望本文所述對年夜家C#法式設計有所贊助。