C# LinkedList.AddBefore方法代码示例

        public static void FN(string cmd, string p1, LinkedList<ActionNode> lNode, LinkedListNode<ActionNode> before)
        {
            DirectFunctionCallNode dfn = new DirectFunctionCallNode();
            dfn.Parameters = new List<string>() { BaseCompiled.SET_GET_FROM_RTV, p1 };
            lNode.AddBefore(before, dfn);

            FunctionCallNode fn = new FunctionCallNode();
            fn.Parameters = new List<string>() { cmd, p1 };
            lNode.AddBefore(before, fn);
        }

        public static void Main(string[] args)
        {
            LinkedList<string> list =
            new LinkedList<string>();
            list.AddFirst("1");
            list.AddLast("5");
            list.AddAfter(list.First, "2");
            list.AddBefore(list.Last, "3");
            list.AddBefore(list.Last, "4");
            list.Remove(list.First.NextItem);

            PrintList(list);
        }

 public static void VAR(Token next, LinkedList<ActionNode> lNode, LinkedListNode<ActionNode> before)
 {
     if (next.Type == TokenType.NUMBER)
     {
         DirectFunctionCallNode dfn = new DirectFunctionCallNode();
         dfn.Parameters = new List<string>() { BaseCompiled.SET_CONST_TO_RTV, next.Text };
         lNode.AddBefore(before, dfn);
     }
     else
     {
         DirectFunctionCallNode dfnx = new DirectFunctionCallNode();
         dfnx.Parameters = new List<string>() { BaseCompiled.SET_ID_TO_RTV, next.Text };//Set the variable name
         lNode.AddBefore(before, dfnx);
     }
 }

        static void Main(string[] args)
        {
            //creates a linked list
            LinkedList<string> linked1 = new LinkedList<string>();

            //appending three elements to the list
            linked1.AddLast("One");
            linked1.AddLast("Two");
            linked1.AddLast("Three");
            linked1.AddFirst("Zero");
            PrintLinked1(linked1);

            Console.WriteLine();
            //insterting a node between element "Two" and "Three"
            LinkedListNode<string> myNode = linked1.Find("Three");
            linked1.AddBefore(myNode, "Inserted using add before.");
            PrintLinked1(linked1);

            //removing one element
            linked1.Remove("One");
            PrintLinked1(linked1);

            //remove Three using myNode
            myNode = linked1.Find("Three");
            linked1.Remove(myNode);
            PrintLinked1(linked1);
        }

        static void Main(string[] args)
        {
            LinkedList<string> sporcular = new LinkedList<string>();
            sporcular.AddLast("A");
            sporcular.AddLast("B");
            sporcular.AddLast("C");
            sporcular.AddLast("D");
            sporcular.AddLast("E");
            sporcular.AddLast("F");
            sporcular.AddLast("G");
            sporcular.AddLast("H");

            sporcular.Remove("H");
            sporcular.AddFirst("H");

            sporcular.Remove("E");
            sporcular.AddFirst("E");

            sporcular.AddAfter(sporcular.First, "X");

            LinkedListNode<string> c =
                sporcular.Find("C");

            sporcular.AddBefore(c, "Y");

            foreach (string item in sporcular)
            {
                Console.WriteLine(item);
            }
        }

        private void addFromLast(_DropdownlistLinkedModel model, LinkedList<_DropdownlistLinkedNodeModel> linkedList, int projectId)
        {
            _DropdownlistLinkedNodeModel first = null;
            if (linkedList.Last == null)
            {
                first = new _DropdownlistLinkedNodeModel();
                linkedList.AddLast(first);
            }
            else
            {
                first = linkedList.First.Value;
            }

            first.CurrentProject = getProjectById(projectId);

            _DropdownlistLinkedNodeModel pre = getParent(projectId);
            if (pre != null)
            {
                linkedList.AddBefore(linkedList.First, pre);
                first.Projects = getFromParent(pre.CurrentProject.Id);

                addFromLast(model, linkedList, pre.CurrentProject.Id);
            }
            else
            {
                model.TailSelectedProject = getParentGroup(projectId);
                first.Projects = getFromGroup(model.TailSelectedProject.Id);
            }

        }

        public override Tree<SyntaxToken> Read(LinkedList<MixedToken> tokens, Grammar grammar)
        {
            // Do not create negate syntax token if we are able to create a subtract syntax token
            var lastNegateNode = tokens.FindLastNode(t => t.Value.IsLexicToken &&
                t.Value.LexicToken is SubtractToken && (t.Previous != null && !t.Previous.Value.IsTree || t.Previous == null));
            if (lastNegateNode != null) {
                var next = lastNegateNode.Next;
                if (next == null)
                    throw new ParserException("Unexpected argument of 'negate' operator.");

                if (!next.Value.IsTree)
                    throw new ParserException("Argument of 'negate' operator was not parsed.");

                NegateSyntaxToken token = new NegateSyntaxToken();
                Tree<SyntaxToken> tree = new Tree<SyntaxToken>(token);
                tree.Leafs.Add(next.Value.Tree);

                tokens.AddBefore(lastNegateNode, new MixedToken(tree));
                tokens.Remove(lastNegateNode);
                tokens.Remove(next);

                return tree;
            }

            return null;
        }

        private static IEnumerable<Type> GetTypesOrderedByGeneration(Type[] sourceTypes)
        {
            var queue = new Queue<Type>(sourceTypes);
            var sortedList = new LinkedList<Type>();

            while (queue.Count > 0)
            {
                var currentType = queue.Dequeue();

                // Search through the list and make sure this type is added before any type deriving from it.
                var node = sortedList.First;
                while (true)
                {
                    if (node == null)
                    {
                        sortedList.AddLast(currentType);
                        break;
                    }
                    if (currentType.IsAssignableFrom(node.Value))
                    {
                        sortedList.AddBefore(node, currentType);
                        break;
                    }
                    node = node.Next;
                }
            }
            return sortedList;
        }

        static void Main(string[] args)
        {
            Stack<int> s = new Stack<int>();
            Queue<int> q = new Queue<int>();

            for (int i = 0; i < 10; ++i)
            {
                s.Push(i);
                q.Enqueue(i);
            }

            while (s.Count > 0)
                Console.WriteLine(s.Pop()); //Writes them out in reverse order (9-0). 'Cause FILO

            while (q.Count > 0)
                Console.WriteLine(q.Dequeue()); //Writes them in order (FIFO).
            //New list
            LinkedList<Student> TwoKay = new LinkedList<Student>();
            //New node with a new student
            LinkedListNode<Student> Current = new LinkedListNode<Student>(new Student("AJ", 123432)); 
            //Take that node and add it to my list.
            TwoKay.AddFirst(Current);
            //Add a student without creating a node first
            TwoKay.AddBefore(TwoKay.First, new Student("Caleb", 123456));
            //Show it
            PrintList(TwoKay);
            //Change AJ
            TwoKay.First.Next.Value = new Student("AJ the Mighty", 333);
            //Print the list again
            PrintList(TwoKay);
            //Now, note that the value of current changed, too, because reference.
            Console.WriteLine(Current.Value);
        }

		public void SwapBlocks(LinkedList<Block> leftBlockList, Block leftBlock, LinkedList<Block> rightBlockList, Block rightBlock)
		{
			leftBlockList.AddBefore(leftBlockList.Find(leftBlock), rightBlock);
			leftBlockList.Remove(leftBlockList.Find(leftBlock));

			rightBlockList.AddBefore(rightBlockList.Find(rightBlock), leftBlock);
			rightBlockList.Remove(rightBlock);
		}

        public override LinkedList<int> ordenar(List<int> lista)
        {
            LinkedList<int> ordenada = new LinkedList<int>();
            if (null == lista || lista.Count == 0)
                return null;
            if (ordenada.Count == 0)
                ordenada.AddFirst(lista[0]);
            for (int i = 1; i < lista.Count; i++)
            {
                if (lista[i] < ordenada.First.Value)
                {
                    ordenada.AddFirst(lista[i]);
                }
                else
                {
                    LinkedListNode<int> node = ordenada.First;
                    while (null != node)
                    {
                        if (null != node.Next)
                        {
                            if (lista[i] > node.Value)
                            {
                                node = node.Next;
                            }
                            else
                            {
                                ordenada.AddBefore(node, lista[i]);
                                break;
                            }
                        }
                        else
                        {
                            if (lista[i] > node.Value)
                                ordenada.AddAfter(node, lista[i]);
                            else
                                ordenada.AddBefore(node, lista[i]);
                            break;
                        }

                    }
                }

            }

            return ordenada;
        }

        public void add_item_before_tail_to_an_empty_list_should_become_head_and_tail()
        {
            var list = new LinkedList<int>();
            var one = 1;

            list.AddBefore(list.Head, one);

            Assert.AreEqual(one, list.Head.Value);
            Assert.AreEqual(one, list.Tail.Value);
        }

    static void Main()
    {
        LinkedList<string> list = new LinkedList<string>();
        list.AddFirst("First");
        list.AddLast("Last");
        list.AddAfter(list.First, "After First");
        list.AddBefore(list.Last, "Before Last");

        Console.WriteLine(String.Join(", ", list));
        // Result: First, After First, Before Last, Last
    }

        static void Main()
        {
            LinkedList<int> linkedList = new LinkedList<int>();
            linkedList.AddFirst(5);
            linkedList.AddLast(100);
            linkedList.AddAfter(linkedList.FirstElement.NextItem, 1000);
            linkedList.AddBefore(linkedList.FirstElement.NextItem, 999);
            linkedList.AddBefore(linkedList.FirstElement, 0);
            linkedList.RemoveFirst();
            linkedList.RemoveLast();

            ListItem<int> next = linkedList.FirstElement;
            while (next != null)
            {
                Console.WriteLine(next.Value);
                next = next.NextItem;
            }

            Console.WriteLine(linkedList.Count);
        }

    static void Main()
    {
        Console.WriteLine("Dot Net LinkedList");
        LinkedList<int> dotNetList = new LinkedList<int>();
        dotNetList.AddFirst(3);
        dotNetList.AddFirst(1);
        dotNetList.AddBefore(dotNetList.Last, 2);
        dotNetList.AddBefore(dotNetList.First, 4);
        dotNetList.AddAfter(dotNetList.Last, 5);
        dotNetList.AddAfter(dotNetList.First, 6);
        dotNetList.AddLast(7);
        dotNetList.AddLast(8);
        dotNetList.RemoveFirst();
        dotNetList.RemoveLast();

        foreach (var item in dotNetList)
        {
            Console.WriteLine(item);
        }
        Console.WriteLine("Dot Net LinkedList.Count = {0}", dotNetList.Count);

        Console.WriteLine();
        Console.WriteLine("My LinkedList<T>");
        MyLinkedList<int> myList = new MyLinkedList<int>();
        myList.AddFirst(3);
        myList.AddFirst(1);
        myList.AddBefore(myList.Last, 2);
        myList.AddBefore(myList.First, 4);
        myList.AddAfter(myList.Last, 5);
        myList.AddAfter(myList.First, 6);
        myList.AddLast(7);
        myList.AddLast(8);
        myList.RemoveFirst();
        myList.RemoveLast();

        foreach (var number in myList)
        {
            Console.WriteLine(number);
        }
        Console.WriteLine("MyList.Count = {0}", myList.Count);
    }