C# LinkedList.Clear方法代码示例

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

        private void GetTests()
        {
            methods = methods ?? new LinkedList<MethodInfo>();
            methods.Clear();
            status = status ?? new Dictionary<MethodInfo, Status>();
            status.Clear();
            toggleGroup = toggleGroup ?? new Dictionary<string, bool>();

            var bindingFlags = BindingFlags.Public;
            bindingFlags |= BindingFlags.Static;
            bindingFlags |= BindingFlags.DeclaredOnly;

            Type[] typelist = GetTypesInNamespace("Exodrifter.ExpressionParser.Test");
            for (int i = 0; i < typelist.Length; i++) {
                foreach (var method in typelist[i].GetMethods(bindingFlags)) {
                    if (0 == method.GetParameters().Length) {
                        methods.AddLast(method);
                        status.Add(method, Status.UNKNOWN);

                        if (!toggleGroup.ContainsKey(method.DeclaringType.Name)) {
                            toggleGroup[method.DeclaringType.Name] = false;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// a constructor. 
        /// </summary>
        /// <param name="fieldTermStack">FieldTermStack object</param>
        /// <param name="fieldQuery">FieldQuery object</param>
        /// <param name="phraseLimit">maximum size of phraseList</param>
        public FieldPhraseList(FieldTermStack fieldTermStack, FieldQuery fieldQuery, int phraseLimit)
        {
            String field = fieldTermStack.FieldName;

            LinkedList<TermInfo> phraseCandidate = new LinkedList<TermInfo>();
            QueryPhraseMap currMap = null;
            QueryPhraseMap nextMap = null;
            while (!fieldTermStack.IsEmpty() && (phraseList.Count < phraseLimit) )
            {

                phraseCandidate.Clear();

                TermInfo ti = fieldTermStack.Pop();
                currMap = fieldQuery.GetFieldTermMap(field, ti.Text);

                // if not found, discard top TermInfo from stack, then try next element
                if (currMap == null) continue;

                // if found, search the longest phrase
                phraseCandidate.AddLast(ti);
                while (true)
                {
                    ti = fieldTermStack.Pop();
                    nextMap = null;
                    if (ti != null)
                        nextMap = currMap.GetTermMap(ti.Text);
                    if (ti == null || nextMap == null)
                    {
                        if (ti != null)
                            fieldTermStack.Push(ti);
                        if (currMap.IsValidTermOrPhrase(new List<TermInfo>(phraseCandidate)))
                        {
                            AddIfNoOverlap(new WeightedPhraseInfo(phraseCandidate, currMap.Boost, currMap.TermOrPhraseNumber));
                        }
                        else
                        {
                            while (phraseCandidate.Count > 1)
                            {
                                TermInfo last = phraseCandidate.Last.Value;
                                phraseCandidate.RemoveLast();
                                fieldTermStack.Push(last);
                                currMap = fieldQuery.SearchPhrase(field, new List<TermInfo>(phraseCandidate));
                                if (currMap != null)
                                {
                                    AddIfNoOverlap(new WeightedPhraseInfo(phraseCandidate, currMap.Boost, currMap.TermOrPhraseNumber));
                                    break;
                                }
                            }
                        }
                        break;
                    }
                    else
                    {
                        phraseCandidate.AddLast(ti);
                        currMap = nextMap;
                    }
                }
            }
        }

        public RezultatKomanda addMaterijal(string Naslov, string Opis, string DodadenOd, string Slika, string Pateka,String Type)
        {
            RezultatKomanda rezultat = new RezultatKomanda(false);
            try
            {
                parametriKomanda = new LinkedList<SqlParameter>();

                parametriKomanda.Clear();

                //Parametar za @Naslov  = Naslov
                //Input Parametar
                SqlParam = new SqlParameter("@Naslov", SqlDbType.NVarChar);
                SqlParam.Value = Naslov;
                parametriKomanda.AddLast(SqlParam);

                //Parametar za @Opis = Opis
                //Input Parametar
                SqlParam = new SqlParameter("@Opis", SqlDbType.NVarChar);
                SqlParam.Value = Opis;
                parametriKomanda.AddLast(SqlParam);

                //Parametar za @DodadenOd  = DodadenOd
                //Input Parametar
                SqlParam = new SqlParameter("@DodadenOd", SqlDbType.VarChar);
                SqlParam.Value = DodadenOd;
                parametriKomanda.AddLast(SqlParam);

                //Parametar za @Slika  = Slika
                //Input Parametar
                SqlParam = new SqlParameter("@Slika", SqlDbType.NVarChar);
                SqlParam.Value = Slika ;
                parametriKomanda.AddLast(SqlParam);

                //Parametar za @Pateka  = Pateka
                //Input Parametar
                SqlParam = new SqlParameter("@Pateka", SqlDbType.NVarChar);
                SqlParam.Value = Pateka;
                parametriKomanda.AddLast(SqlParam);

                //Parametar za @Type = Type
                //Input Parametar
                SqlParam = new SqlParameter("@Type", SqlDbType.NVarChar);
                SqlParam.Value = Type;
                parametriKomanda.AddLast(SqlParam);

                BazaDB.ExecuteScalar(parametriKomanda.ToArray(), "sp_ZacuvajMaterijal", sqlCn: null);


                rezultat.Rezultat = RezultatKomandaEnum.Uspeh;

                return rezultat;
            }
            catch (Exception ex)
            {
                rezultat.Rezultat = RezultatKomandaEnum.Neuspeh;
                rezultat.Pricina = ex.Message;
                return rezultat;
            }
        }

    // Looks like I ended up with the typical sliding-window deque solution. Here's an example for k = 3:
    // 1 3 2 8 4 7 2, initialize left looking dominators like {3, 2}. These dominate everything to their
    // left until a bigger dominator. Leftmost dominator goes to max value for subarray.
    // [1 3 2] 8 4 7 2, {3, 2}
    // 1 [3 2 8] 4 7 2, {8}, lost 1 but it wasn't a dominator, gained 8 and it dominates everything, kills 3 and 2.
    // 1 3 [2 8 4] 7 2, {8, 4}, lost 3 but wasn't a dominator, gained 4 which dominates til 8.
    // 1 3 2 [8 4 7] 2, {8, 7}, lost 2 but wasn't a dominator, gained 7 which kills 4 and domaintes til 8.
    // 1 3 2 8 [4 7 2], {7, 2}, lost 8 so pop it off, gained 2 which dominates til 7.
    // I say dominate because if you're an element and there's an element in your sliding window to your right
    // that's greater than you (dominating you), you're never going to be the max for any of your remaining subarrays.
    // That dominating element to your right will always be there until you're kicked out of the window.
    // When a big number slides in it can dominate all of the dominators and be the only one left; the existing
    // dominators would be to its left so they'd never be able to be the max for any remaining subarrays.
    // We have to keep track of the dominators to the right of other, larger dominators because those other dominators
    // are going to slide out before the ones to their right, and we need to know where to pick up from. It should be
    // clear the dominators are always sorted, descending, from left to right. Dominators could be thought of recursively
    // as greatest element in subarray, followed by greatest element in subarray to that element's right, etc. O(n)
    // because we add or remove an array element from the dominators at most one time.
    public static int[] Solve(int[] array, int k)
    {
        if (k == array.Length) return new[] { array.Max() };
        if (k == 1) return array;

        // Initializing the dominators for the first subarray. Gotta have the rightmost, then the next to the left that's
        // larger than (or equal to) it, and so on. Equal to because we need the next one after an equal one is popped off.
        var leftLookingDominators = new LinkedList<int>();
        leftLookingDominators.AddFirst(array[k - 1]);

        for (int i = k - 2; i >= 0; --i)
        {
            if (array[i] >= leftLookingDominators.Last.Value)
            {
                leftLookingDominators.AddLast(array[i]);
            }
        }

        // Each iteration we're looking at the next subarray, slid over from the previous. We lose an element during the
        // slide which might've been the leftmost dominator (the leftmost dominator is the only one that can be lost). We
        // gain an element which might start dominating everything, or just some dominators til hitting some dominator to its
        // left that's greater than it, or just itself. Don't have to worry about dominators ever becoming empty, because
        // base case handled above. Even for k = 2, if there's only 1 dominator going in to the next iteration, it must be
        // the rightmost element of the previous subarray, so it's not going to get popped off the end until the next next iteration.
        int subarrayCount = array.Length - k + 1;
        int[] subarrayMaximums = new int[subarrayCount];
        subarrayMaximums[0] = leftLookingDominators.Last.Value;

        for (int i = 1, j = k; i < subarrayCount; ++i, ++j)
        {
            int lostLeftValue = array[i - 1];
            int gainedRightValue = array[j];

            if (lostLeftValue == leftLookingDominators.Last.Value)
            {
                leftLookingDominators.RemoveLast();
            }

            if (gainedRightValue > leftLookingDominators.Last.Value)
            {
                leftLookingDominators.Clear();
                leftLookingDominators.AddFirst(gainedRightValue);
            }
            else
            {
                while (gainedRightValue > leftLookingDominators.First.Value)
                {
                    leftLookingDominators.RemoveFirst();
                }
                leftLookingDominators.AddFirst(gainedRightValue);
            }

            subarrayMaximums[i] = leftLookingDominators.Last.Value;
        }

        return subarrayMaximums;
    }

        public RezultatKomanda addUstanova(string Ime, string Adresa, string WebStrana, int Institucija_ID)
        {
            RezultatKomanda rezultat = new RezultatKomanda(false);
            dsKomanda = null;
            try
            {
                parametriKomanda = new LinkedList<SqlParameter>();

                parametriKomanda.Clear();

                //Parametar za @Ime  = Ime
                //Input Parametar
                SqlParam = new SqlParameter("@Ime", SqlDbType.NVarChar);
                SqlParam.Value = Ime;
                parametriKomanda.AddLast(SqlParam);

                //Parametar za @Adresa = Adresa
                //Input Parametar
                SqlParam = new SqlParameter("@Adresa", SqlDbType.NVarChar);
                SqlParam.Value = Adresa;
                parametriKomanda.AddLast(SqlParam);

                //Parametar za @WebAdresa = WebAdresa
                //Input Parametar
                SqlParam = new SqlParameter("@WebStrana", SqlDbType.NVarChar);
                SqlParam.Value = WebStrana;
                parametriKomanda.AddLast(SqlParam);

                //Parametar za @Institucija_ID  = Institucija_ID
                //Input Parametar
                SqlParam = new SqlParameter("@Institucija_ID", SqlDbType.Int);
                SqlParam.Value = Institucija_ID;
                parametriKomanda.AddLast(SqlParam);

                //Parametar za @Aktiven  = D
                //Input Parametar
                SqlParam = new SqlParameter("@Aktiven", SqlDbType.Char);
                SqlParam.Value = 'D';
                parametriKomanda.AddLast(SqlParam);


                BazaDB.ExecuteScalar(parametriKomanda.ToArray(), "sp_ZacuvajUstanova", sqlCn: null);


                rezultat.Rezultat = RezultatKomandaEnum.Uspeh;

                return rezultat;
            }
            catch (Exception ex)
            {
                rezultat.Rezultat = RezultatKomandaEnum.Neuspeh;
                rezultat.Pricina = ex.Message;
                return rezultat;
            }
        }

        public Boolean TryCalculateFanMotif 
            (IGraph oGraph, BackgroundWorker oBackgroundWorker, out ICollection<Motif> oMotifs)
        {
            Debug.Assert(oGraph != null);

            oMotifs = null;

            LinkedList<Motif> oFanMotifs = new LinkedList<Motif>();
            LinkedList<IVertex> oLeaves = new LinkedList<IVertex>();

            IVertexCollection oVertices = oGraph.Vertices;
            Int32 iVertices = oVertices.Count;
            Int32 iCalculationsSoFar = 0;

            foreach (IVertex oVertex in oVertices)
            {
                if ((iCalculationsSoFar % 100 == 0) &&
                    !ReportProgressAndCheckCancellationPending(iCalculationsSoFar, iVertices, oBackgroundWorker)
                    )
                {
                    return (false);
                }

                ICollection<IVertex> oAdjacentVertices = oVertex.AdjacentVertices;

                if (oAdjacentVertices.Count >= 2)
                {
                    foreach (IVertex oAdjacentVertex in oAdjacentVertices)
                    {
                        if (oAdjacentVertex.AdjacentVertices.Count == 1)
                        {
                            oLeaves.AddLast(oAdjacentVertex);
                        }
                    }

                    if (oLeaves.Count >= 2)
                    {
                        oFanMotifs.AddLast(
                            new FanMotif(oVertex, oLeaves.ToArray()));
                    }

                    oLeaves.Clear();
                }

                iCalculationsSoFar++;
            }

            // Set the ArcScale property on each FanMotif object.

            SetFanMotifArcScale(oFanMotifs);

            oMotifs = oFanMotifs;

            return (true);
        }

        public override void SetPolygons()
        {
            base.SetPolygons();

            LinkedList<float> tempList = new LinkedList<float>();
            foreach ( Polygon poly in filledPolygons ) {
                for ( int i = 2 ; i < poly.Points.Count ; ++i ) {
                    tempList.AddLast( poly.Points[ 0 ].X );
                    tempList.AddLast( poly.Points[ 0 ].Y );
                    tempList.AddLast( 1 );
                    tempList.AddLast( 1 );
                    tempList.AddLast( poly.Colors[ 0 ].X );
                    tempList.AddLast( poly.Colors[ 0 ].Y );
                    tempList.AddLast( poly.Colors[ 0 ].Z );
                    tempList.AddLast( poly.Colors[ 0 ].W );

                    tempList.AddLast( poly.Points[ i - 1 ].X );
                    tempList.AddLast( poly.Points[ i - 1 ].Y );
                    tempList.AddLast( 1 );
                    tempList.AddLast( 1 );
                    tempList.AddLast( poly.Colors[ i - 1 ].X );
                    tempList.AddLast( poly.Colors[ i - 1 ].Y );
                    tempList.AddLast( poly.Colors[ i - 1 ].Z );
                    tempList.AddLast( poly.Colors[ i - 1 ].W );

                    tempList.AddLast( poly.Points[ i ].X );
                    tempList.AddLast( poly.Points[ i ].Y );
                    tempList.AddLast( 1 );
                    tempList.AddLast( 1 );
                    tempList.AddLast( poly.Colors[ i ].X );
                    tempList.AddLast( poly.Colors[ i ].Y );
                    tempList.AddLast( poly.Colors[ i ].Z );
                    tempList.AddLast( poly.Colors[ i ].W );
                }
            }
            fillArray = tempList.ToArray();
            tempList.Clear();

            foreach ( Polygon poly in outlinePolygons ) {
                for ( int i = 0 ; i < poly.Points.Count ; ++i ) {
                    tempList.AddLast( poly.Points[ i ].X );
                    tempList.AddLast( poly.Points[ i ].Y );
                    tempList.AddLast( 1 );
                    tempList.AddLast( 1 );
                    tempList.AddLast( poly.Colors[ i ].X );
                    tempList.AddLast( poly.Colors[ i ].Y );
                    tempList.AddLast( poly.Colors[ i ].Z );
                    tempList.AddLast( poly.Colors[ i ].W );
                }
            }
            outlineArray = tempList.ToArray();

            GenerateBuffers();
        }

        public static LinkedList<String> NetworkToConnections(double[,] matrix, bool[] rev, String[] metabolite_names = null, String[] reaction_names = null)
        {
            if (metabolite_names == null)
            {
                metabolite_names = new String[matrix.Length / rev.Length];
                for (int i = 0; i < matrix.Length / rev.Length; ++i)
                    metabolite_names[i] = "M_" + (i + 1);
            }

            if (reaction_names == null)
            {
                reaction_names = new String[rev.Length];
                for (int i = 0; i < rev.Length; ++i)
                    reaction_names[i] = "R_" + (i + 1);
            }

            LinkedList<String> res = new LinkedList<string>();

            res.AddFirst("digraph Network {");
            res.AddLast("\tnodesep=0.7;");
            res.AddLast("\trankdir=LR;");

            int n = rev.Length, m = matrix.Length / n;

            for (int i = 0; i < m; ++i)
                res.AddLast(String.Format("\t{0}[label=\"{1}\"];", i + 1, metabolite_names[i]));

            LinkedList<int> produced = new LinkedList<int>(), consumed = new LinkedList<int>();
            for (int j = 0; j < n; ++j)
            {
                produced.Clear();
                consumed.Clear();

                for (int i = 0; i < m; ++i)
                {
                    if (matrix[i, j] < 0)
                        consumed.AddLast(i);
                    if (matrix[i, j] > 0)
                        produced.AddLast(i);
                }

                foreach (int m1 in produced)
                    foreach (int m2 in consumed)
                        if (rev[j])
                            res.AddLast(String.Format("{0}->{1}[dir=both]", m1 + 1, m2 + 1));
                        else
                            res.AddLast(String.Format("{0}->{1}", m1 + 1, m2 + 1));
            }

            res.AddLast("}");

            return res;
        }

        private List<FriendshipLink> CreateFriendships(List<Person> people)
        {
            List<FriendshipLink> friendships = new List<FriendshipLink>();
            Person p1, p2;

            int totalCount  = people.Count;
            int missing;

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

            for (int i = 0; i < totalCount; i++)
            {
                p1 = people[i];
                missing = Mathf.Clamp((int) Utils.GetRandomValue(avgConnections, avgConnections*1.2f, 3), 1, 100) - p1.FriendCount;

                if (missing <= 0)
                    continue;

                list.Clear();

                for (int j = i+1; j < totalCount; j++)
                {
                    p2 = people[j];
                    if (p2.FriendCount < avgConnections * 1.2)
                        list.AddLast(new DistanceNode(p1, p2));
                }

                while (list.Count > 0 && missing > 0)
                {
                    DistanceNode smallest = list.First.Value;

                    //Lerp between probability and 1, depending on how many are left and how many are missing

                    float prob = Mathf.Lerp(probability, 1, missing / list.Count);
                    foreach (DistanceNode node in list)
                    {
                        if (node.dist < smallest.dist)
                            smallest = node;
                    }
                    //TODO Code/use a heap instead

                    if (Random.value < prob)
                    {
                        friendships.Add(CreateFriendship(p1, smallest.p));
                        missing--;
                    }
                    list.Remove(smallest);
                }
            }

            return friendships;
        }

 public void ItShouldBeAbleToClear()
 {
     LinkedList<object> list = new LinkedList<object>();
     list.Add('a');
     list.Add('b');
     list.Add('c');
     list.Add('d');
     list.Add('e');
     list.Clear();
     object expected = 0;
     object actual = list.Count;
     Assert.AreEqual(expected, actual);
 }

        public void Clear_Empty()
        {
            LinkedList<int> list = new LinkedList<int>();

            Assert.IsNull(list.Head);
            Assert.IsNull(list.Tail);
            Assert.AreEqual(0, list.Count);

            list.Clear();

            Assert.IsNull(list.Head);
            Assert.IsNull(list.Tail);
            Assert.AreEqual(0, list.Count);
        }

 public void buttonRemoveSTL_Click(object sender, EventArgs e)
 {
     //STL stl = (STL)listSTLObjects.SelectedItem;
     //if (stl == null) return;
     LinkedList<STL> list = new LinkedList<STL>();
     foreach (STL stl in listSTLObjects.SelectedItems)
         list.AddLast(stl);
     foreach (STL stl in list)
     {
         cont.models.Remove(stl);
         listSTLObjects.Items.Remove(stl);
     }
     list.Clear();
     cont.UpdateChanges();
 }

        public virtual SetOfSentences doProcess(SetOfSentences sos)
        {
            List< Eojeol [] > eojeolSetArray = sos.getEojeolSetArray();

            LinkedList < Eojeol > eojeolArray = new LinkedList < Eojeol >();

            for (int i = 0; i < eojeolSetArray.Count; i++)
            {
                Eojeol[] eojeolSet = eojeolSetArray[i];

                eojeolArray.Clear();
                for (int j = 0; j < eojeolSet.Length; j++)
                {
                    eojeolArray.AddLast(eojeolSet[j]);
                }

                int unkCount = 0;
                for (int j = 0; j < eojeolArray.Count; j++)
                {
                    Eojeol eojeol = eojeolArray.Get_Renamed(j);
                    System.String[] tags = eojeol.Tags;
                    System.String[] morphemes = eojeol.Morphemes;

                    for (int k = 0; k < tags.Length; k++)
                    {
                        if (tags[k].Equals("unk"))
                        {
                            tags[k] = "nqq";

                            Eojeol newEojeol = new Eojeol(morphemes.Clone() as string[], tags.Clone() as string[]);
                            eojeolArray.AddLast(newEojeol);

                            tags[k] = "ncn";
                            unkCount++;
                        }
                    }
                }

                if (unkCount > 0)
                {
                    eojeolSetArray[i] = eojeolArray.ToArray(eojeolSet);
                }
            }

            return sos;
        }

        private static void Calcular(int[] l, int M, int lim, int i, LinkedList<int> r,
                                     ref int max, LinkedList<int> aux, int auxv, int auxt) {
            if(i < M) {
                if(auxt + l[i] <= lim) {
                    aux.AddLast(i);
                    Calcular(l, M, lim, i + 1, r, ref max, aux, auxv + 1, auxt + l[i]);
                    aux.RemoveLast();

                }
                Calcular(l, M, lim, i + 1, r, ref max, aux, auxv, auxt);
            } else if(auxv > max) {
                max = auxv;
                r.Clear();
                foreach(int n in aux) {
                    r.AddLast(n);
                }
            }
        }