C# LinkedList.Contains方法代码示例

        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 ContainsInt()
 {
     var target = new LinkedList<int>() { 1, 2, 3 };
       Assert.IsTrue(target.Contains(1));
       Assert.IsTrue(target.Contains(2));
       Assert.IsTrue(target.Contains(3));
       Assert.IsFalse(target.Contains(0));
 }

        public void ContainsTest()
        {
            var list = new LinkedList<string>();
            Assert.IsTrue(list != null);

            list.Add("first item");

            Assert.IsTrue(list.Contains("first item"));
            Assert.IsFalse(list.Contains("second item"));
        }

        private void ValidateMapping(Type service, LinkedList<Type> breadcrumbs)
        {
            if (breadcrumbs.Contains(service))
                throw new CircularDependenciesException(
                    "Found a circular dependency when looking up " + breadcrumbs.First() +
                    ", when inspecting the constructor of " + breadcrumbs.Last() + ", violating service: " + service,
                    breadcrumbs);



            IList<IBuildPlan> buildPlans;
            if (!_serviceMappings.TryGetValue(service, out buildPlans))
                throw new DependencyNotRegisteredException(breadcrumbs.Last.Value, service);

            var cbp = buildPlans.Last() as ConcreteBuildPlan;
            if(cbp == null)
                return;

            breadcrumbs.AddLast(service);
            foreach (var parameter in cbp.Constructor.GetParameters())
            {
                ValidateMapping(parameter.ParameterType, breadcrumbs);
            }
            breadcrumbs.RemoveLast();
        }

    // 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()
    {
        var list = new LinkedList<int>();

        list.AddLast(1);
        Console.WriteLine(list);

        list.AddLast(2);
        Console.WriteLine(list);

        list.AddLast(3);
        Console.WriteLine(list);

        list.AddFirst(-1);
        Console.WriteLine(list);

        list.AddFirst(-2);
        Console.WriteLine(list);

        list.AddFirst(-3);
        Console.WriteLine(list);

        Console.WriteLine("Remove First: {0}", list.RemoveFirst().Value);
        Console.WriteLine("Remove Last: {0}", list.RemoveLast().Value);
        Console.WriteLine(list);

        Console.WriteLine("Min: {0}; Max: {1}", list.Min(), list.Max());
        Console.WriteLine("Contains 2: {0}", list.Contains(2));
        Console.WriteLine("Count: {0}", list.Count);
    }

        public void ContainsWithEmptyListTest()
        {
            var list = new LinkedList<string>();
            Assert.IsTrue(list != null);

            Assert.IsFalse(list.Contains("test"));
        }

        static LinkedList<LinkedList<string>> convertToDFA(LinkedList<LinkedList<string>> NFA_Table, LinkedList<string> states, LinkedList<string> finalStates, LinkedList<string> alphabets)
        {
            LinkedList<LinkedList<string>> DFA_Table = new LinkedList<LinkedList<string>>();
            LinkedList<string> DFA_States = new LinkedList<string>();
            string newState="";
            DFA_States.AddLast("0");
            for (int i = 0; i < DFA_States.Count; i++)
            {
                for (int j = 0; j < alphabets.Count; j++)
                {
                    for (int k = 0; k < NFA_Table.Count; k++)
                    {
                        if (NFA_Table.ElementAt(k).ElementAt(0).CompareTo(DFA_States.ElementAt(i)) == 0 && NFA_Table.ElementAt(k).ElementAt(2).CompareTo(alphabets.ElementAt(j)) == 0)
                        {
                            newState += NFA_Table.ElementAt(i).ElementAt(1);
                        }
                    }
                    if (DFA_States.Contains(newState) == false)
                    {
                        DFA_States.AddLast(newState);
                        LinkedList<string> DFA_Contacts = new LinkedList<string>();
                        DFA_Contacts.AddLast(DFA_States.ElementAt(i));
                        DFA_Contacts.AddLast(newState);
                        DFA_Contacts.AddLast(alphabets.ElementAt(j));
                        DFA_Table.AddLast(DFA_Contacts);

                    }
                    newState = "";
                }
            }

            return DFA_Table;
        }

 private static void Main()
 {
     var linkedList = new LinkedList<int>();
     Console.WriteLine(linkedList.Count);
     Console.WriteLine(linkedList.Contains(1));
     linkedList.AddFirst(1);
     Console.WriteLine(linkedList.Count);
 }

        public LinkedList<string> CollectTerms(LinkedList<string> terms, LinkedList<string> userTerms)
        {
            LinkedList<string> newTerms= new LinkedList<string>();
            foreach (string term in userTerms) {

                if (!terms.Contains(term)) newTerms.AddLast(term);

            }
            return newTerms;
        }

        public void Find_Missing(int[] testData, int value)
        {
            LinkedList<int> list = new LinkedList<int>();
            foreach (int data in testData)
            {
                list.AddLast(new LinkedListNode<int>(data));
            }

            Assert.IsFalse(list.Contains(value), "Nothing should have been found.");
        }

        public void Find_Found(int[] testData, int value)
        {
            LinkedList<int> list = new LinkedList<int>();
            foreach (int data in testData)
            {
                list.AddLast(new LinkedListNode<int>(data));
            }

            Assert.IsTrue(list.Contains(value), "There should have been a node found");
        }

        public static void Main(string[] args)
        {
            SequenceParser.WarningMessage();

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

            sampleList.Add(-33);
            sampleList.Add(2);
            sampleList.Add(100);
            sampleList.Add(4);

            foreach (var item in sampleList)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine(new string('=', 40));
            Console.WriteLine($"First element : {sampleList.FirstElement.Value}");
            Console.WriteLine($"Last element : {sampleList.LastElement.Value}");
            Console.WriteLine($"Count of all elements added : {sampleList.Count}");
            Console.WriteLine(new string('=', 40));

            var head = sampleList.GetFirstNode();
            Console.WriteLine(head.Value);
            Console.WriteLine(head.NextItem.Value);
            Console.WriteLine(head.NextItem.NextItem.Value);
            Console.WriteLine(head.NextItem.NextItem.NextItem.Value);
            Console.WriteLine(new string('=', 40));

            var head2 = head.GetNextNode();
            Console.WriteLine(head2.Value);

            Console.WriteLine(new string('=', 40));
            var containsCheckOne = sampleList.Contains(-33);
            var containsCheckTwo = sampleList.Contains(-3300);
            Console.WriteLine($"do sample list contains -33 : {containsCheckOne}");
            Console.WriteLine($"do sample list contains -3300 : {containsCheckTwo}");

            sampleList.Remove(-33);
            Console.WriteLine(sampleList.GetFirst());
            Console.WriteLine(sampleList.LastElement.Value);
        }

        public LinkedList<Ele> del_ele(LinkedList<Ele> d_list, LinkedListNode<Ele> d_ele)
        {
            //PexAssume.IsNotNullOrEmpty(d_list);
            //PexAssume.IsNotNull(d_ele);
            if (d_list != null)
            {
                PexAssume.IsFalse(d_list.Contains(null));
                if (d_ele != null)
                {
                    PexAssume.IsTrue(d_list.Contains(d_ele.Value));
                    PexAssume.IsNotNull(d_ele.List);
                    if (d_ele.List != null)
                    {
                        PexAssume.IsTrue(d_ele.List.Equals(d_list));
                    }
                }                
            }

            LinkedList<Ele> result = Program.del_ele(d_list, d_ele);
            return result;
            // TODO: add assertions to method ProgramTest.del_ele(LinkedList`1<Ele>, LinkedListNode`1<Ele>)
        }

 public static void Main()
 {
     // Create LinkedList and test its methods
     ListItem<int> lastElement = new ListItem<int>(5);
     LinkedList<int> linkedList = new LinkedList<int>(lastElement);
     ListItem<int> middleElement = new ListItem<int>(2);
     linkedList.Add(middleElement);
     ListItem<int> firstElement = new ListItem<int>(-3);
     linkedList.Add(firstElement);
     bool contains = linkedList.Contains(firstElement);
     linkedList.Remove(middleElement);
     int index = linkedList.IndexOf(lastElement);
     int count = linkedList.Count();
     ListItem<int> element = linkedList[index];
     bool isSame = lastElement == element;
 }