C#_约束 实现可排序单链表

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



/*

 使用 约束 实现可排序单链表

 */

namespace UsingConstraints

{

    class Employee : IComparable<Employee>

    {

        private string name;

        public Employee(string name)

        {

            this.name = name;

        }

        public override string ToString()

        {

            return this.name;

        }



        //实现接口

        public int CompareTo(Employee rhs)

        {

            return this.name.CompareTo(rhs.name);

        }

        public bool Equal(Employee rhs)

        {

            return this.name == rhs.name;

        }

    }



    //结点必须实现T的Node的IComparable

    //使用关键字where

    //约束Node只能接受实现了IComparable接口的项

    public class Node<T> : IComparable<Node<T>> where T : IComparable<T>

    {

        private T data;

        private Node<T> next = null;

        private Node<T> prev = null;

        //构造方法

        public Node(T data)

        {

            this.data = data;

        }



        //属性

        public T Data { get { return this.data; } }



        public Node<T> Next { get { return this.next; } }



        public int CompareTo(Node<T> rhs)

        {

            //存在约束，所以可行

            return data.CompareTo(rhs.data);

        }



        public bool Equals(Node<T> rhs)

        {

            return this.data.Equals(rhs.data);

        }



        public Node<T> Add(Node<T> newNode)

        {

            if (this.CompareTo(newNode) > 0) //在我之前

            {

                newNode.next = this;



                //如果前面有结点，将它设为新结点，作为后续

                if (this.prev != null)

                {

                    this.prev.next = newNode;

                    newNode.prev = this.prev;

                }

                //当前结点prev指向新结点

                this.prev = newNode;

                //返回newNode，如果它是新的头结点

                return newNode;

            }

            else     //在我之后

            {

                //如果后面还有结点，一同传递比较

                if (this.next != null)

                {

                    this.next.Add(newNode);

                }

                //没有后续结点了，将新结点作为后续结点

                else

                {

                    this.next = newNode;

                    newNode.prev = this;

                }

                return this;

            }

        }



        public override string ToString()

        {

            string output = data.ToString();

            if (next != null)

            {

                output += ", " + next.ToString();

            }

            return output;

        }



    }



    class LinkedList<T> where T : IComparable<T>

    {

        private Node<T> headNode = null;

        //属性索引器

        public T this[int index]

        {

            get

            {

                int ctr = 0;



                Node<T> node = headNode;



                while(node != null && ctr<=index)

                {

                    if (ctr == index)

                    {

                        return node.Data;

                    }

                    else

                    {

                        node = node.Next;

                    }

                    ++ctr;

                }

                throw new ArgumentOutOfRangeException();

            }

        }



        public LinkedList()

        {

        }



        public void Add(T data)

        {

            if (headNode == null)

            {

                headNode = new Node<T>(data);

            }

            else

            {

                headNode = headNode.Add(new Node<T>(data));

            }

        }





        public override string ToString()

        {

            if (this.headNode != null)

            {

                return this.headNode.ToString();

            }

            else

            {

                return string.Empty;

            }

        }

    }



    class Program

    {

        static void Main(string[] args)

        {

            Program pg = new Program();

            pg.Run();

        }



        public void Run()

        {

            LinkedList<int> myLinkedList = new LinkedList<int>();

            Random rand =new Random();

            Console.Write("Adding: ");

            for(int i=0;i<10;i++)

            {

                int nextInt = rand.Next(10);

                Console.Write("{0} ",nextInt);

                myLinkedList.Add(nextInt);

            }

            Console.WriteLine();

            Console.WriteLine("Integer: "+myLinkedList);



            LinkedList<Employee> empLinkedList = new LinkedList<Employee>();

            empLinkedList.Add(new Employee("John"));

            empLinkedList.Add(new Employee("Wang"));

            empLinkedList.Add(new Employee("Lee"));

            //按顺序排序后显示

            Console.WriteLine("class: " + empLinkedList);

            Console.ReadLine();

        }

    }

}