单链表排序及克隆

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

namespace 单链表排序
{
    /// <summary>
    /// 运算符重载
    /// </summary>
    public class MyString
    {
        public string Val { get; set; }
        public MyString(string s)
        {
            Val = s;
        }
        public MyString() { }

        //加
        public static MyString operator +(MyString a, MyString b)
        {
            MyString ret = new MyString();
            ret.Val = a.Val + b.Val;
            return ret;
        }
        //减
        public static MyString operator -(MyString a, MyString b)
        {
            MyString ret = new MyString();
            ret.Val = a.Val.Substring(0, a.Val.LastIndexOf(b.Val));
            return ret;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
             LinkList<int> a = new LinkList<int>();
             a.Append(17);
            a.Append(2);
            a.Append(10);
            a.Append(15);
            a.Append(6);

            LinkList<int> d = (LinkList<int>)a.Clone();
            LinkList<int> e = a;//随a变化


            LinkList<int> b = new LinkList<int>();
            b.Append(5);
            b.Append(9);
            LinkList<int> c = new LinkList<int>();
            c = a + b;
 
            //排序
            a.ListSort();
            Node<int> S = a.Head;
            for (int i = 0; i < a.GetLength(); i++)
            {
                Console.WriteLine(S.Data);
                S = S.Next;

            }
            Console.ReadKey();

        }
    }
    public interface IListDS<T>
    {
        int GetLength(); //求长度
        void Clear(); //清空操作
        bool IsEmpty(); //判断线性表是否为空
        bool Append(T item); //附加操作
        bool Insert(T item, int i); //插入操作
        T Delete(int i); //删除操作
        T GetElem(int i); //取表元
        int Locate(T value); //按值查找
    }
    public class Node<T>:ICloneable
    {
        private T data;              //数据域
        private Node<T> next;        //引用域

        /// <summary>
        /// 构造器，要求输入数据值
        /// </summary>
        /// <param name="val">数据值</param>
        public Node(T val)
        {
            data = val;
            next = null;
        }

        /// <summary>
        /// 构造器, 数据值为系统默认值
        /// </summary>
        public Node()
        {
            data = default(T);
            next = null;
        }

        /// <summary>
        /// 数据域属性
        /// </summary>
        public T Data
        {
            get
            {
                return data;
            }
            set
            {
                data = value;
            }
        }

        /// <summary>
        /// 引用域属性
        /// </summary>
        public Node<T> Next
        {
            get
            {
                return next;
            }
            set
            {
                next = value;
            }
        }

        #region ICloneable 成员
        //实现克隆
        public object Clone()
        {
            Node<T> clone = new Node<T>();
            clone.Data = this.data;
            clone.Next = this.next;
            return clone;
        }

        #endregion
    }
    public class LinkList<T> : IListDS<T>,ICloneable
    {
        /// <summary>
        /// 单链表的头节点,即第一个节点
        /// </summary>
        private Node<T> head;

        /// <summary>
        /// 单链表的头节点
        /// </summary>
        public Node<T> Head
        {
            get
            {
                return head;
            }

            set
            {
                head = value;
            }
        }


        /// <summary>
        ///构造器,构造具有空引用的头节点 
        /// </summary>
        public LinkList()
        {
            head = null;
        }


        /// <summary>
        /// 求单链表的长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            Node<T> curNode = head;
            int len = 0;
            while (curNode != null)
            {
                ++len;
                curNode = curNode.Next;
            }
            return len;
        }


        /// <summary>
        /// 清空单链表
        /// </summary>
        public void Clear()
        {
            head = null;
        }


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


        /// <summary>
        /// 在单链表的末尾添加新元素
        /// </summary>
        /// <param name="item">新数据</param>
        public bool Append(T item)
        {
            Node<T> newNode = new Node<T>(item);
            Node<T> curNode = null;

            if (head == null)
            {
                head = newNode;
                return false;
            }
            curNode = head;
            while (curNode.Next != null)
            {
                curNode = curNode.Next;
            }
            curNode.Next = newNode;
            return true;
        }



