双向链表LinkedList的使用

Document类:

class Document
    {
        public string Title { get; private set; }
        public string Content { get; private set; }
        public byte Priority { get; private set; }

        public Document(string title, string content, byte priority = 0)
        {
            this.Title = title;
            this.Content = content;
            this.Priority = priority;
        }
    }

PriorityDocumentManager类:

class PriorityDocumentManager
    {
        private readonly LinkedList<Document> documentList;
        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));
            }
        }

        public void AddDocument(Document doc)
        {
            if (doc == null)
            {
                throw new ArgumentNullException("doc");
            }
            AddDocumentToPriorityNode(doc, doc.Priority);
        }

        private void AddDocumentToPriorityNode(Document doc, int priority)
        {
            if (priority > 9 || priority < 0)
            {
                throw new ArgumentException("优先级必须大于0小于9");
            }

            if (priorityNodes[priority].Value == null)
            {
                --priority;
                if (priority >= 0)
                {
                    AddDocumentToPriorityNode(doc, priority);
                }
                else
                {
                    documentList.AddLast(doc);
                    priorityNodes[doc.Priority] = documentList.Last;
                }

                return;
            }
            else
            {
                LinkedListNode<Document> prioNode = priorityNodes[priority];
                if (priority == doc.Priority)
                {
                    documentList.AddAfter(prioNode, doc);
                    priorityNodes[doc.Priority] = prioNode.Next;
                }
                else
                {
                    LinkedListNode<Document> firstPrioNode = prioNode;
                    while (firstPrioNode.Previous != null && firstPrioNode.Previous.Value.Priority == prioNode.Value.Priority)
                    {
                        firstPrioNode = prioNode.Previous;
                        prioNode = firstPrioNode;
                    }

                    documentList.AddBefore(firstPrioNode, doc);

                    priorityNodes[doc.Priority] = firstPrioNode.Previous;
                }
            }
        }

        public void DisplayAllNodes()
        {
            foreach (var doc in documentList)
            {
                Console.WriteLine("priority: {0}, title: {1}", doc.Priority, doc.Title);
            }
        }

        public Document GetDocument()
        {
            Document doc = documentList.First.Value;
            documentList.RemoveFirst();
            return doc;
        }
    }

应用层:

            PriorityDocumentManager pdm = new PriorityDocumentManager();
            pdm.AddDocument(new Document("one", "content", 3));
            pdm.AddDocument(new Document("two", "content", 1));
            pdm.AddDocument(new Document("three", "content", 2));
            pdm.AddDocument(new Document("six", "content", 4));
            pdm.DisplayAllNodes(); 

附上应用层运行结果的截图:

时间: 2024-10-31 08:34:44

双向链表LinkedList的使用的相关文章

双向链表LinkedList使用

LinkedList是传统意义上的链表也就是双向链表.每个元素都是节点,都可以指向下一级 在前添加,在后添加: mSource.AddLast(...) mSource.AddFirst(...) 在某个节点前添加,在某个节点后添加: mSource.AddBefore(node, willAddNode) mSource.AddAfter(node, willAddNode)

Java 自定义双向链表

双向链表 LinkedList其实也就是我们在数据结构中的链表,这种数据结构有这样的特性: 分配内存空间不是必须是连续的:插入.删除操作很快,只要修改前后指针就OK了,时间复杂度为O(1):访问比较慢,必须得从第一个元素开始遍历,时间复杂度为O(n):在Java中,LinkedList提供了丰富的方法,可以模拟链式队列,链式堆栈等数据结构,为用户带来了极大的方便,下面我们来自定义一个双向链表(目的了解底层实现原理) 自定义节点结构 1 // 自定义节点结构 2 class Node { 3 No

Map 综述(二):彻头彻尾理解 LinkedHashMap

摘要: HashMap和LinkedList合二为一即是LinkedHashMap.所谓LinkedHashMap,其落脚点在HashMap,因此更准确地说,它是一个将所有Entry节点链入一个双向链表LinkedList的HashMap.由于LinkedHashMap是HashMap的子类,所以LinkedHashMap自然会拥有HashMap的所有特性.比如,LinkedHashMap的元素存取过程基本与HashMap基本类似,只是在细节实现上稍有不同.当然,这是由LinkedHashMap

提高C#质量与性能

这篇随笔,用来记录提高C#质量和性能的方法. 基本 使用字符串应避免两种性能开销. 1.确保尽量少的装箱:值类型转换引用类型,会进行装箱操作.但是值类型的ToString(),是非托管方法,直接操作内存进行转换.故此不会进行装箱操作.9.ToString() 性能高于 string s = 9; 2.避免分配额外的内存空间:因字符串不可变性,对字符串进行任何操作或运算都会创建新对象,需要分配新的内存空间.使用常量进行+ 拼接,不会分配内存空间.尽量使用StringBuilder.string.F

C# IEnumerable&lt;T&gt;、IEnumerator&lt;T&gt;、List&lt;T&gt;、ArrayList、[]数组各各的区别

List <T>是ArrayList的泛型,ArrayList里边的数据类型是object,List <T>里边的是具体的某种类型. ArrayList类似于向量,可以存储不同的数据类型在一个数组里边(转换为了object). 一般使用的时候尽量使用List <T>,因为ArrayList存取都要进行一次转换(装箱.拆箱). []类型的数组类似于List <T>,不同的是[]是定长的,而List <T>是长度可变的数组. ICollection主

.NET面试题系列[11] - IEnumerable&lt;T&gt;的派生类

“你每次都选择合适的数据结构了吗?” - Jeffery Zhao .NET面试题系列目录 ICollection<T>继承IEnumerable<T>.在其基础上,增加了Add,Remove等方法,可以修改集合的内容.IEnumerable<T>的直接继承者还有Stack<T>和Queue<T>. 所有标准的泛型集合都实现了ICollection<T>.主要的几个继承类有IList<T>,IDictionary<K

Java 面试题:百度前200页都在这里了

基本概念 操作系统中 heap 和 stack 的区别 什么是基于注解的切面实现 什么是 对象/关系 映射集成模块 什么是 Java 的反射机制 什么是 ACID BS与CS的联系与区别 Cookie 和 Session的区别 fail-fast 与 fail-safe 机制有什么区别 get 和 post请求的区别 Interface 与 abstract 类的区别 IOC的优点是什么 IO 和 NIO的区别,NIO优点 Java 8 / Java 7 为我们提供了什么新功能 什么是竞态条件?

百度Java工程师面试资源

基本概念 操作系统中 heap 和 stack 的区别什么是基于注解的切面实现什么是 对象/关系 映射集成模块什么是 Java 的反射机制什么是 ACIDBS与CS的联系与区别Cookie 和 Session的区别fail-fast 与 fail-safe 机制有什么区别get 和 post请求的区别Interface 与 abstract 类的区别IOC的优点是什么IO 和 NIO的区别,NIO优点Java 8 / Java 7 为我们提供了什么新功能什么是竞态条件? 举个例子说明.JRE.J

Java 基础总结

Java基础总结 jdk:Java的开发环境与部署环境jre:Java的运行环境 Java数据类型分为:基本类型和引用类型 基本类型:①整数类型 byte   short   int   long 默认值: 0   ②字符类型 char 默认值: 空格   ③浮点类型 float  double 默认值: 0.0   ④布尔类型 boolean 默认值: false 引用类型:①类  ②接口  ③数组  ④ null 类型 Java中除基本类型之外的类型都被称为引用类型,默认值为: null 八