C# LinkedList.Remove方法代码示例

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

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

    // Implement the data structure linked list. 
    public static void Main()
    {
        var linkedList = new LinkedList<string>();

        linkedList.AddFirst("first");
        linkedList.AddLast("second");
        Console.WriteLine(string.Join(", ", linkedList));

        linkedList.Clear();
        linkedList.AddLast("second");
        linkedList.AddFirst("first");
        Console.WriteLine(string.Join(", ", linkedList));

        string value = "first";
        Console.WriteLine("List contains \"{0}\": {1}", value, linkedList.Contains(value));

        Console.WriteLine("List contains {0} item(s)", linkedList.Count);

        var item = linkedList.Find("second");
        Console.WriteLine(item);

        linkedList.Remove("first");
        Console.WriteLine(string.Join(", ", linkedList));

        linkedList.Remove("second");
        Console.WriteLine("List contains {0} item(s): {1}", linkedList.Count, string.Join(", ", linkedList));

        linkedList.AddFirst("second");
        linkedList.AddFirst("first");
        linkedList.AddLast("third");
        Console.WriteLine(string.Join(", ", linkedList));

        linkedList.Remove("second");
        Console.WriteLine(string.Join(", ", linkedList));
    }

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

 /* 11. Implement the data structure linked list. Define a class ListItem<T> that has two fields: value (of type T) and NextItem (of type ListItem<T>).
  * Define additionally a class LinkedList<T> with a single field FirstElement (of type ListItem<T>).*/
 /// <summary>
 /// Mains the specified args.
 /// </summary>
 public static void Main()
 {
     LinkedList<int> testList = new LinkedList<int>();
     // Console.WriteLine(testList);
     testList.AddFirst(1);
     testList.AddFirst(2);
     testList.AddFirst(8);
     testList.AddFirst(1);
     testList.AddLast(3);
     testList.AddLast(5);
     testList.Remove(1);
     testList.Remove(5);
     Console.Write(testList);
 }

    static void Main()
    {
        LinkedList<int> linkedList = new LinkedList<int>();
        linkedList.Add(5);
        linkedList.Add(10);

        Console.WriteLine(linkedList.Head.Value);
        Console.WriteLine(linkedList.Head.NextNode.Value);
        linkedList.Remove(1);

        Console.WriteLine(linkedList.Head.Value);
        Console.WriteLine(linkedList.Count);

        linkedList.Remove(0);
        Console.WriteLine(linkedList.Count);

        linkedList.Add(1);
        linkedList.Add(2);
        linkedList.Add(3);
        linkedList.Add(4);
        linkedList.Add(5);
        linkedList.Add(1);
        Console.WriteLine(linkedList.FirstIndexOf(1));
        Console.WriteLine(linkedList.FirstIndexOf(20));
        Console.WriteLine(linkedList.LastIndexOf(1));
        Console.WriteLine(linkedList.LastIndexOf(20));

        Console.WriteLine();
        Console.WriteLine("Foreached: ");
        foreach (int value in linkedList)
        {
            Console.WriteLine(value);
        }

        Console.WriteLine();
        Console.WriteLine("Indexes: ");
        Console.WriteLine(linkedList[0]);
        Console.WriteLine(linkedList[1]);
        Console.WriteLine(linkedList[2]);
        Console.WriteLine(linkedList[3]);
        Console.WriteLine(linkedList[4]);
        Console.WriteLine(linkedList[5]);
        // Console.WriteLine(linkedList[6]); // Exception

        Console.WriteLine("Changing the values");
        linkedList[0] = 20;
        linkedList[1] = 30;
        Console.WriteLine(linkedList[0]);
        Console.WriteLine(linkedList[1]);
    }

        static void Main()
        {
            LinkedList<int> numbers = new LinkedList<int>();
            Console.WriteLine("Enter some numbers: ");

            bool isNumber = true;

            while (isNumber)
            {
                int number;
                isNumber = int.TryParse(Console.ReadLine(), out number);
                if (isNumber)
                {
                    numbers.AddLast(number);
                }
            }

            var node = numbers.First;
            while (node != null)
            {
                var next = node.Next;
                if (node.Value < 0)
                    numbers.Remove(node);
                node = next;
            }

            Console.WriteLine(string.Join(" -> ", numbers));
        }

        static void Main(string[] args)
        {
            LinkedList<string> myList = new LinkedList<string>();
            myList.Add("element");
            myList.Add("element2");
            myList.Add("element3");
            myList.Add("element4");
            myList.Add("element5");
            myList.Add("element6");
            myList.Add("element6");
            myList.Add("element6");
            myList.Add("element6");
            myList.Add("element6");
            myList.Add("element4");
            myList.Add("element4");
            myList.Add("element4");

            myList.Remove(2);

            foreach (var element in myList)
            {
                Console.WriteLine(element);
            }
            Console.WriteLine(myList.GetCurrent);
            Console.WriteLine(myList.First);

            Console.WriteLine(myList.FirstIndexOf("item"));
            Console.WriteLine(myList.LastIndexOf("element6"));
        }

        static void Main()
        {
            string line = "3 -9 6 -5 55 84 22 6 -55 56 -100 22";

            string[] elements = line.Split(' ');

            LinkedList<int> list = new LinkedList<int>();

            foreach (string element in elements)
            {
                list.AddLast(int.Parse(element));
            }

            Console.WriteLine("The list before removing all the negative elements:");
            Console.WriteLine(string.Join(", ", list));

            var firstElement = list.First;

            while (firstElement != null)
            {
                var nextElement = firstElement.Next;

                if (firstElement.Value < 0)
                {
                    list.Remove(firstElement);
                }

                firstElement = nextElement;
            }

            Console.WriteLine("The list after removing all the negative elements:");
            Console.WriteLine(string.Join(", ", list));
        }

    public static void Main()
    {
        try
        {
            LinkedList list = new LinkedList();

            Console.WriteLine("It is {0} that this list in empty", list.IsEmpty());

            list.Insert("Happy days");
            list.Insert("Pie in the sky");
            list.Insert("Trouble in River City");

            Console.WriteLine("The original list is:");

            list.Display();
            list.Reset();
            list.Advance();

            Console.WriteLine("The current list element is {0}", list.GetData());

            list.Remove();

            Console.WriteLine("The list, after removing the current element, is:");

            list.Display();

        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
        Console.WriteLine("Hit any key to exit");
        Console.ReadLine();
    }

        /*
            Ultra-duper mega cool code snippet from StackOverflow - It'll save your life one day!
        */
        private static Control FindControlIterative(Control root, string id)
        {
            Control ctl = root;
            var ctls = new LinkedList<Control>();

            while (ctl != null)
            {
                if (ctl.ID == id)
                    return ctl;
                foreach (Control child in ctl.Controls)
                {
                    if (child.ID == id)
                        return child;
                    if (child.HasControls())
                        ctls.AddLast(child);
                }
                if (ctls.First != null)
                {
                    ctl = ctls.First.Value;
                    ctls.Remove(ctl);
                }
                else return null;
            }
            return null;
        }

        public void Solve(StreamWriter writer, StreamReader reader)
        {
            var list = new LinkedList<int>(Enumerable.Range(1, 100));
            var current = list.First.Next;

            while (current != null)
            {
                var value = current.Value;
                var removing = list.First;
                while (removing != null)
                {
                    for (int i = 1; i < value && removing != null; i++)
                        removing = removing.Next;

                    if (removing == null)
                        break;

                    if (removing == current)
                        current = current.Previous;

                    var next = removing.Next;
                    list.Remove(removing);
                    removing = next;
                }
                current = current.Next;
            }
        }

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

 public static void Run()
 {
     string[] line = Console.ReadLine().Split(' ');
     int n = Convert.ToInt32(line[0]), x1 = Convert.ToInt32(line[1]), y1 = Convert.ToInt32(line[2]),
         x2 = Convert.ToInt32(line[3]), y2 = Convert.ToInt32(line[4]);
     LinkedList<Flower> first = new LinkedList<Flower>();
     LinkedList<Flower> second = new LinkedList<Flower>();
     
     for (int i = 0; i < n; i++)
     {
         line = Console.ReadLine().Split(' ');
         int x = Convert.ToInt32(line[0]), y = Convert.ToInt32(line[1]);
         first.AddLast(new Flower { x = x, y = y, dist = (long)(x - x1) * (long)(x - x1) + (long)(y - y1) * (long)(y - y1) });
     }
     long res = long.MaxValue;
     for (int i = 0; i <= n; i++)
     {
         Flower firstmax = first.Count > 0 ? first.Aggregate((c, d) => c.dist > d.dist ? c : d) : null;
         Flower secondmax = second.Count > 0 ? second.Aggregate((c, d) => c.dist > d.dist ? c : d) : null;
         long d1 = 0, d2 = 0;
         if (firstmax != null) d1 = firstmax.dist;
         if (secondmax != null) d2 = secondmax.dist;
         res = Math.Min(res, d1 + d2);
         if (firstmax != null)
         {
             first.Remove(firstmax);
             firstmax.dist = (long)(firstmax.x - x2) * (long)(firstmax.x - x2) + (long)(firstmax.y - y2) * (long)(firstmax.y - y2);
             second.AddLast(firstmax);
         }
     }
     Console.WriteLine(res);
 }