C# LinkedList.AddAfter方法代码示例

 static void Main(string[] args)
 {
     LinkedListNode<string> node = new
     LinkedListNode<string>("KARTHIK");
     LinkedList<string> names = new LinkedList<string>();
     names.AddFirst(node);
     LinkedListNode<string> node1 = new
     LinkedListNode<string>
     ("ANIL");
     names.AddAfter(node, node1);
     LinkedListNode<string> node2 = new
     LinkedListNode<string>
     ("SUMAN");
     names.AddAfter(node1, node2);
     LinkedListNode<string> node3 = new LinkedListNode
     <string>(null);
     LinkedListNode<string> aNode = names.First;
     while (aNode != null)
     {
         Console.WriteLine(aNode.Value);
         aNode = aNode.Next;
     }
     aNode = names.Find("David");
     if (aNode != null) aNode = names.First;
     while (aNode != null)
     {
         Console.WriteLine(aNode.Value);
         aNode = aNode.Next;
     }
     Console.Read();
 }

        public void MethodUnderTest_TestedBehavior_ExpectedResult()
        {
            var nodeList = new LinkedList<object>();
            nodeList.Add(new ListNode<object>(1));
            nodeList.Add(new ListNode<object>(2));
            nodeList.Add(new ListNode<object>(3));
            nodeList.Add(new ListNode<object>(4));
            nodeList.Add(new ListNode<object>(5));
            nodeList.Add(new ListNode<object>(6));
            nodeList.Add(new ListNode<object>("d"));
            nodeList.Add(new ListNode<object>("g"));
            nodeList.AddAfter(3, new ListNode<object>("B"));
            nodeList.AddAfter("g", new ListNode<object>("uber"));

            Console.WriteLine(nodeList.Tail);


            Console.WriteLine("The list has {0} elements!", nodeList.ListSize);
            nodeList.Traverse();
            nodeList.Reverse();
            nodeList.Traverse();

            Assert.That(nodeList.ListSize, Is.EqualTo(10));
            Assert.That(nodeList.Contains("g"), Is.True);

            nodeList.Remove("d");
            nodeList.Remove("g");

            Assert.That(nodeList.ListSize, Is.EqualTo(8));
            Assert.That(nodeList.Contains("g"), Is.False);

            nodeList.Reverse();
            nodeList.Traverse();
        }

        public void ExploreLinkedLists()
        {
            // a LinkedList is a doubly linked list
            var linkedList = new LinkedList<string>();
            linkedList.AddFirst("1");
            // first argument accepts a "LinkedListNode"
            linkedList.AddAfter(linkedList.First, "2");
            linkedList.AddLast("3");
            linkedList.AddAfter(linkedList.Find("2"), "4");

            var orderedArray = linkedList.ToArray();
            // order should be 1,2,4,3
            Assert.That(orderedArray[0], Is.EqualTo("1"));
            Assert.That(orderedArray[1], Is.EqualTo("2"));
            Assert.That(orderedArray[2], Is.EqualTo("4"));
            Assert.That(orderedArray[3], Is.EqualTo("3"));

            // advantages:
            //  insertion is really easy

            // disadvantages:
            // looping through the objects is harder because they arent saved on contigous memory blocks

            // most of the time it is best NOT to use linked lists
            // essentially they are only good for insert/remove in the middle of lists
            // LinkedList<T> does NOT implement IList<T> - so does not have alot of useful methods
            // List<T> is much faster for random access (because backed by Array)
            // SEE: https://stackoverflow.com/questions/169973/when-should-i-use-a-list-vs-a-linkedlist
        }

 public void NoCycle()
 {
     var list = new LinkedList<string>();
     var first = list.AddFirst(new LinkedListNode<string>("first"));
     list.AddAfter(first, new LinkedListNode<string>("second"));
     var second = first.Next;
     list.AddAfter(second, new LinkedListNode<string>("third"));
     var detection = new CycleDetection<string>(list);
     Assert.That(detection.HasCycle, Is.False);
 }

        public void LinkedList()
        {
            var list = new LinkedList<string>();
            var first = list.AddFirst("Matteo");
            var second = list.AddAfter(first, "Pierangeli");
            var third = list.AddAfter(second, "ha");
            var fourth = list.AddAfter(third, "32");
            var fifth = list.AddAfter(fourth, "anni");

            Assert.That(third.Previous.Value, Is.EqualTo("Pierangeli"));
            Assert.That(third.Next.Value, Is.EqualTo("32"));
        }

        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);
            }
        }

 public void CycleDetectStartElement()
 {
     var list = new LinkedList<string>();
     var first = list.AddFirst(new LinkedListNode<string>("first"));
     var second = list.AddAfter(
         first,
         new LinkedListNode<string>("second")
     );
     list.AddAfter(
         second,
         new LinkedListNode<string>("third")
     );
     list.AddLast(second);
     var detection = new CycleDetection<string>(list);
     Assert.That(detection.CycleBeginning, Is.EqualTo(second));
 }

        public static void Main(string[] args)
        {
            /* Creating a Simple Linked List */

            LinkedList<Object> MyLinkedList = new LinkedList<Object>();

            /* Inserting Elements */

            MyLinkedList.AddLast ("Add");
            MyLinkedList.AddLast(4);

            /* Implementing Find */

            MyLinkedList.AddAfter(MyLinkedList.Find("Add"), 'a');

            /* Printing Elements of the List */

            PrintList (MyLinkedList);

            /* Remove a particular element from the List */

            MyLinkedList.Remove (4);

            PrintList (MyLinkedList);

            /* Printing the Count of the List */

            int linkedListCount = MyLinkedList.Count;

            Console.WriteLine (linkedListCount);
        }

        static void Main(string[] args)
        {
            List<int> list = new List<int>
            {
                3,2,
            }; // 3, 2

            list.Add(5); // 3, 2, 5
            list.Add(6); // 3, 2, 5, 6
            list.Remove(5); // 3, 2, 6

            Queue<int> queue = new Queue<int>();
            queue.Enqueue(3);// 3
            queue.Enqueue(8);// 3, 8
            queue.Dequeue(); // 8

            Stack<int> stack = new Stack<int>();
            stack.Push(2); // 2
            stack.Push(7); // 7, 2
            stack.Push(8); // 8, 7, 2
            stack.Pop();   // 7, 2

            foreach (var i in stack)
            {
                Console.WriteLine(i);
            }

            LinkedList<int> linkedList = new LinkedList<int>();
            linkedList.AddFirst(9); // 9
            linkedList.AddAfter(linkedList.Find(9), 5); // 9, 5
            linkedList.Remove(9); // 5

            Console.Read();
        }

        public MyClass()
        {
            LinkedList<int> test = new LinkedList<int>();
            LinkedListNode<int> node = test.AddFirst(1);
            node = test.AddAfter(node,5);
            node = test.AddAfter(node,3);
            node = test.AddBefore(node,2);
            LinkedListNode<int> third = node = test.AddAfter(node,6);
            node = test.AddAfter(node,2);

            test.AddAfter(third,4);
            node = test.First;
            while(node != null)
            {
                Console.WriteLine(node.Value);
                node = node.Next;
            }
        }

 public void Cycle()
 {
     var list = new LinkedList<string>();
     var first = list.AddFirst(new LinkedListNode<string>("first"));
     list.AddAfter(first, new LinkedListNode<string>("second"));
     list.AddLast(first);
     var detection = new CycleDetection<string>(list);
     Assert.That(detection.HasCycle, Is.True);
 }

    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()
    {
        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);
    }

 static void Main(string[] args)
 {
     LinkedList<string> linked = new LinkedList<string>();
     //ape->cat->dog->man
     linked.AddLast("cats");
     linked.AddLast("dog");
     linked.AddLast("man");
     linked.AddFirst("ape");
     //ape->cat->monkey->dog->man
     LinkedListNode<string> node = linked.Find("cat");
     linked.AddAfter(node, "monkey");
 }

        public void TestAddAfterNoPrevious()
        {
            var expected = new int[3] { 0, 1, 2 };

            var list = new LinkedList<int>();
            var node = list.AddLast(0);
            list.AddLast(2);

            list.AddAfter(node, 1);

            Verify(expected, list);
        }