C#中链表的用使用LinkedList

来源：互联网发布：国家食品药品数据查询编辑：程序博客网时间：2024/06/04 18:35
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 集合
{
    class 链表
    {
        public static void Main()
        { 
            //LinkedList<T>集合类没有非泛型类的版本，它是一个双向链表，它的元素指向元素的前一个与后一个元素 
            //链表的优点是：如果要插入一个元素到链表的中间位置，会非常的快， 
            //原因是，如果插入，只需要修改上一个元素的Next　与　下一个元素的Previous的引用则可。 
            //像ArrayList列表中，如果插入，需要移动其后的所有元素。 
            //链表的缺点是，链表只能是一个接着一个的访问，这样就要用较长的时间来查找定位位于链表中间的元素。 
            //LinkedListNode<T>被LinkedList类包含，用LinkedListNode类，可以获得元素的上一个与下一个元素的引用。 
            //简单介绍一下LinkedList<T>类的方法与属性 
            //Count 返回链表中的元素个数 
            //First 返回链表中的第一个节点，其返回的类型是一个节点类LinkedListNode<T>,用它可以迭代集合中的其它节点 
            //Last 返回最后一个节点。。。。略 
            //AddAfter() AddBefore() AddFirst() AddLast() 
            //使用AddXXXX方法，可以在链表中添加元素分别是链表的头部与尾部，还有一个节点的前面与后面 
            //Remove() RemoveFirst() RemoveLast() First与Last分别删除链表的头部元素与尾表元素 , Remove是删除指定的一个匹配对像 
            //Clear()清除所有的元素 
            //Contains() 搜索一个元素，如果找到返回TRUE找不到返回FALSE 
            //Find() 从链表头开始找一个元素，并返回他的节点类，LinkedListNode<T> 
            //FindLast() 与Find()类似，不同的是从尾部来搜 
            //下面开始写示例，示例中使用了一个链表LinkedList<T>与一个列表List<T> 
            //链表包含文档，与我们上一个队列的例子相同,但文档有一个优先级。在链表中，文档按优先级来排序，如查多个文档优先级相同 
            //则按插入时间来决定优先排序 
            //链表添加文档对象时，它们应放在优先级相同的最后一个文档后面，例如：要加一个文档，优先级数是３，那么，我们应放在３级文档组里的最后一个，因为，此时他一定最晚的 
            PriorityDocumentManager man = new PriorityDocumentManager() ;
            man.AddDocument( new Document( "一" , "nihao" , 8 ) ) ;
            man.AddDocument( new Document( "二" , "nihao" , 3 ) ) ;
            man.AddDocument( new Document( "三" , "nihao" , 4 ) ) ;
            man.AddDocument( new Document( "四" , "nihao" , 8 ) ) ;
            man.AddDocument( new Document( "五" , "nihao" , 1 ) ) ;
            man.AddDocument( new Document( "六" , "nihao" , 9 ) ) ;
            man.AddDocument( new Document( "七" , "nihao" , 1 ) ) ;
            man.AddDocument( new Document( "八" , "nihao" , 1 ) ) ;
            man.DispalyAllNodes();
            Console.Read();
        }
    }
    class Document
    {
        private string title;
        public string Title
        {
            get { return title; }
            set { title = value; }
        }
        private string content;
        public string Content
        {
            get { return content; }
            set { content = value; }
        }
        private int priority;
        public int Priority
        {
            get { return priority; }
            set { priority = value; }
        }
        public Document(string title, string content, byte priority)
        {
            this.priority = priority;
            this.title = title;
            this.content = content;
        }
    }
    class PriorityDocumentManager
    {
        //docList包含所有的文档 
        private readonly LinkedList<Document> documentList ;
        //proiorityNodes包含最多10个元素的引用 
        private readonly List<LinkedListNode<Document>> priorityNodes ;
        public PriorityDocumentManager()
        {
            //初始化 
            documentList = new LinkedList<Document>();
            priorityNodes = new List<LinkedListNode<Document>>(10);
           
            for (int i = 0; i < 10; i++)
            {
                priorityNodes.Add(new LinkedListNode<Document>(null));
            }
        }
        /// <summary> 
        /// 本方法用来添加文档 
        /// </summary> 
        /// <param name="d">要添加的文档对象</param> 
        public void AddDocument(Document d)
        {
            if (d == null)
            {
                //如果文档为空，抛出异常 
                throw new ArgumentNullException("d");
            }
            //调用添加方法 
            AddDocumentToPriorityNode(d,d.Priority);
        }
        /// <summary> 
        /// 递归方法 
        /// </summary> 
        /// <param name="d">要添加的文档对象</param> 
        /// <param name="p">优先级</param> 
        private void AddDocumentToPriorityNode(Document doc, int priority)
        {
            if (priority > 9 || priority < 0)
            {
                throw new ArgumentException( "优先级异常");
            }
            if (this.priorityNodes[priority].Value == null)
            {
                priority --;
                if (priority >= 0)
                {
                    AddDocumentToPriorityNode(doc, priority);
                }
                else
                {
                    this.documentList.AddLast(doc);
                    this.priorityNodes[doc.Priority] = this.documentList.Last;
                }
                return;
            }
            else
            {
                LinkedListNode<Document> priorityNode = this.priorityNodes[priority];
                if (priority == doc.Priority)
                {
                    this.documentList.AddAfter(priorityNode, doc);
                    this.priorityNodes[doc.Priority] = priorityNode.Next;
                }
                else
                {
                    LinkedListNode<Document> firstPriorityNode = priorityNode;
                    while (firstPriorityNode.Previous != null && firstPriorityNode.Previous.Value.Priority == priorityNode.Value.Priority )
                    {
                        firstPriorityNode = priorityNode.Previous;
                    }
                    this.documentList.AddBefore(firstPriorityNode, doc);
                    priorityNodes[doc.Priority] = firstPriorityNode.Previous;
                }
            }
        }
        public void DispalyAllNodes()
        { 
            foreach( Document doc in this.documentList)
            {
                Console.WriteLine( "文档标题：{0} 文档内容:{1} 优先级：{2}" , doc.Title , doc.Content ,doc.Priority);
            }
        }
        //public Document GetDocument() 
        //{ 
        //    Document doc = this.documentList.First.Value; 
        //    this.documentList.RemoveFirst(); 
        //    return doc; 
        //} 
    }
}