C#写的排序链表

在看《Programming C#》的时候看到了一个排序链表的例子，其实作者原本要讲的是约束，碰巧最近在上数据结构，对这个比较敏感，没想到用C#写链表真是奥妙啊，下面有贴代码。

还有就是发现大多数关于数据结构和算法的书大多都是用C或者Java实现的，C++的好书很少，更谈不上C#了。所以小研究了一下，大概一方面是因为C++概念多，对读者要求比较高。还有一方面就是C++和C#都有内置的STL，里面有很多数据结构的实现，Java 和 C 都没有这种标准。不过话说回来，学数据结构重要的是学习其思想，看看《算法导论》(Introduction to Algorithms)就知道了。

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

namespace  UsingConstraints
... {
    public 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 Equals(Employee rhs)
        ...{
            return this.name == rhs.name;
        }
    }

    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;
                }
                this.prev = 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;
        }
    }

    public 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 Test
    ...{
        static void Main(string[] args)
        ...{
            Test t = new Test();
            t.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);
            }

            LinkedList<Employee> employees = new LinkedList<Employee>();
            employees.Add(new Employee ("John"));
            employees.Add(new Employee("Paul"));
            employees.Add(new Employee("George"));
            employees.Add(new Employee("Ringo"));

            Console.WriteLine(" Retrieving collections...");

            Console.WriteLine("Integers: " + myLinkedList);
            Console.WriteLine("Employees: " + employees);

            Console.ReadKey();
        }
    }
}