        /// <summary>
        /// 在单链表的第pos个结点的位置前插入一个值为item的结点
        /// </summary>
        /// <param name="item">新数据</param>
        /// <param name="pos">将要插入的位置，有效值为大于等于0的整数</param>
        /// <returns></returns>
        public bool Insert(T item, int pos)
        {
            if (pos < 0)//IsEmpty() || 
            {
                Console.WriteLine("List is empty or Position is error!");
                return false;
            }

            Node<T> newNode = new Node<T>(item);

            if (pos == 0)
            {
                newNode.Next = head;
                head = newNode;
                return true;
            }


            Node<T> curNode = head.Next;
            Node<T> frontNode = head;
            int index = 1;

            while (curNode.Next != null && index < pos)
            {
                frontNode = curNode;
                curNode = curNode.Next;
                ++index;
            }

            if (index == pos)
            {
                newNode.Next = curNode;
                frontNode.Next = newNode;
                return true;
            }
            else
            {
                Console.WriteLine(" Position is error!");
                return false;
            }
        }


        /// <summary>
        /// 删除单链表的第pos个结点
        /// </summary>
        /// <param name="pos"></param>
        /// <returns></returns>
        public T Delete(int pos)
        {

            if (IsEmpty() || pos < 0)
            {
                Console.WriteLine("Link is empty or Position is error!");
                return default(T);
            }

            T data = default(T);


            if (pos == 0)
            {
                data = head.Data;
                head = head.Next;
                return data;
            }

            Node<T> frontNode = this.head;
            Node<T> curNode = this.head.Next;

            int index = 1;

            while (curNode.Next != null && index < pos)
            {
                ++index;
                frontNode = curNode;
                curNode = curNode.Next;
            }

            if (index == pos)
            {
                frontNode.Next = curNode.Next;
                return curNode.Data;
            }
            else
            {
                Console.WriteLine("Position is out of range!");
                return default(T);
            }
        }

        /// <summary>
        /// 获得单链表的第pos个数据元素 
        /// </summary>
        /// <param name="pos">要查找的位置</param>
        /// <returns></returns>
        public T GetElem(int pos)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is empty!");
                return default(T);
            }

            Node<T> curNode = head;
            int index = 0;

            while (curNode.Next != null && index < pos)
            {
                ++index;
                curNode = curNode.Next;
            }

            if (index == pos)
            {
                return curNode.Data;
            }
            else
            {
                Console.WriteLine("Position is out of range!");
                return default(T);
            }
        }

        /// <summary>
        /// 在单链表中查找值为value的结点
        /// </summary>
        /// <param name="value">要查找的数据</param>
        /// <returns>该数据在链表中的位置（从0开始），-1表示没有找到</returns>
        public int Locate(T value)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is Empty!");
                return -1;
            }

            Node<T> curNode = new Node<T>();
            curNode = head;
            int pos = 0;

            while (curNode != null && !curNode.Data.Equals(value))
            {
                curNode = curNode.Next;
                ++pos;
            }
            if (curNode == null)
            {
                return -1;
            }
            return pos;
        }

         //加
        public static LinkList<T> operator +(LinkList<T> a, LinkList<T> b)
        {
            Node<T> corNode = a.Head;
            while (corNode.Next !=null)
            {
                corNode = corNode.Next;
            }
            corNode.Next = b.Head;
            return a;
        }
         //排序
        public void ListSort()
        {
            T[] temp = new T[GetLength()];
            Node<T> n = head;
            for (int i = 0; i < GetLength(); i++)
            {
                temp[i] = n.Data;
                n = n.Next;
                
            }
            Array.Sort(temp, new SortAdapter());
            int count = GetLength();
            this.Clear();
            for (int i = 0; i < count; i++)
            {
                this.Append(temp[i]);
            }
        }
             class SortAdapter : IComparer<T>//通过接口的形式
        {
            public int Compare(T x, T y)
            {
                if (x.GetType().Name == "String" && y.GetType().Name == "String")
                {
                    return (x.ToString()).CompareTo(y);
                }
                if (x.GetType().Name == "Int32" && y.GetType().Name == "Int32")
                {
                    return (int.Parse(x.ToString())).CompareTo(y);
                }
                return 0;
             }
        }

          
 

  



        #region ICloneable 成员
        //克隆

        public object Clone()
        {
            return this.MemberwiseClone();
        }

        #endregion
    }
}