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")); }
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) { 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)); }
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 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); }
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; } }
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() { LinkedList<int> ints = new LinkedList<int>(4); ints.AddFirst(3); ints.AddLast(5); ints.AddBefore(1, 1); ints.AddAfter(2, 0); ints.RemoveFirst(); ints.RemoveLast(); Console.WriteLine(ints.GetItemAt(0).Value); }
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); }
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 void TestAddAfterLast() { var expected = new int[3] { 0, 1, 2 }; var list = new LinkedList<int>(); list.AddLast(0); list.AddLast(1); var node = list.AddAfter(list.Last, 2); Verify(expected, list); Assert.AreSame(list.Last, node); }
static void Main() { LinkedList<int> numbers = new LinkedList<int>(); for (int i = 0; i < 20; i++) { numbers.AddLast(i); } numbers.AddFirst(100); numbers.AddFirst(50); numbers.AddAfter(numbers.FirstElement, -50); foreach (var number in numbers) { System.Console.WriteLine(number); } }
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 static void Main(string[] args) { LinkedList<object> linkedList = new LinkedList<object> (); linkedList.AddFirst (1); linkedList.AddAfter (linkedList.Find(1),2); linkedList.AddLast ("Bye"); linkedList.AddBefore (linkedList.Find(1),3.55); Console.WriteLine ("The Elements are: "); PrintElements (linkedList); Console.WriteLine ("No. of items in list: {0}",linkedList.Count); linkedList.Remove (1); Console.WriteLine ("The Elements after removing are: "); PrintElements (linkedList); Console.WriteLine ("No. of items in list after removing: {0}",linkedList.Count); }
private void AddToList(LinkedList<Pair> list, Pair pair) { if(list.Count == 0) { list.AddFirst(pair); return; } LinkedListNode<Pair> node = list.Last; while(node != null) { if(String.CompareOrdinal(pair.Key, node.Value.Key) >= 0) { list.AddAfter(node, pair); return; } node = node.Previous; } list.AddFirst(pair); }
static void Main() { LinkedList<int> myLinkedList = new LinkedList<int>(); myLinkedList.AddFirst(1); myLinkedList.AddLast(5000); myLinkedList.AddFirst(10); myLinkedList.AddLast(500); myLinkedList.AddAfter(myLinkedList.FirstElement.NextItem, 100000000); myLinkedList.AddBefore(myLinkedList.FirstElement.NextItem, 500000000); myLinkedList.PrintList(); Console.WriteLine("the count={0}",myLinkedList.Count); Console.WriteLine(); Console.WriteLine("after removing of some elements"); myLinkedList.RemoveFirst(); myLinkedList.RemoveLast(); myLinkedList.PrintList(); Console.WriteLine("the count={0}",myLinkedList.Count); }
private void Frm_Main_Load(object sender, EventArgs e) { //构建泛型双向链表 LinkedList<int> ints = new LinkedList<int>(); ints.AddFirst(0);//添加第一个元素 for (int i = 1; i < 10; i++) { ints.AddAfter(ints.Find(i - 1), i);//向泛型双向链表中添加元素 } //LINQ过滤、排序泛型双向链表 var query = from item in ints where item > 0 && item < 9 orderby item descending select item; //显示查询结果 foreach (var item in query) { label1.Text += item.ToString() + "<="; } }
static void Main(string[] args) { var presidents = new LinkedList<string>(); presidents.AddLast("JFK"); presidents.AddLast("Lyndon B. Johnson"); presidents.AddLast("Richard Nixon"); presidents.AddLast("Jimmy Carter"); presidents.RemoveFirst(); LinkedListNode<string> kennedy = presidents.AddFirst("John F. Kennedy"); // works but inefficient LinkedListNode<string> nixon = presidents.Find("Richard Nixon"); presidents.AddAfter(nixon, "Gerald Ford"); foreach (string president in presidents) { Console.WriteLine(president); } }
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(string[] args) { LinkedList<string> list = new LinkedList<string>(); list.AddFirst(".AddFirst() adds at the head."); list.AddLast(".AddLast() adds at the tail."); LinkedListNode<string> head = list.Find(".AddFirst() adds at the head."); list.AddAfter(head, ".AddAfter() adds after a specified node."); LinkedListNode<string> tail = list.Find(".AddLast() adds at the tail."); list.AddBefore(tail, "Betcha can't guess what .AddBefore() does."); System.Console.WriteLine("Forward:"); foreach (string nodeValue in list) { System.Console.WriteLine(nodeValue); } System.Console.WriteLine("\nBackward:"); LinkedListNode<string> current = tail; while (current != null) { System.Console.WriteLine(current.Value); current = current.Previous; } }
public int NthSuperUglyNumber(int n, int[] primes) { LinkedList<long> list = new LinkedList<long>(); list.AddFirst(1); LinkedListNode<long>[] hints = new LinkedListNode<long>[primes.Length]; var minNode = list.First; long min = 0; int size = n; while (n-- > 0) { min = minNode.Value; for (int i = 0; i < primes.Length; i++) { var current = hints[i]; if (current == null) current = list.First; long p = primes[i]; while (current.Next != null && current.Next.Value <= p * min) { current = current.Next; } hints[i] = current; if (current.Value == p * min) continue; if (list.Count > size && list.Last.Value < p * min) { break; } list.AddAfter(current, p * min); } minNode = minNode.Next; } return (int)min; }
static void Main(string[] args) { var list = new LinkedList<int>(); list.AddFirst(2); list.AddFirst(1); var node = list.Find(2); list.AddAfter(node,3); foreach (var item in list) { Console.WriteLine(item); } list.AddBefore(node,7); Console.WriteLine("----------Adding Before 2-----------------"); foreach (var i in list) { Console.WriteLine(i); } }
static void Main(string[] args) { var presidents = new LinkedList<string>(); // Add items to the presidenst linked list. presidents.AddLast("JFK"); presidents.AddLast("Lyndon B Johnson"); presidents.AddLast("Richard Nixon"); presidents.AddLast("Jimmy Carter"); presidents.RemoveFirst(); presidents.AddFirst("John F. Kennedy"); // For creating a linked list node directly LinkedListNode<string> kennedy = presidents.AddFirst("John F. Kennedy"); // To put a value before or after a value, the value has to be a LinkedListNode. LinkedListNode<string> nixon = presidents.Find("Richard Nixon"); presidents.AddAfter(nixon, "Gerald Ford"); foreach (string president in presidents) { Console.WriteLine(president); } }
protected async Task AllocateBlocks(IProgress <string> ProgressStatus, IProgress <int> ProgressPercentage, uint startingID = 0) { uint ID = startingID; ProgressStatus.Report("First pass hash caching...\r\n"); await GenerateHashes(Files, ProgressPercentage); ProgressStatus.Report("Second pass writing...\r\n"); ProgressStatus.Report("Allocating chunks...\r\n"); ProgressPercentage.Report(0); //Create a LST chunk var lstChunk = new QueuedChunk(new List <ISubfile>(), ID++, DefaultCompression, 23); //bunch duplicate files together //going to assume OrderBy is a stable sort LinkedList <ISubfile> linkedSubfileList = new LinkedList <ISubfile>( Files .OrderBy(x => x.Name) //order by file name first .OrderBy(x => Path.GetExtension(x.Name) ?? x.Name)); //then we order by file type, preserving duplicate file order Dictionary <Md5Hash, LinkedListNode <ISubfile> > HashList = new Dictionary <Md5Hash, LinkedListNode <ISubfile> >(); var node = linkedSubfileList.First; while (node?.Next != null) { ISubfile file = node.Value; Md5Hash hash = file.Source.Md5; if (HashList.ContainsKey(hash)) { var nextNode = node.Next; var originalNode = HashList[hash]; linkedSubfileList.Remove(node); linkedSubfileList.AddAfter(originalNode, file); node = nextNode; } else { HashList.Add(hash, node); node = node.Next; } } var fileList = new Queue <ISubfile>(linkedSubfileList); ulong accumulatedSize = 0; var currentChunk = new QueuedChunk(new List <ISubfile>(), ID++, DefaultCompression, 23); Md5Hash?previousHash = null; while (fileList.Count > 0) { ISubfile file = fileList.Dequeue(); if (previousHash.HasValue && previousHash.Value == file.Source.Md5) { currentChunk.Subfiles.Add(file); continue; } previousHash = file.Source.Md5; accumulatedSize += file.Source.Size; if (file.Name.EndsWith(".lst")) { lstChunk.Subfiles.Add(file); continue; } if (file.Type == ArchiveFileType.WaveAudio || file.Type == ArchiveFileType.OpusAudio) { //non-compressable data, assign it and any duplicates to a new chunk List <ISubfile> opusFiles = new List <ISubfile>(); opusFiles.Add(file); byte[] md5Template = file.Source.Md5; //keep peeking and dequeuing until we find another file while (true) { if (fileList.Count == 0) { break; //no more files, need to stop } ISubfile next = fileList.Peek(); if (!Utility.CompareBytes( md5Template, next.Source.Md5)) { //we've stopped finding duplicates break; } opusFiles.Add(fileList.Dequeue()); } var tempChunk = new QueuedChunk(opusFiles, ID++, ArchiveChunkCompression.Uncompressed, 0); QueuedChunks.Add(tempChunk); continue; } if (file.Size + accumulatedSize > ChunkSizeLimit) { //cut off the chunk here QueuedChunks.Add(currentChunk); accumulatedSize = 0; //create a new chunk currentChunk = new QueuedChunk(new List <ISubfile>(), ID++, DefaultCompression, 23); } currentChunk.Subfiles.Add(file); } if (currentChunk.Subfiles.Count > 0) { QueuedChunks.Add(currentChunk); } if (lstChunk.Subfiles.Count > 0) { QueuedChunks.Add(lstChunk); } QueuedChunks.CompleteAdding(); }
}//________________________________________________________________________---------------------------- public ColaElement AgregarElementoTabAreas(TableLayoutPanel t, TareaEntity tarea) { //foreach (Particion a in llPart) //{ // Console.WriteLine(a.num + "|" + a.tam + "|" + a.dir + "|" + a.proceso + "|" + a.estado); //} //Console.WriteLine("\n----------------------------------\n"); if (filaLibreAreas.Count != 0 && encontrado == 0) { // Revisa si hay espacios disponibles si no, inserta uno nuevo Area prueba = new Area(); foreach (int x in filaLibreAreas) { prueba = null; for (var node = llArea.First; node != null; node = node.Next) { if (node.Value.num == x) { prueba = node.Value; break; } } if (prueba.tam == tarea.GetTamañoTarea()) { llArea.AddAfter(llArea.Find(prueba), new LinkedListNode <Area>(new Area(x, tarea.GetTamañoTarea(), prueba.dir, "A", tarea))); llArea.Remove(prueba); ActualizarTabla(t); filaLibreAreas.Remove(x); encontrado = 0; break; } else if (prueba.tam > tarea.GetTamañoTarea()) { LinkedListNode <Area> p = llArea.Find(prueba); llArea.AddBefore(p, new LinkedListNode <Area>(new Area(x, tarea.GetTamañoTarea(), prueba.dir, "A", tarea))); p.Value.dir = p.Previous.Value.tam + prueba.dir; p.Value.tam = prueba.tam - p.Previous.Value.tam; ActualizarTabla(t); filaLibreAreas.Remove(x); encontrado = 0; filaLibreAreas.Add(x + 1); numArea++; break; } else { encontrado = 1; AgregarElementoTabAreas(t, tarea); } } } else if (llArea.First == null) { llArea.AddFirst(new Area(numArea, tarea.GetTamañoTarea(), 0, "A", tarea)); numArea++; AñadirUltimoATabla(t); //DejarVacioElementoTabAreas(t, 0); PARA PRUEBA UNITARIA } else { if (llArea.Last.Value.dir + llArea.Last.Value.tam + tarea.GetTamañoTarea() > espacioDisponible) { tarea.SetPrioridad(tarea.GetPrioridad() + 1); return(new ColaElement(tarea)); } llArea.AddLast(new Area(numArea, tarea.GetTamañoTarea(), llArea.Last.Value.dir + llArea.Last.Value.tam, "A", tarea)); numArea++; AñadirUltimoATabla(t); } encontrado = 0; tarea.SetPrioridad(0);// tarea fue añadida a Tabla de Areas Disp. return(new ColaElement(tarea)); }
public void Fitting(Func <CompressedTimeSpan, float> originalCurve, CompressedTimeSpan stepSize, float maxErrorThreshold) { // Some info: http://wscg.zcu.cz/wscg2008/Papers_2008/full/A23-full.pdf // Compression of Temporal Video Data by Catmull-Rom Spline and Quadratic Bézier Curve Fitting // And: http://bitsquid.blogspot.jp/2009/11/bitsquid-low-level-animation-system.html // Only one or zero keys: no need to do anything. if (KeyFrames.Count <= 1) { return; } var keyFrames = new LinkedList <KeyFrameData <float> >(this.KeyFrames); var evaluator = new Evaluator(keyFrames); // Compute initial errors (using Least Square Equation) var errors = new LinkedList <ErrorNode>(); //var errors = new List<float>(); var errorQueue = new PriorityQueue <LinkedListNode <ErrorNode> >(new ErrorComparer()); foreach (var keyFrame in keyFrames.EnumerateNodes()) { if (keyFrame.Next == null) { break; } var error = EvaluateError(originalCurve, evaluator, stepSize, keyFrame.Value, keyFrame.Next.Value); var errorNode = errors.AddLast(new ErrorNode(keyFrame, error.Key, error.Value)); errorQueue.Enqueue(errorNode); } //for (int keyFrame = 0; keyFrame < KeyFrames.Count - 1; ++keyFrame) //{ // //errors.Add(EvaluateError(originalCurve, evaluator, stepSize, keyFrame)); // var errorNode = errors.AddLast(new ErrorNode(EvaluateError(originalCurve, evaluator, stepSize, keyFrame))); // errorQueue.Enqueue(errorNode); //} while (true) { // Already reached enough subdivisions var highestError = errorQueue.Dequeue(); if (highestError.Value.Error <= maxErrorThreshold) { break; } //// Find segment to optimize //var biggestErrorIndex = 0; //for (int keyFrame = 1; keyFrame < KeyFrames.Count - 1; ++keyFrame) //{ // if (errors[keyFrame] > errors[biggestErrorIndex]) // biggestErrorIndex = keyFrame; //} //// Already reached enough subdivisions //if (errors[biggestErrorIndex] <= maxErrorThreshold) // break; // Create new key (use middle point, but better heuristic might improve situation -- like point with biggest error) //var middleTime = (start.Value.Time + end.Value.Time) / 2; var middleTime = highestError.Value.BiggestDeltaTime; //KeyFrames.Insert(biggestErrorIndex + 1, new KeyFrameData<float> { Time = middleTime, Value = originalCurve(middleTime) }); var newKeyFrame = keyFrames.AddAfter(highestError.Value.KeyFrame, new KeyFrameData <float> { Time = middleTime, Value = originalCurve(middleTime) }); //errors.Insert(biggestErrorIndex + 1, 0.0f); var newError = errors.AddAfter(highestError, new ErrorNode(newKeyFrame, CompressedTimeSpan.Zero, 0.0f)); var highestErrorLastUpdate = newError; if (highestErrorLastUpdate.Next != null) { highestErrorLastUpdate = highestErrorLastUpdate.Next; } // Invalidate evaluator (data changed) evaluator.InvalidateTime(); // Update errors for (var error = highestError.Previous ?? highestError; error != null; error = error.Next) { if (error != highestError && error != newError) { errorQueue.Remove(error); } var errorInfo = EvaluateError(originalCurve, evaluator, stepSize, error.Value.KeyFrame.Value, error.Value.KeyFrame.Next.Value); error.Value.BiggestDeltaTime = errorInfo.Key; error.Value.Error = errorInfo.Value; errorQueue.Enqueue(error); if (error == highestErrorLastUpdate) { break; } } } KeyFrames = new List <KeyFrameData <float> >(keyFrames); }
private static ICollection BuildResult(List <Entry> map) { LinkedList <IAdaptable> result = new LinkedList <IAdaptable>(); LinkedListNode <IAdaptable> firstzone = null; LinkedListNode <IAdaptable> lastzone = null; foreach (Entry e in map) { if (e.dependency == null) { //依存物なしのばあい、first-dontcare-lastの各ゾーン順で並ぶ。各ゾーン内は元の入力順を保持 //designationなしはDontCareに等しい if (e.designation == null || e.designation.DesignationPosition == PositionType.DontCare) { if (lastzone == null) { result.AddLast(e.content); } else { result.AddBefore(lastzone, e.content); } } else if (e.designation.DesignationPosition == PositionType.First) { if (firstzone == null) { firstzone = result.AddFirst(e.content); } else { firstzone = result.AddAfter(firstzone, e.content); } } else if (e.designation.DesignationPosition == PositionType.Last) { if (lastzone == null) { lastzone = result.AddLast(e.content); } else { lastzone = result.AddBefore(lastzone, e.content); } } } else //依存物あり { LinkedListNode <IAdaptable> n = result.Find(e.dependency.content); Debug.Assert(n != null); Debug.Assert(e.designation.DesignationPosition != PositionType.DontCare); if (e.designation.DesignationPosition == PositionType.NextTo) { result.AddAfter(n, e.content); } else { result.AddBefore(n, e.content); } } } return(result); }
static void Main(string[] args) { // instancier notre liste chainée avec les entiers 5, 10 et 4. int[] mesEntiers = { 5, 10, 4 }; LinkedList <int> maListeEntiers = new LinkedList <int>(mesEntiers); foreach (int item in maListeEntiers) { Console.WriteLine(item); } // afficher les éléments de la liste chainée en utilisant la propriété qui accède au premier élément // afficher les éléments de la liste chainée en utilisant la propriété qui accède à un élément par son indice for (int i = 0; i < maListeEntiers.Count; i++) { Console.WriteLine(maListeEntiers.ElementAt(i)); } Console.WriteLine("Insertion de deux éléments"); // inserer 99 à la première position maListeEntiers.AddFirst(99); // inserer 33 à la seconde position maListeEntiers.AddAfter(maListeEntiers.Find(99), 33); // inserer 30 à la seconde position maListeEntiers.AddAfter(maListeEntiers.Find(99), 30); // afficher tout for (int i = 0; i < maListeEntiers.Count; i++) { Console.WriteLine(maListeEntiers.ElementAt(i)); } Console.WriteLine("----------------------------------Utilisation de ma propre liste chainée--------------------------------------------"); ListeChainee <int> listeChainee = new ListeChainee <int>(); listeChainee.Ajouter(5); listeChainee.Ajouter(10); listeChainee.Ajouter(4); Console.WriteLine("listeChainee.Premier.Valeur : " + listeChainee.Premier.Valeur); Console.WriteLine("listeChainee.Premier.Suivant.Valeur : " + listeChainee.Premier.Suivant.Valeur); Console.WriteLine("listeChainee.Premier.Suivant.Suivant.Valeur : " + listeChainee.Premier.Suivant.Suivant.Valeur); Console.WriteLine("****************************************"); Console.WriteLine(listeChainee.ObtenirElement(0).Valeur); Console.WriteLine(listeChainee.ObtenirElement(1).Valeur); Console.WriteLine(listeChainee.ObtenirElement(2).Valeur); Console.WriteLine("*************"); listeChainee.Inserer(99, 0); listeChainee.Inserer(33, 2); listeChainee.Inserer(30, 2); Console.WriteLine(listeChainee.ObtenirElement(0).Valeur); Console.WriteLine(listeChainee.ObtenirElement(1).Valeur); Console.WriteLine(listeChainee.ObtenirElement(2).Valeur); Console.WriteLine(listeChainee.ObtenirElement(3).Valeur); Console.WriteLine(listeChainee.ObtenirElement(4).Valeur); Console.WriteLine(listeChainee.ObtenirElement(5).Valeur); /* * ----------------------------------Utilisation de ma propre liste chainée-------- * ------------------------------------ * listeChainee.Premier.Valeur : 5 * listeChainee.Premier.Suivant.Valeur : 10 * listeChainee.Premier.Suivant.Suivant.Valeur : 4 **************************************** * 5 * 5 * 10 ************* *************99 *************99 *************30 *************33 *************5 *************10 * */ Console.WriteLine("Fin du test, tapez sur une touche pour sortir"); Console.ReadKey(); }
// Creates a linked list of all vertices in the polygon, with the hole vertices joined to the hull at optimal points. LinkedList <Vertex> GenerateVertexList(Polygon polygon) { LinkedList <Vertex> vertexList = new LinkedList <Vertex>(); LinkedListNode <Vertex> currentNode = null; // Add all hull points to the linked list for (int i = 0; i < polygon.numHullPoints; i++) { int prevPointIndex = (i - 1 + polygon.numHullPoints) % polygon.numHullPoints; int nextPointIndex = (i + 1) % polygon.numHullPoints; bool vertexIsConvex = IsConvex(polygon.points[prevPointIndex], polygon.points[i], polygon.points[nextPointIndex]); Vertex currentHullVertex = new Vertex(polygon.points[i], i, vertexIsConvex); if (currentNode == null) { currentNode = vertexList.AddFirst(currentHullVertex); } else { currentNode = vertexList.AddAfter(currentNode, currentHullVertex); } } // Process holes: List <HoleData> sortedHoleData = new List <HoleData>(); for (int holeIndex = 0; holeIndex < polygon.numHoles; holeIndex++) { // Find index of rightmost point in hole. This 'bridge' point is where the hole will be connected to the hull. Vector2 holeBridgePoint = new Vector2(float.MinValue, 0); int holeBridgeIndex = 0; for (int i = 0; i < polygon.numPointsPerHole[holeIndex]; i++) { if (polygon.GetHolePoint(i, holeIndex).x > holeBridgePoint.x) { holeBridgePoint = polygon.GetHolePoint(i, holeIndex); holeBridgeIndex = i; } } sortedHoleData.Add(new HoleData(holeIndex, holeBridgeIndex, holeBridgePoint)); } // Sort hole data so that holes furthest to the right are first sortedHoleData.Sort((x, y) => (x.bridgePoint.x > y.bridgePoint.x) ? -1 : 1); foreach (HoleData holeData in sortedHoleData) { // Find first edge which intersects with rightwards ray originating at the hole bridge point. Vector2 rayIntersectPoint = new Vector2(float.MaxValue, holeData.bridgePoint.y); List <LinkedListNode <Vertex> > hullNodesPotentiallyInBridgeTriangle = new List <LinkedListNode <Vertex> >(); LinkedListNode <Vertex> initialBridgeNodeOnHull = null; currentNode = vertexList.First; while (currentNode != null) { LinkedListNode <Vertex> nextNode = (currentNode.Next == null) ? vertexList.First : currentNode.Next; Vector2 p0 = currentNode.Value.position; Vector2 p1 = nextNode.Value.position; // at least one point must be to right of holeData.bridgePoint for intersection with ray to be possible if (p0.x > holeData.bridgePoint.x || p1.x > holeData.bridgePoint.x) { // one point is above, one point is below if (p0.y > holeData.bridgePoint.y != p1.y > holeData.bridgePoint.y) { float rayIntersectX = p1.x; // only true if line p0,p1 is vertical if (!Mathf.Approximately(p0.x, p1.x)) { float intersectY = holeData.bridgePoint.y; float gradient = (p0.y - p1.y) / (p0.x - p1.x); float c = p1.y - gradient * p1.x; rayIntersectX = (intersectY - c) / gradient; } // intersection must be to right of bridge point if (rayIntersectX > holeData.bridgePoint.x) { LinkedListNode <Vertex> potentialNewBridgeNode = (p0.x > p1.x) ? currentNode : nextNode; // if two intersections occur at same x position this means is duplicate edge // duplicate edges occur where a hole has been joined to the outer polygon bool isDuplicateEdge = Mathf.Approximately(rayIntersectX, rayIntersectPoint.x); // connect to duplicate edge (the one that leads away from the other, already connected hole, and back to the original hull) if the // current hole's bridge point is higher up than the bridge point of the other hole (so that the new bridge connection doesn't intersect). bool connectToThisDuplicateEdge = holeData.bridgePoint.y > potentialNewBridgeNode.Previous.Value.position.y; if (!isDuplicateEdge || connectToThisDuplicateEdge) { // if this is the closest ray intersection thus far, set bridge hull node to point in line having greater x pos (since def to right of hole). if (rayIntersectX < rayIntersectPoint.x || isDuplicateEdge) { rayIntersectPoint.x = rayIntersectX; initialBridgeNodeOnHull = potentialNewBridgeNode; } } } } } // Determine if current node might lie inside the triangle formed by holeBridgePoint, rayIntersection, and bridgeNodeOnHull // We only need consider those which are reflex, since only these will be candidates for visibility from holeBridgePoint. // A list of these nodes is kept so that in next step it is not necessary to iterate over all nodes again. if (currentNode != initialBridgeNodeOnHull) { if (!currentNode.Value.isConvex && p0.x > holeData.bridgePoint.x) { hullNodesPotentiallyInBridgeTriangle.Add(currentNode); } } currentNode = currentNode.Next; } // Check triangle formed by hullBridgePoint, rayIntersection, and bridgeNodeOnHull. // If this triangle contains any points, those points compete to become new bridgeNodeOnHull LinkedListNode <Vertex> validBridgeNodeOnHull = initialBridgeNodeOnHull; foreach (LinkedListNode <Vertex> nodePotentiallyInTriangle in hullNodesPotentiallyInBridgeTriangle) { if (nodePotentiallyInTriangle.Value.index == initialBridgeNodeOnHull.Value.index) { continue; } // if there is a point inside triangle, this invalidates the current bridge node on hull. if (Maths2D.PointInTriangle(holeData.bridgePoint, rayIntersectPoint, initialBridgeNodeOnHull.Value.position, nodePotentiallyInTriangle.Value.position)) { // Duplicate points occur at hole and hull bridge points. bool isDuplicatePoint = validBridgeNodeOnHull.Value.position == nodePotentiallyInTriangle.Value.position; // if multiple nodes inside triangle, we want to choose the one with smallest angle from holeBridgeNode. // if is a duplicate point, then use the one occurring later in the list float currentDstFromHoleBridgeY = Mathf.Abs(holeData.bridgePoint.y - validBridgeNodeOnHull.Value.position.y); float pointInTriDstFromHoleBridgeY = Mathf.Abs(holeData.bridgePoint.y - nodePotentiallyInTriangle.Value.position.y); if (pointInTriDstFromHoleBridgeY < currentDstFromHoleBridgeY || isDuplicatePoint) { validBridgeNodeOnHull = nodePotentiallyInTriangle; } } } // Insert hole points (starting at holeBridgeNode) into vertex list at validBridgeNodeOnHull currentNode = validBridgeNodeOnHull; for (int i = holeData.bridgeIndex; i <= polygon.numPointsPerHole[holeData.holeIndex] + holeData.bridgeIndex; i++) { int previousIndex = currentNode.Value.index; int currentIndex = polygon.IndexOfPointInHole(i % polygon.numPointsPerHole[holeData.holeIndex], holeData.holeIndex); int nextIndex = polygon.IndexOfPointInHole((i + 1) % polygon.numPointsPerHole[holeData.holeIndex], holeData.holeIndex); if (i == polygon.numPointsPerHole[holeData.holeIndex] + holeData.bridgeIndex) // have come back to starting point { nextIndex = validBridgeNodeOnHull.Value.index; // next point is back to the point on the hull } bool vertexIsConvex = IsConvex(polygon.points[previousIndex], polygon.points[currentIndex], polygon.points[nextIndex]); Vertex holeVertex = new Vertex(polygon.points[currentIndex], currentIndex, vertexIsConvex); currentNode = vertexList.AddAfter(currentNode, holeVertex); } // Add duplicate hull bridge vert now that we've come all the way around. Also set its concavity Vector2 nextVertexPos = (currentNode.Next == null) ? vertexList.First.Value.position : currentNode.Next.Value.position; bool isConvex = IsConvex(holeData.bridgePoint, validBridgeNodeOnHull.Value.position, nextVertexPos); Vertex repeatStartHullVert = new Vertex(validBridgeNodeOnHull.Value.position, validBridgeNodeOnHull.Value.index, isConvex); vertexList.AddAfter(currentNode, repeatStartHullVert); //Set concavity of initial hull bridge vert, since it may have changed now that it leads to hole vert LinkedListNode <Vertex> nodeBeforeStartBridgeNodeOnHull = (validBridgeNodeOnHull.Previous == null) ? vertexList.Last : validBridgeNodeOnHull.Previous; LinkedListNode <Vertex> nodeAfterStartBridgeNodeOnHull = (validBridgeNodeOnHull.Next == null) ? vertexList.First : validBridgeNodeOnHull.Next; validBridgeNodeOnHull.Value.isConvex = IsConvex(nodeBeforeStartBridgeNodeOnHull.Value.position, validBridgeNodeOnHull.Value.position, nodeAfterStartBridgeNodeOnHull.Value.position); } return(vertexList); }
/// <summary> /// use the IComparer interface of an item to insert that item into the /// linked list in an ordered sequence. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="List"></param> /// <param name="InsertItem"></param> /// <param name="CurrentNode"></param> /// <returns></returns> public static LinkedListNode <T> OrderedListInsert <T>( this LinkedList <T> List, T InsertItem, LinkedListNode <T> CurrentNode) where T : IComparer <T> { LinkedListNode <T> insertedNode = null; LinkedListNode <T> baseNode = null; // start the search for the ordered insert position at the CurrentNode. var startNode = CurrentNode; if (startNode == null) { startNode = List.First; } // search forward for the insert after node. var node = startNode; LinkedListNode <T> pvNode = null; while (true) { if (node == null) { baseNode = pvNode; break; } var rc = InsertItem.Compare(InsertItem, node.Value); // insert item is before the current item. If there is a pvNode, // then setup to insert after the pvNode. if (rc == -1) { baseNode = pvNode; break; } pvNode = node; node = node.Next; } // search backward for the insert after node. if (baseNode == null) { node = startNode; while (true) { if (node == null) { baseNode = null; break; } var rc = InsertItem.Compare(InsertItem, node.Value); // insert item is equal or after the current item. // Setup to insert after this current item. if ((rc == 0) || (rc == 1)) { baseNode = node; break; } node = node.Previous; } } // insert after the base node. if (baseNode != null) { insertedNode = List.AddAfter(baseNode, InsertItem); } else { insertedNode = List.AddFirst(InsertItem); } return(insertedNode); }
public static IList <int> PlayCrabCups( IList <int> startingNumbers, int numberOfCupsToPickUp, int numberOfRounds) { var numberLinkedList = new LinkedList <int>(startingNumbers); var labelToNodeDictionary = new Dictionary <int, LinkedListNode <int> >(); var currentNode = numberLinkedList.First; for (var i = 0; i < startingNumbers.Count; i++) { if (currentNode == null) { continue; } labelToNodeDictionary.Add(currentNode.Value, currentNode); currentNode = currentNode.Next; } var currentCupNode = numberLinkedList.First; //var startTime = DateTime.Now; //const int pingRounds = 1000000; for (var roundNumber = 1; roundNumber <= numberOfRounds; roundNumber++) { var cupsToRemoveNodes = new List <LinkedListNode <int> >(); //if (roundNumber % pingRounds == 0) //{ // var endTime = DateTime.Now; // //var timeDiffSeconds = (endTime - startTime).TotalSeconds; // //var secondsPerRound = (double)timeDiffSeconds / pingRounds; // //var totalSeconds = numberOfRounds * secondsPerRound; // //Console.WriteLine($"---> Round {roundNumber}: {timeDiffSeconds} seconds; Estimated total time for all: {totalSeconds}"); // startTime = DateTime.Now; //} var nextCupNode = currentCupNode; for (var i = 0; i < numberOfCupsToPickUp; i++) { nextCupNode = nextCupNode?.Next ?? numberLinkedList.First; cupsToRemoveNodes.Add(nextCupNode); } if (currentCupNode != null) { var destinationCup = currentCupNode.Value; for (var i = 1; i < startingNumbers.Count; i++) { destinationCup--; if (destinationCup < 1) { destinationCup += startingNumbers.Count; } if (!cupsToRemoveNodes.Select(n => n.Value).Contains(destinationCup)) { break; } } var destinationCupNode = labelToNodeDictionary[destinationCup]; // Remove them foreach (var removeNode in cupsToRemoveNodes) { numberLinkedList.Remove(removeNode); } var addAfterNode = destinationCupNode; foreach (var addNode in cupsToRemoveNodes) { numberLinkedList.AddAfter(addAfterNode, addNode); addAfterNode = addNode; } } currentCupNode = currentCupNode?.Next ?? numberLinkedList.First; } return(numberLinkedList.ToList()); }
static void Main(string[] args) { Random r = new Random(); LinkedList <int> l = new LinkedList <int>(); for (int i = 0; i < 10; ++i) { if (r.Next(2) == 0) { l.AddLast(i); } else { l.AddFirst(i); } } //Print list from manager class foreach (int i in l) { Console.Write($"{i} "); } Console.WriteLine(); LinkedListNode <int> second = null; //Add as third node (manual traversal) if (l.Count >= 2) { second = l.First.Next; l.AddAfter(second, 99); } List <int> li = l.ToList(); LinkedListNode <int> n = l.First; if (!(n is null)) { do { Console.Write($"{n.Value} "); n = n.Next; }while (n != null); } Console.WriteLine(); Stack <LinkedList <int> > slli = new Stack <LinkedList <int> >(); for (int i = 0; i < 10; ++i) { LinkedList <int> lli = new LinkedList <int>(); for (int j = 0; j < i; ++j) { lli.AddFirst(r.Next(10)); } slli.Push(lli); } while (slli.Count > 0) { LinkedList <int> lli = slli.Pop(); foreach (int x in lli) { Console.Write($"{x} "); } } Console.ReadKey(); }
public static void Main() { // <Snippet2> // Create the link list. string[] words = { "the", "fox", "jumped", "over", "the", "dog" }; LinkedList <string> sentence = new LinkedList <string>(words); Display(sentence, "The linked list values:"); Console.WriteLine("sentence.Contains(\"jumped\") = {0}", sentence.Contains("jumped")); // </Snippet2> // Add the word 'today' to the beginning of the linked list. sentence.AddFirst("today"); Display(sentence, "Test 1: Add 'today' to beginning of the list:"); // <Snippet3> // Move the first node to be the last node. LinkedListNode <string> mark1 = sentence.First; sentence.RemoveFirst(); sentence.AddLast(mark1); // </Snippet3> Display(sentence, "Test 2: Move first node to be last node:"); // Change the last node be 'yesterday'. sentence.RemoveLast(); sentence.AddLast("yesterday"); Display(sentence, "Test 3: Change the last node to 'yesterday':"); // <Snippet4> // Move the last node to be the first node. mark1 = sentence.Last; sentence.RemoveLast(); sentence.AddFirst(mark1); // </Snippet4> Display(sentence, "Test 4: Move last node to be first node:"); // <Snippet12> // Indicate, by using parentheisis, the last occurence of 'the'. sentence.RemoveFirst(); LinkedListNode <string> current = sentence.FindLast("the"); // </Snippet12> IndicateNode(current, "Test 5: Indicate last occurence of 'the':"); // <Snippet5> // Add 'lazy' and 'old' after 'the' (the LinkedListNode named current). sentence.AddAfter(current, "old"); sentence.AddAfter(current, "lazy"); // </Snippet5> IndicateNode(current, "Test 6: Add 'lazy' and 'old' after 'the':"); // <Snippet6> // Indicate 'fox' node. current = sentence.Find("fox"); IndicateNode(current, "Test 7: Indicate the 'fox' node:"); // Add 'quick' and 'brown' before 'fox': sentence.AddBefore(current, "quick"); sentence.AddBefore(current, "brown"); // </Snippet6> IndicateNode(current, "Test 8: Add 'quick' and 'brown' before 'fox':"); // Keep a reference to the current node, 'fox', // and to the previous node in the list. Indicate the 'dog' node. mark1 = current; LinkedListNode <string> mark2 = current.Previous; current = sentence.Find("dog"); IndicateNode(current, "Test 9: Indicate the 'dog' node:"); // The AddBefore method throws an InvalidOperationException // if you try to add a node that already belongs to a list. Console.WriteLine("Test 10: Throw exception by adding node (fox) already in the list:"); try { sentence.AddBefore(current, mark1); } catch (InvalidOperationException ex) { Console.WriteLine("Exception message: {0}", ex.Message); } Console.WriteLine(); // <Snippet7> // Remove the node referred to by mark1, and then add it // before the node referred to by current. // Indicate the node referred to by current. sentence.Remove(mark1); sentence.AddBefore(current, mark1); // </Snippet7> IndicateNode(current, "Test 11: Move a referenced node (fox) before the current node (dog):"); // <Snippet8> // Remove the node referred to by current. sentence.Remove(current); // </Snippet8> IndicateNode(current, "Test 12: Remove current node (dog) and attempt to indicate it:"); // Add the node after the node referred to by mark2. sentence.AddAfter(mark2, current); IndicateNode(current, "Test 13: Add node removed in test 11 after a referenced node (brown):"); // The Remove method finds and removes the // first node that that has the specified value. sentence.Remove("old"); Display(sentence, "Test 14: Remove node that has the value 'old':"); // <Snippet9> // When the linked list is cast to ICollection(Of String), // the Add method adds a node to the end of the list. sentence.RemoveLast(); ICollection <string> icoll = sentence; icoll.Add("rhinoceros"); // </Snippet9> Display(sentence, "Test 15: Remove last node, cast to ICollection, and add 'rhinoceros':"); Console.WriteLine("Test 16: Copy the list to an array:"); //<Snippet10> // Create an array with the same number of // elements as the inked list. string[] sArray = new string[sentence.Count]; sentence.CopyTo(sArray, 0); foreach (string s in sArray) { Console.WriteLine(s); } //</Snippet10> //<Snippet11> // Release all the nodes. sentence.Clear(); Console.WriteLine(); Console.WriteLine("Test 17: Clear linked list. Contains 'jumped' = {0}", sentence.Contains("jumped")); //</Snippet11> Console.ReadLine(); }
static LinkedListDemo() { linkList.AddFirst("h1"); linkList.AddAfter(linkList.Find("h1"), "h2"); linkList.AddBefore(linkList.Find("h2"), "h3"); }
public void InsertChildAfter(RenderElement parent, RenderElement after, RenderElement re) { re._internalLinkedNode = _myElements.AddAfter(after._internalLinkedNode, re); RenderElement.SetParentLink(re, parent); re.InvalidateGraphics(); }
private void AddApparelToLinkedList(Apparel apparel, LinkedList <Apparel> l) { if (!l.Contains(apparel)) { float score = JobGiver_OptimizeApparel.ApparelScoreRaw(null, apparel); for (LinkedListNode <Apparel> n = l.First; n != null; n = n.Next) { float nScore = JobGiver_OptimizeApparel.ApparelScoreRaw(null, apparel); if (score >= nScore) { l.AddBefore(n, apparel); return; } else if (score < nScore) { l.AddAfter(n, apparel); return; } } l.AddLast(apparel); } /* #if TRACE * Log.Message("Start StoredApparel.AddApparelToLinkedList"); * Log.Warning("Apparel: " + apparel.Label); * StringBuilder sb = new StringBuilder("LinkedList: "); * foreach (Apparel a in l) * { * sb.Append(a.LabelShort); * sb.Append(", "); * } * Log.Warning(sb.ToString()); #endif * QualityCategory q; * if (!apparel.TryGetQuality(out q)) * { #if TRACE * Log.Message("AddLast - quality not found"); #endif * l.AddLast(apparel); * } * else * { #if TRACE * Log.Message("HP: " + apparel.HitPoints + " HPMax: " + apparel.MaxHitPoints); #endif * int hpPercent = apparel.HitPoints / apparel.MaxHitPoints; * for (LinkedListNode<Apparel> n = l.First; n != null; n = n.Next) * { * QualityCategory nq; * if (!n.Value.TryGetQuality(out nq) || * q > nq || * (q == nq && hpPercent >= (n.Value.HitPoints / n.Value.MaxHitPoints))) * { * l.AddBefore(n, apparel); * return; * } * } * l.AddLast(apparel); * } #if TRACE * Log.Message("End StoredApparel.AddApparelToLinkedList"); #endif */ }
private void InsertBlock( long BasePosition, long PagesCount, MemoryState OldState, MemoryPermission OldPermission, MemoryAttribute OldAttribute, MemoryState NewState, MemoryPermission NewPermission, MemoryAttribute NewAttribute) { //Insert new block on the list only on areas where the state //of the block matches the state specified on the Old* state //arguments, otherwise leave it as is. OldAttribute |= MemoryAttribute.IpcAndDeviceMapped; ulong Start = (ulong)BasePosition; ulong End = (ulong)PagesCount * PageSize + Start; LinkedListNode <KMemoryBlock> Node = Blocks.First; while (Node != null) { LinkedListNode <KMemoryBlock> NewNode = Node; LinkedListNode <KMemoryBlock> NextNode = Node.Next; KMemoryBlock CurrBlock = Node.Value; ulong CurrStart = (ulong)CurrBlock.BasePosition; ulong CurrEnd = (ulong)CurrBlock.PagesCount * PageSize + CurrStart; if (Start < CurrEnd && CurrStart < End) { MemoryAttribute CurrBlockAttr = CurrBlock.Attribute | MemoryAttribute.IpcAndDeviceMapped; if (CurrBlock.State != OldState || CurrBlock.Permission != OldPermission || CurrBlockAttr != OldAttribute) { Node = NextNode; continue; } if (CurrStart >= Start && CurrEnd <= End) { CurrBlock.State = NewState; CurrBlock.Permission = NewPermission; CurrBlock.Attribute &= ~MemoryAttribute.IpcAndDeviceMapped; CurrBlock.Attribute |= NewAttribute; } else if (CurrStart >= Start) { CurrBlock.BasePosition = (long)End; CurrBlock.PagesCount = (long)((CurrEnd - End) / PageSize); long NewPagesCount = (long)((End - CurrStart) / PageSize); NewNode = Blocks.AddBefore(Node, new KMemoryBlock( (long)CurrStart, NewPagesCount, NewState, NewPermission, NewAttribute)); } else if (CurrEnd <= End) { CurrBlock.PagesCount = (long)((Start - CurrStart) / PageSize); long NewPagesCount = (long)((CurrEnd - Start) / PageSize); NewNode = Blocks.AddAfter(Node, new KMemoryBlock( BasePosition, NewPagesCount, NewState, NewPermission, NewAttribute)); } else { CurrBlock.PagesCount = (long)((Start - CurrStart) / PageSize); long NextPagesCount = (long)((CurrEnd - End) / PageSize); NewNode = Blocks.AddAfter(Node, new KMemoryBlock( BasePosition, PagesCount, NewState, NewPermission, NewAttribute)); Blocks.AddAfter(NewNode, new KMemoryBlock( (long)End, NextPagesCount, CurrBlock.State, CurrBlock.Permission, CurrBlock.Attribute)); NextNode = null; } MergeEqualStateNeighbours(NewNode); } Node = NextNode; } }
static void Main() { LinkedList <String> list = new LinkedList <String>(); list.AddLast("one"); list.AddLast("two"); list.AddLast("three"); list.AddLast("four"); list.AddLast("five"); list.AddLast("six"); list.AddLast("seven"); Console.WriteLine("-------elements in the linkedlist---------------"); foreach (var st in list) { Console.WriteLine(st); } Console.WriteLine("--------------using Enumerator-------------------"); LinkedList <string> .Enumerator ll = list.GetEnumerator(); while (ll.MoveNext()) { Console.WriteLine(ll.Current); } Console.WriteLine("remove paricualr element-------------------"); list.Remove("one"); foreach (var e in list) { Console.WriteLine(e); } Console.WriteLine("remove at first-------------------------"); list.RemoveFirst(); foreach (var e in list) { Console.WriteLine(e); } Console.WriteLine("Removes at last------------------------------"); list.RemoveLast(); foreach (var e in list) { Console.WriteLine(e); } Console.WriteLine("Add at first---------------------------------"); list.AddFirst("hello"); foreach (var e in list) { Console.WriteLine(e); } Console.WriteLine("add at last---------------------------------"); list.AddLast("Sravss"); foreach (var e in list) { Console.WriteLine(e); } var newNode = list.AddLast("Brad"); list.AddBefore(newNode, "wowo super"); Console.WriteLine("LinkedList after adding new nodes..."); foreach (var stu in list) { Console.WriteLine(stu); } var newNode1 = list.AddFirst("welcome"); list.AddAfter(newNode1, "zensarians"); Console.WriteLine("LinkedList after adding new nodes..."); foreach (var stu in list) { Console.WriteLine(stu); } Console.WriteLine("using find()--------------------------"); LinkedListNode <string> temp = list.Find("hello"); Console.WriteLine(temp.Value); }
public static void Show() { //1 内存连续存储,节约空间,可以索引访问,读取快,增删慢 #region Array { //Array:在内存上连续分配的,而且元素类型是一样的 //可以坐标访问 读取快--增删慢,长度不变 Console.WriteLine("***************Array******************"); int[] intArray = new int[3]; intArray[0] = 123; string[] stringArray = new string[] { "123", "234" };//Array } { //ArrayList 不定长的,连续分配的; //元素没有类型限制,任何元素都是当成object处理,如果是值类型,会有装箱操作 //读取快--增删慢 Console.WriteLine("***************ArrayList******************"); ArrayList arrayList = new ArrayList(); arrayList.Add("Eleven"); arrayList.Add("Is"); arrayList.Add(32);//add增加长度 //arrayList[4] = 26;//索引复制,不会增加长度 //删除数据 //arrayList.RemoveAt(4); var value = arrayList[2]; arrayList.RemoveAt(0); arrayList.Remove("Eleven"); } { //List:也是Array,内存上都是连续摆放;不定长;泛型,保证类型安全,避免装箱拆箱 //读取快--增删慢 Console.WriteLine("***************List<T>******************"); List <int> intList = new List <int>() { 1, 2, 3, 4 }; intList.Add(123); intList.Add(123); //intList.Add("123"); //intList[0] = 123; List <string> stringList = new List <string>(); //stringList[0] = "123";//异常的 foreach (var item in intList) { } } #endregion //2 非连续摆放,存储数据+地址,找数据的话就只能顺序查找,读取慢;增删快, #region 链表 { //LinkedList:泛型的特点;链表,元素不连续分配,每个元素都有记录前后节点 //节点值可以重复 //能不能下标访问?不能,找元素就只能遍历 查找不方便 //增删 就比较方便 Console.WriteLine("***************LinkedList<T>******************"); LinkedList <int> linkedList = new LinkedList <int>(); //linkedList[3] linkedList.AddFirst(123); linkedList.AddLast(456); bool isContain = linkedList.Contains(123); LinkedListNode <int> node123 = linkedList.Find(123); //元素123的位置 从头查找 linkedList.AddBefore(node123, 123); linkedList.AddBefore(node123, 123); linkedList.AddAfter(node123, 9); linkedList.Remove(456); linkedList.Remove(node123); linkedList.RemoveFirst(); linkedList.RemoveLast(); linkedList.Clear(); } { //Queue 就是链表 先进先出 放任务延迟执行,A不断写入日志任务 B不断获取任务去执行 Console.WriteLine("***************Queue<T>******************"); Queue <string> numbers = new Queue <string>(); numbers.Enqueue("one"); numbers.Enqueue("two"); numbers.Enqueue("three"); numbers.Enqueue("four"); numbers.Enqueue("four"); numbers.Enqueue("five"); foreach (string number in numbers) { Console.WriteLine(number); } Console.WriteLine($"Dequeuing '{numbers.Dequeue()}'"); Console.WriteLine($"Peek at next item to dequeue: { numbers.Peek()}"); Console.WriteLine($"Dequeuing '{numbers.Dequeue()}'"); Queue <string> queueCopy = new Queue <string>(numbers.ToArray()); foreach (string number in queueCopy) { Console.WriteLine(number); } Console.WriteLine($"queueCopy.Contains(\"four\") = {queueCopy.Contains("four")}"); queueCopy.Clear(); Console.WriteLine($"queueCopy.Count = {queueCopy.Count}"); } //队列是没瓶底的瓶子,栈是有瓶底的瓶子 { //Stack 就是链表 先进后出 解析表达式目录树的时候,先产生的数据后使用 //操作记录为命令,撤销的时候是倒序的 Console.WriteLine("***************Stack<T>******************"); Stack <string> numbers = new Stack <string>(); numbers.Push("one"); numbers.Push("two"); numbers.Push("three"); numbers.Push("four"); numbers.Push("five");//放进去 foreach (string number in numbers) { Console.WriteLine(number); } Console.WriteLine($"Pop '{numbers.Pop()}'"); //获取并移除 Console.WriteLine($"Peek at next item to dequeue: { numbers.Peek()}"); //获取不移除 Console.WriteLine($"Pop '{numbers.Pop()}'"); Stack <string> stackCopy = new Stack <string>(numbers.ToArray()); foreach (string number in stackCopy) { Console.WriteLine(number); } Console.WriteLine($"stackCopy.Contains(\"four\") = {stackCopy.Contains("four")}"); stackCopy.Clear(); Console.WriteLine($"stackCopy.Count = {stackCopy.Count}"); } #endregion //set纯粹的集合,容器,东西丢进去,唯一性 无序的 #region Set { //集合:hash分布,元素间没关系,动态增加容量 去重 //统计用户IP;IP投票 交叉并补--二次好友/间接关注/粉丝合集 Console.WriteLine("***************HashSet<string>******************"); HashSet <string> hashSet = new HashSet <string>(); hashSet.Add("123"); hashSet.Add("689"); hashSet.Add("456"); hashSet.Add("12435"); hashSet.Add("12435"); hashSet.Add("12435"); //hashSet[0]; foreach (var item in hashSet) { Console.WriteLine(item); } Console.WriteLine(hashSet.Count); Console.WriteLine(hashSet.Contains("12345")); { HashSet <string> hashSet1 = new HashSet <string>(); hashSet1.Add("123"); hashSet1.Add("689"); hashSet1.Add("789"); hashSet1.Add("12435"); hashSet1.Add("12435"); hashSet1.Add("12435"); hashSet1.SymmetricExceptWith(hashSet); //补 hashSet1.UnionWith(hashSet); //并 hashSet1.ExceptWith(hashSet); //差 hashSet1.IntersectWith(hashSet); //交 //风--亡五 找出共同的好友 } hashSet.ToList(); hashSet.Clear(); } { //排序的集合:去重 而且排序 //统计排名--每统计一个就丢进去集合 Console.WriteLine("***************SortedSet<string>******************"); SortedSet <string> sortedSet = new SortedSet <string>(); //IComparer<T> comparer 自定义对象要排序,就用这个指定 sortedSet.Add("123"); sortedSet.Add("689"); sortedSet.Add("456"); sortedSet.Add("12435"); sortedSet.Add("12435"); sortedSet.Add("12435"); foreach (var item in sortedSet) { Console.WriteLine(item); } Console.WriteLine(sortedSet.Count); Console.WriteLine(sortedSet.Contains("12345")); { SortedSet <string> sortedSet1 = new SortedSet <string>(); sortedSet1.Add("123"); sortedSet1.Add("689"); sortedSet1.Add("456"); sortedSet1.Add("12435"); sortedSet1.Add("12435"); sortedSet1.Add("12435"); sortedSet1.SymmetricExceptWith(sortedSet); //补 sortedSet1.UnionWith(sortedSet); //并 sortedSet1.ExceptWith(sortedSet); //差 sortedSet1.IntersectWith(sortedSet); //交 } sortedSet.ToList(); sortedSet.Clear(); } #endregion //读取&增删都快? 有 hash散列 字典 //key-value,一段连续有限空间放value(开辟的空间比用到的多,hash是用空间换性能),基于key散列计算得到地址索引,这样读取快 //增删也快,删除时也是计算位置,增加也不影响别人 //肯定会出现2个key(散列冲突),散列结果一致18,可以让第二次的+1, //可能会造成效率的降低,尤其是数据量大的情况下,以前测试过dictionary在3w条左右性能就开始下降的厉害 #region key-value { //Hashtable key-value 体积可以动态增加 拿着key计算一个地址,然后放入key - value //object-装箱拆箱 如果不同的key得到相同的地址,第二个在前面地址上 + 1 //查找的时候,如果地址对应数据的key不对,那就 + 1查找。。 //浪费了空间,Hashtable是基于数组实现 //查找个数据 一次定位; 增删 一次定位; 增删查改 都很快 //浪费空间,数据太多,重复定位定位,效率就下去了 Console.WriteLine("***************Hashtable******************"); Hashtable table = new Hashtable(); table.Add("123", "456"); table[234] = 456; table[234] = 567; table[32] = 4562; table[1] = 456; table["eleven"] = 456; foreach (DictionaryEntry objDE in table) { Console.WriteLine(objDE.Key.ToString()); Console.WriteLine(objDE.Value.ToString()); } //线程安全 Hashtable.Synchronized(table);//只有一个线程写 多个线程读 } { //字典:泛型;key - value,增删查改 都很快;有序的 // 字典不是线程安全 ConcurrentDictionary Console.WriteLine("***************Dictionary******************"); Dictionary <int, string> dic = new Dictionary <int, string>(); dic.Add(1, "HaHa"); dic.Add(5, "HoHo"); dic.Add(3, "HeHe"); dic.Add(2, "HiHi"); dic.Add(4, "HuHu1"); dic[4] = "HuHu"; dic.Add(4, "HuHu"); foreach (var item in dic) { Console.WriteLine($"Key:{item.Key}, Value:{item.Value}"); } } { Console.WriteLine("***************SortedDictionary******************"); SortedDictionary <int, string> dic = new SortedDictionary <int, string>(); dic.Add(1, "HaHa"); dic.Add(5, "HoHo"); dic.Add(3, "HeHe"); dic.Add(2, "HiHi"); dic.Add(4, "HuHu1"); dic[4] = "HuHu"; dic.Add(4, "HuHu"); foreach (var item in dic) { Console.WriteLine($"Key:{item.Key}, Value:{item.Value}"); } } { //"a".GetHashCode(); Console.WriteLine("***************SortedList******************"); SortedList sortedList = new SortedList();//IComparer sortedList.Add("First", "Hello"); sortedList.Add("Second", "World"); sortedList.Add("Third", "!"); sortedList["Third"] = "~~"; // sortedList.Add("Fourth", "!"); sortedList.Add("Fourth", "!"); //重复的Key Add会错 sortedList["Fourth"] = "!!!"; var keyList = sortedList.GetKeyList(); var valueList = sortedList.GetValueList(); sortedList.TrimToSize();//用于最小化集合的内存开销 sortedList.Remove("Third"); sortedList.RemoveAt(0); sortedList.Clear(); } #endregion { //ConcurrentQueue 线程安全版本的Queue //ConcurrentStack线程安全版本的Stack //ConcurrentBag线程安全的对象集合 //ConcurrentDictionary线程安全的Dictionary //BlockingCollection } { List <string> fruits = new List <string> { "apple", "passionfruit", "banana", "mango", "orange", "blueberry", "grape", "strawberry" }; IEnumerable <string> query = fruits.Where(fruit => fruit.Length < 6); foreach (var item in query)//遍历才会去查询比较 迭代器 yield { } IQueryable <string> queryable = fruits.AsQueryable <string>().Where(s => s.Length > 5); foreach (var item in queryable)//表达式目录树的解析,延迟到遍历的时候才去执行 EF的延迟查询 { } } }
static void Main(string[] args) { int elementsCount = 10000000; var indexOfMiddle = elementsCount / 2; int operationsCount = 100; int longOperationsCount = 1000; //Коллекции var lst = new List <int>(); var linkLst = new LinkedList <int>(); //Инициализация коллекций for (int i = 0; i < elementsCount; i++) { lst.Add(i); linkLst.AddLast(i); } //** Добавление в начало списка for (var i = 0; i < longOperationsCount; i++) //551ms { lst.Insert(0, i); } for (var i = 0; i < operationsCount; i++) //1349ms { linkLst.AddFirst(i); } //** Добавление в конец списка for (var i = 0; i < operationsCount; i++) //70ms { lst.Add(i); } for (var i = 0; i < operationsCount; i++) //1632ms { linkLst.AddLast(i); } int obj = 0; //** Операция чтения из середины списка for (var i = 0; i < operationsCount; i++) //55ms { obj = lst[indexOfMiddle + i]; } for (var i = 0; i < longOperationsCount; i++) //3301ms { obj = linkLst.ElementAt(indexOfMiddle + i); } //** Добавление в середину списка //for (var i = 0; i < operationsCount; i++) //ms lst.Insert(indexOfMiddle, -1); //5ms //for (var i = 0; i < operationsCount; i++) //ms //{ var obj1 = linkLst.Find(indexOfMiddle); //18ms if (obj1 != null) { linkLst.AddAfter(obj1, -1); //1ms } //} Console.ReadKey(); }
static void Main() { LinkedList <string> myList = new LinkedList <string>(); myList.AddLast("Pune"); myList.AddLast("Mumbai"); myList.AddLast("Kolhapur"); myList.AddLast("Pandharpur"); myList.AddLast("Satara"); Console.WriteLine("Adding Nagpur at the first node using AddFirst()"); myList.AddFirst("Nagpur"); LinkedListNode <string> n1 = myList.Find("Mumbai"); LinkedListNode <string> var1 = myList.AddAfter(n1, "Amravati"); myList.AddBefore(var1, "Solapur"); foreach (string str in myList) { Console.WriteLine(str); } Console.WriteLine("Iteration using GetEnumerator method"); LinkedList <string> .Enumerator lle = myList.GetEnumerator(); while (lle.MoveNext()) { Console.WriteLine(lle.Current); //Console.WriteLine(lle.); } Console.WriteLine("Contains Method--------"); bool ht = myList.Contains("Satara"); Console.WriteLine(ht); Console.WriteLine("Using CopytTo method------------"); string[] arr = new string[myList.Count]; myList.CopyTo(arr, 0); foreach (string item in arr) { Console.WriteLine(item); } LinkedListNode <string> b = myList.FindLast("Pandharpur"); Console.WriteLine("FindLast method:{0}", b.Value); bool rem = myList.Remove("Nagpur"); Console.WriteLine("Removing Element Nagpur from the linked list:{0}", rem); foreach (string show in myList) { Console.WriteLine(show); } Console.WriteLine("Removing the starting node from the linked list"); myList.RemoveFirst(); foreach (string rem1 in myList) { Console.WriteLine(rem1); } Console.WriteLine("Removing the node at the last from the linked list"); myList.RemoveLast(); foreach (string disp in myList) { Console.WriteLine(disp); } //Console.WriteLine("Clearing the LinkedList"); //myList.Clear(); Console.Read(); }
/* * /// <summary> * /// check authentication attributes for the class * /// </summary> * protected virtual void MapClassAuth() * { * object[] attributes = GetType().GetCustomAttributes(true); * foreach (object attribute in attributes) * { * if (attribute.GetType() == typeof (AuthenticatorAttribute)) * AddAuthAttribute(ClassMethodName, attribute); * if (attribute.GetType() == typeof (AuthenticationRequiredAttribute)) * AddCheckAuthAttribute(ClassMethodName, attribute); * } * } */ /// <summary> /// This method goes through all methods in the controller and /// add's them to a dictionary. They are later used to invoke /// the correct method depending on the url /// </summary> private void MapMethods() { lock (_methods) { // already mapped. if (_methods.Count > 0) { return; } object[] controllerNameAttrs = GetType().GetCustomAttributes(typeof(ControllerNameAttribute), false); if (controllerNameAttrs.Length > 0) { _controllerName = ((ControllerNameAttribute)controllerNameAttrs[0]).Name; } else { _controllerName = GetType().Name; if (ControllerName.Contains("Controller")) { _controllerName = ControllerName.Replace("Controller", ""); } _controllerName = ControllerName.ToLower(); } MethodInfo[] methods = GetType().GetMethods(BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Instance); foreach (MethodInfo info in methods) { ParameterInfo[] parameters = info.GetParameters(); // find regular render methods if (parameters.Length == 0 && info.ReturnType == typeof(string)) { string name = info.Name.ToLower(); if (name.Length > 3 && (name.Substring(0, 4) == "get_" || name.Substring(0, 4) == "set_")) { continue; } if (name == "tostring") { continue; } // Add authenticators object[] authAttributes = info.GetCustomAttributes(true); foreach (object attribute in authAttributes) { if (attribute.GetType() == typeof(AuthRequiredAttribute)) { _authMethods.Add(info.Name.ToLower(), ((AuthRequiredAttribute)attribute).Level); } } _methods.Add(info.Name.ToLower(), info); } // find raw handlers object[] attributes = info.GetCustomAttributes(typeof(RawHandlerAttribute), true); if (attributes.Length >= 1 && info.ReturnType == typeof(void) && parameters.Length == 0) { // Add authenticators object[] authAttributes = info.GetCustomAttributes(true); foreach (object attribute in authAttributes) { if (attribute.GetType() == typeof(AuthRequiredAttribute)) { _authMethods.Add(info.Name.ToLower(), ((AuthRequiredAttribute)attribute).Level); } } _binaryMethods.Add(info.Name.ToLower(), info); } } //foreach methods = GetType().GetMethods(BindingFlags.Instance | BindingFlags.NonPublic); foreach (MethodInfo info in methods) { ParameterInfo[] parameters = info.GetParameters(); // find before filters. if (parameters.Length == 0 && info.ReturnType == typeof(bool)) { object[] authAttributes = info.GetCustomAttributes(true); foreach (object attribute in authAttributes) { if (attribute.GetType() == typeof(AuthValidatorAttribute)) { if (_authValidator != null) { throw new InvalidOperationException("Auth validator have already been specified."); } _authValidator = info; } else if (attribute.GetType() == typeof(BeforeFilterAttribute)) { BeforeFilterAttribute attr = (BeforeFilterAttribute)attribute; LinkedListNode <MethodInfo> node = new LinkedListNode <MethodInfo>(info); if (attr.Position == FilterPosition.First) { _beforeFilters.AddFirst(node); } else if (attr.Position == FilterPosition.Last) { _beforeFilters.AddLast(node); } else { if (_lastMiddleFilter == null) { _beforeFilters.AddLast(node); } else { _beforeFilters.AddAfter(_lastMiddleFilter, node); } _lastMiddleFilter = node; } } } } } // Map index method. MethodInfo mi = GetType().GetMethod("Index", BindingFlags.Public | BindingFlags.Instance); if (mi != null && mi.ReturnType == typeof(string) && mi.GetParameters().Length == 0) { DefaultMethod = "Index"; } } }
public LinkedListNode <WaypointEntry> InsertWaypointAfter(WaypointEntry entry, Vector3 pos, float orientation) { var newWp = CreateWaypoint(pos, orientation); return(Waypoints.AddAfter(entry.Node, newWp)); }
static void Main(string[] args) { //Imagine uma lista de frutas List <string> frutas = new List <string> { "abacate", "banana", "caqui", "damasco", "figo" }; //Vamos imprimir essa lista foreach (var fruta in frutas) { Console.WriteLine(fruta); } Console.WriteLine(); ///image1 ///<image url="$(ProjectDir)\Slides\image1.png" scale=""/> //Adicionar um elemento ao final de uma lista é rápido //Porém inserir no meio da lista exige mais esforço computacional ///image2 ///<image url="$(ProjectDir)\Slides\image2.png" scale=""/> //porque os elementos têm que ser deslocados para darem //espaço ao novo elemento! //E se tivermos que remover esse elemento, os elementos //seguintes precisam ser deslocados de novo! //Quanto maior a lista, mais ineficiente é a inserção //e remoção de elementos no meio dela! //Que coleção é apropriada para inserção/remoção rápida? //Apresentando LISTA LIGADA (LINKED LIST): //- Elementos não precisam estar em sequência em memória //- Cada elemento sabe quem é o anterior e o próximo //- Cada elemento é um "nó" que contém um valor ///linked ///<image url="$(ProjectDir)\Slides\linked.png" scale=""/> //Como a ordem é mantida? Usando ponteiros ///linked2 ///<image url="$(ProjectDir)\Slides\linked2.png" scale=""/> //Instanciando uma nova lista ligada: dias da semana LinkedList <string> dias = new LinkedList <string>(); //Adicionando um dia qualquer: "quarta" var d4 = dias.AddFirst("quarta"); //"quarta" é o primeiro elemento da lista ligada ///image3 ///<image url="$(ProjectDir)\Slides\image3.png" scale=""/> //cada elemento é um nó: LinkedListNode<T> ///System.Collections.Generic.LinkedListNode`1[System.String] //Mas e o valor "quarta"? Está na propriedade d4.Value Console.WriteLine("d4.Value: " + d4.Value); //E para adicionar mais itens? LinkedList não possui Add! //Podemos adicionar de 4 formas: //1. Como primeiró nó //2. Como último nó //3. Antes de um nó conhecido //4. Depois de um nó conhecido //Vamos adicionar segunda, antes de quarta: var d2 = dias.AddBefore(d4, "segunda"); ///image4 ///<image url="$(ProjectDir)\Slides\image4.png" scale=""/> //Agora d2 e d4 estão ligados! //- d2.Next é igual a d4 //- d4.Previous é igual a d2 //Continuando com nossa lista ligada, //vamos adicionar terça depois de segunda var d3 = dias.AddAfter(d2, "terça"); ///image5 ///<image url="$(ProjectDir)\Slides\image5.png" scale=""/> //Perceba que os "ponteiros", ou referências //de d2 e d4 foram redirecionados para d3!! //Vamos adicionar sexta depois de quarta var d6 = dias.AddAfter(d4, "sexta"); ///image6 ///<image url="$(ProjectDir)\Slides\image6.png" scale=""/> //sábado depois de sexta var d7 = dias.AddAfter(d6, "sábado"); ///image7 ///<image url="$(ProjectDir)\Slides\image7.png" scale=""/> //quinta antes de sexta var d5 = dias.AddBefore(d6, "quinta"); ///image8 ///<image url="$(ProjectDir)\Slides\image8.png" scale=""/> //domingo antes de segunda var d1 = dias.AddBefore(d2, "domingo"); ///image9 ///<image url="$(ProjectDir)\Slides\image9.png" scale=""/> //Agora vamos imprimir a lista ligada foreach (var dia in dias) { Console.WriteLine(dia); } Console.WriteLine(); //LinkedList NÃO DÁ suporte ao acesso de índice: dias[0] //por isso podemos fazer um laço foreach mas não um for! var quarta = dias.Find("quarta"); //Para removermos um elemento, podemos tanto //remover pelo valor quanto pela //referência do LinkedListNode //dias.Remove("quarta") ou dias.Remove(d4); dias.Remove("quarta"); foreach (var dia in dias) { Console.WriteLine(dia); } }
private void ReplaceInQueue(LinkedList<Element> queue, Element output, Element input) { queue.AddAfter(queue.Find(output), input); queue.Remove(output); }
static void Main(string[] args) { //TAREFA 1: PRIMEIRO QUE ENTRA, PRIMEIRO QUE SAI (FIFO) var veiculo1 = "van"; var veiculo2 = "kombi"; var veiculo3 = "guincho"; var veiculo4 = "pickup"; Queue <string> pedagio = new Queue <string>(); pedagio.Enqueue(veiculo1); pedagio.Enqueue(veiculo2); pedagio.Enqueue(veiculo3); pedagio.Enqueue(veiculo4); Console.WriteLine(pedagio.Dequeue()); Console.WriteLine(pedagio.Dequeue()); Console.WriteLine(pedagio.Dequeue()); Console.WriteLine(pedagio.Dequeue()); Console.WriteLine(); //TAREFA 2: PRIMEIRO QUE ENTRA, ÚLTIMO QUE SAI (LIFO) string site0 = "<<vazio>>"; string site1 = "google.com"; string site2 = "caelum.com.br"; string site3 = "alura.com.br"; Stack <string> historicoNavegador = new Stack <string>(); historicoNavegador.Push(site0); Console.WriteLine("Navegando para: {0}", site1); historicoNavegador.Push(site1); Console.WriteLine("Navegando para: {0}", site2); historicoNavegador.Push(site2); Console.WriteLine("Navegando para: {0}", site3); historicoNavegador.Push(site3); Console.WriteLine("Voltando para: {0}", historicoNavegador.Pop()); Console.WriteLine("Voltando para: {0}", historicoNavegador.Pop()); Console.WriteLine("Voltando para: {0}", historicoNavegador.Pop()); Console.WriteLine("Voltando para: {0}", historicoNavegador.Pop()); Console.WriteLine(); //TAREFA 3: UMA COLEÇÃO PODEROSA List <string> meses = new List <string> { "janeiro", "fevereiro", "março", "abril", "abril", "maio", "junho", "julho", "agosto" }; meses.Add("setembro"); meses.AddRange(new string[] { "novembro", "dezembro", "onzembro" }); meses.RemoveAt(4); meses.RemoveAt(meses.Count - 1); meses.Insert(9, "outubro"); for (int i = 0; i < meses.Count; i++) { Console.WriteLine("mês {0}: {1}", i + 1, meses[i]); } Console.WriteLine(); meses.Sort((m1, m2) => m1.CompareTo(m2)); for (int i = 0; i < meses.Count; i++) { Console.WriteLine("{0}", meses[i]); } Console.WriteLine(); //TAREFA 4: MATRIZ DE DADOS DE TAMANHO FIXO int[] imagem = new int[65535]; int x = 31; int y = 14; const int rgb = 0x9EA3A7; imagem[27] = rgb; //TAREFA 5: LIGANDO OS NÓS LinkedList <string> dias = new LinkedList <string>(); var d4 = dias.AddFirst("quarta"); var d2 = dias.AddBefore(d4, "segunda"); var d3 = dias.AddAfter(d2, "terça"); var d6 = dias.AddAfter(d4, "sexta"); var d7 = dias.AddAfter(d6, "sábado"); var d5 = dias.AddBefore(d6, "quinta"); var d1 = dias.AddBefore(d2, "domingo"); foreach (var dia in dias) { Console.WriteLine(dia); } Console.WriteLine(); //TAREFA 6: UNINDO COLEÇÕES SEM DUPLICAÇÃO var pares = new List <int> { 0, 2, 4, 6, 8, 10 }; var impares = new List <int> { 1, 3, 5, 7, 9 }; var primos = new List <int> { 1, 2, 3, 5, 7 }; ISet <int> zeroAdez = new HashSet <int>(); pares.ForEach(n => zeroAdez.Add(n)); impares.ForEach(n => zeroAdez.Add(n)); primos.ForEach(n => zeroAdez.Add(n)); foreach (var n in zeroAdez) { Console.WriteLine(n); } Console.WriteLine(); //TAREFA 7: ASSOCIANDO CHAVES E VALORES Dictionary <string, string> weekDays = new Dictionary <string, string> { { "SEG", "Monday" }, { "TER", "Tuesday" }, { "QUA", "Wednesday" }, { "QUI", "Thursday" }, { "SEX", "Friday" } }; weekDays.Add("SAB", "Saturday"); weekDays.Add("DOM", "Sunday"); foreach (var chaveValor in weekDays) { Console.WriteLine("{0} - {1}", chaveValor.Key, chaveValor.Value); } Console.ReadLine(); }
static long part2(string input) { LinkedList <int> cups = new LinkedList <int>(); Dictionary <int, LinkedListNode <int> > lookup = new Dictionary <int, LinkedListNode <int> >(); for (int i = 0; i < input.Length; i++) { cups.AddLast(int.Parse(input.Substring(i, 1))); lookup[int.Parse(input.Substring(i, 1))] = cups.Last; } for (int i = 10; i <= 1000000; i++) { cups.AddLast(i); lookup[i] = cups.Last; } LinkedListNode <int> current = cups.First; for (int i = 0; i < 10000000; i++) { int currentLabel = current.Value; LinkedListNode <int> cupNode1 = getNextNode(cups, current); LinkedListNode <int> cupNode2 = getNextNode(cups, cupNode1); LinkedListNode <int> cupNode3 = getNextNode(cups, cupNode2); int myCup1 = cupNode1.Value; cups.Remove(cupNode1); int myCup2 = cupNode2.Value; cups.Remove(cupNode2); int myCup3 = cupNode3.Value; cups.Remove(cupNode3); // pick destination int desiredLabel = currentLabel - 1; if (desiredLabel < 1) { desiredLabel += 1000000; } while (myCup1 == desiredLabel || myCup2 == desiredLabel || myCup3 == desiredLabel) { desiredLabel--; if (desiredLabel < 1) { desiredLabel += 1000000; } } LinkedListNode <int> destination = lookup[desiredLabel]; cups.AddAfter(destination, cupNode1); cups.AddAfter(cupNode1, cupNode2); cups.AddAfter(cupNode2, cupNode3); //pick the new current current = getNextNode(cups, current); } //find 1 LinkedListNode <int> one = cups.Find(1); LinkedListNode <int> next1 = one.Next; LinkedListNode <int> next2 = next1.Next; return((long)next1.Value * (long)next2.Value); }
protected List <int> PlayGameLinkedList(List <int> cups, int iterations) { var list = new LinkedList <int>(cups); var cupDictionary = new LinkedListNode <int> [list.Count]; var cupNode = list.First; while (cupNode != null) { cupDictionary[cupNode.Value - 1] = cupNode; cupNode = cupNode.Next; } var minCup = cups.Min(); var maxCup = cups.Max(); LinkedListNode <int> currentItem = list.First; var removedItems = new LinkedListNode <int> [3]; for (var i = 0; i < iterations; i++) { for (var j = 0; j < 3; j++) { if (currentItem.Next != null) { removedItems[j] = currentItem.Next; list.Remove(currentItem.Next); } else { removedItems[j] = list.First; list.Remove(list.First); } } var requiredValue = currentItem.Value - 1; if (requiredValue < minCup) { requiredValue = maxCup; } while (removedItems.Any(a => a.Value == requiredValue)) { requiredValue--; if (requiredValue < minCup) { requiredValue = maxCup; } } var insertNode = cupDictionary[requiredValue - 1]; foreach (var value in removedItems) { list.AddAfter(insertNode, value); insertNode = value; } currentItem = currentItem.Next; if (currentItem == null) { currentItem = list.First; } } return(list.ToList()); }
/// <summary> /// Adds sample to the series at the appropriate position. /// This method respects MaxSamples and first deletes older samples making room for new additions /// </summary> protected void Add(ITimeSeriesSample sample) { if (sample == null) { throw new WFormsException(StringConsts.ARGUMENT_ERROR + "TimeSeries.Add(sample==null)"); } //remove data over max samples while (m_Data.Count >= m_MaxSamples) { m_Data.RemoveFirst(); } var dt = sample.TimeStamp; var head = m_Data.First; if (head == null || head.Value.TimeStamp >= dt) { m_Data.AddFirst(sample); return; } var last = m_Data.Last; if (last.Value.TimeStamp <= dt) { m_Data.AddLast(sample); return; } var d1 = dt - head.Value.TimeStamp; var d2 = last.Value.TimeStamp - dt; if (d1 < d2) { var node = head; while (node != null) { if (node.Value.TimeStamp >= dt) { m_Data.AddBefore(node, sample); return; } node = node.Next; } m_Data.AddLast(sample); } else { var node = last; while (node != null) { if (node.Value.TimeStamp <= dt) { m_Data.AddAfter(node, sample); return; } node = node.Previous; } m_Data.AddFirst(sample); } }
static void Main(string[] args) { LinkedList <string> l = new LinkedList <string>(); l.AddLast("One"); l.AddLast("Two"); l.AddLast("Three"); foreach (var element in l) { Console.WriteLine(element); } Console.WriteLine(); // Example 2 - A linked-list is a collection type that on the surface is very similar to the List<T> type, // but the big difference is how the data is stored internally LinkedList <string> months = new LinkedList <string>(); months.AddLast("March"); months.AddFirst("January"); var march = months.Find("March"); months.AddBefore(march, "February"); months.AddAfter(march, "April"); foreach (var month in months) { Console.WriteLine(month); } Console.WriteLine(); // Example 3 - illustrate the LinkedList<T> class properties // Created LinkedList of string LinkedList <string> myList = new LinkedList <string>(); // Adding Nodes in the LinkedList myList.AddLast("GeeksforGeeks"); myList.AddLast("GFG"); myList.AddLast("Data structures"); myList.AddLast("Noida"); // Count Property // To get the first Node of the LinkedList if (myList.Count > 0) { Console.WriteLine(myList.First.Value); } else { Console.WriteLine("LinkedList is Empty"); } // Last Property // To get the last Node of the LinkedList if (myList.Count > 0) { Console.WriteLine(myList.Last.Value); } else { Console.WriteLine("LinkedList is Empty"); } Console.WriteLine(); }
// Summary: // Sorts the elements in the entire System.Collections.Generic.LinkedList<T> using // the specified System.Comparison<T>. // // Parameters: // comparison: // The System.Comparison<T> to use when comparing elements. // // Exceptions: // System.ArgumentNullException: // comparison is null. public static void Sort <T>(this LinkedList <T> @this, Comparison <T> comparison) { if (@this == null) { throw new NullReferenceException(); } if (comparison == null) { throw new ArgumentNullException("comparison"); } int count = @this.Count; if (count <= 1) { return; } // merge pairs of lists of doubling size for (int mergeLength = 1; mergeLength < count; mergeLength *= 2) { LinkedListNode <T> mergedTail = null; LinkedListNode <T> head2; for (LinkedListNode <T> head1 = @this.First; head1 != null; head1 = head2) { // skip over the 1st part to the start 2nd head2 = head1; int length1; for (length1 = 0; length1 < mergeLength && head2 != null; ++length1) { head2 = head2.Next; } // assume we have a full-length 2nd part int length2 = mergeLength; // while we still have items to merge while (length1 > 0 || (length2 > 0 && head2 != null)) { LinkedListNode <T> next; // determine which part the next item comes from if (length1 != 0 && !(length2 != 0 && head2 != null && comparison(head1.Value, head2.Value) > 0)) { // take item from 1st part Debug.Assert(head1 != null); next = head1; head1 = head1.Next; Debug.Assert(length1 > 0); --length1; } else { // take item from 2nd part Debug.Assert(head2 != null); next = head2; head2 = head2.Next; Debug.Assert(length2 > 0); --length2; } // append the next item to the merged list if (mergedTail == null) { // start a new merged list at the front of the source list if (@this.First != next) // check for no-op { @this.Remove(next); @this.AddFirst(next); } } else if (mergedTail.Next != next) // check for no-op { @this.Remove(next); @this.AddAfter(mergedTail, next); } // advance the merged tail mergedTail = next; } } } }
static void Test2() { LinkedList <int> list1 = new LinkedList <int>(); LinkedListNode <int> node; node = list1.AddLast(10); //list1.AddFirst(5); node = list1.AddFirst(5); list1.Print("list1", "\t"); //5 10 list1.AddAfter(node, 20); list1.Print("list1", "\t"); LinkedListNode <int> node2 = new LinkedListNode <int>(50); list1.AddAfter(node, node2); list1.Print("list1", "\t"); Console.WriteLine(node.Next.Next.Value); Console.WriteLine(node2.Next.Next.Value); LinkedListNode <int> node3 = node2.Next; Console.WriteLine(node3.Value); Console.WriteLine(node3.Previous.Previous.Value); Student stud = new Student { Name = "Anna", Bday = new DateTime(1986, 5, 12) }; List <Student> group = new List <Student> { null, new Student { Name = "Mark", Bday = new DateTime(1996, 12, 13) }, new Student { Name = "Ivan", Bday = new DateTime(2013, 10, 25) }, stud, new Student { Name = "Oleg", Bday = new DateTime(2015, 1, 16) } }; LinkedList <Student> listst = new LinkedList <Student>(group); listst.Print("listst"); //var nodefind=listst.Find(new Student { Name = "Anna", Bday = new DateTime(1986, 5, 12) }); // var nodefind=listst.Find(stud); var nodefind = listst.Find(new Student { Name = "Ivan", Bday = new DateTime(2013, 10, 25) }); if (nodefind is null) { Console.WriteLine("HEMA"); } else { Console.WriteLine($"E {nodefind.Value}"); } var col = listst.OrderBy(x => x).ToList(); LinkedList <Student> listsort = new LinkedList <Student>(col); listsort.Print("listst"); //foreach (var item in col) //{ // Console.WriteLine(item); //} IEnumerable <Student> col2 = listst.OrderBy(x => x, new CompDate()); //ToList(); LinkedList <Student> listsort2 = new LinkedList <Student>(col2); listsort2.Print("listst2"); }
public void AddBefore_LLNode_LLNode() { LinkedList <T> linkedList = new LinkedList <T>(); int arraySize = 16; int seed = 8293; T[] tempItems, headItems, headItemsReverse, tailItems, tailItemsReverse; headItems = new T[arraySize]; tailItems = new T[arraySize]; headItemsReverse = new T[arraySize]; tailItemsReverse = new T[arraySize]; for (int i = 0; i < arraySize; i++) { int index = (arraySize - 1) - i; T head = CreateT(seed++); T tail = CreateT(seed++); headItems[i] = head; headItemsReverse[index] = head; tailItems[i] = tail; tailItemsReverse[index] = tail; } //[] Verify value is default(T) linkedList = new LinkedList <T>(); linkedList.AddFirst(headItems[0]); linkedList.AddBefore(linkedList.First, new LinkedListNode <T>(default(T))); InitialItems_Tests(linkedList, new T[] { default(T), headItems[0] }); //[] Node is the Head linkedList = new LinkedList <T>(); linkedList.AddFirst(headItems[0]); for (int i = 1; i < arraySize; ++i) { linkedList.AddBefore(linkedList.First, new LinkedListNode <T>(headItems[i])); } InitialItems_Tests(linkedList, headItemsReverse); //[] Node is the Tail linkedList = new LinkedList <T>(); linkedList.AddFirst(headItems[0]); tempItems = new T[headItems.Length]; Array.Copy(headItems, 1, tempItems, 0, headItems.Length - 1); tempItems[tempItems.Length - 1] = headItems[0]; for (int i = 1; i < arraySize; ++i) { linkedList.AddBefore(linkedList.Last, new LinkedListNode <T>(headItems[i])); } InitialItems_Tests(linkedList, tempItems); //[] Node is after the Head linkedList = new LinkedList <T>(); linkedList.AddFirst(headItems[0]); linkedList.AddLast(headItems[1]); tempItems = new T[headItems.Length]; Array.Copy(headItems, 0, tempItems, 0, headItems.Length); Array.Reverse(tempItems, 1, headItems.Length - 1); for (int i = 2; i < arraySize; ++i) { linkedList.AddBefore(linkedList.First.Next, new LinkedListNode <T>(headItems[i])); } InitialItems_Tests(linkedList, tempItems); //[] Node is before the Tail linkedList = new LinkedList <T>(); linkedList.AddFirst(headItems[0]); linkedList.AddLast(headItems[1]); tempItems = new T[headItems.Length]; Array.Copy(headItems, 2, tempItems, 0, headItems.Length - 2); tempItems[tempItems.Length - 2] = headItems[0]; tempItems[tempItems.Length - 1] = headItems[1]; for (int i = 2; i < arraySize; ++i) { linkedList.AddBefore(linkedList.Last.Previous, new LinkedListNode <T>(headItems[i])); } InitialItems_Tests(linkedList, tempItems); //[] Node is somewhere in the middle linkedList = new LinkedList <T>(); linkedList.AddFirst(headItems[0]); linkedList.AddLast(headItems[1]); linkedList.AddLast(headItems[2]); tempItems = new T[headItems.Length]; Array.Copy(headItems, 3, tempItems, 0, headItems.Length - 3); tempItems[tempItems.Length - 3] = headItems[0]; tempItems[tempItems.Length - 2] = headItems[1]; tempItems[tempItems.Length - 1] = headItems[2]; for (int i = 3; i < arraySize; ++i) { linkedList.AddBefore(linkedList.Last.Previous.Previous, new LinkedListNode <T>(headItems[i])); } InitialItems_Tests(linkedList, tempItems); //[] Call AddBefore several times remove some of the items linkedList = new LinkedList <T>(); linkedList.AddFirst(headItems[0]); for (int i = 1; i < arraySize; ++i) { linkedList.AddBefore(linkedList.First, new LinkedListNode <T>(headItems[i])); } linkedList.Remove(headItems[2]); linkedList.Remove(headItems[headItems.Length - 3]); linkedList.Remove(headItems[1]); linkedList.Remove(headItems[headItems.Length - 2]); linkedList.RemoveFirst(); linkedList.RemoveLast(); //With the above remove we should have removed the first and last 3 items tempItems = new T[headItemsReverse.Length - 6]; Array.Copy(headItemsReverse, 3, tempItems, 0, headItemsReverse.Length - 6); InitialItems_Tests(linkedList, tempItems); for (int i = 0; i < arraySize; ++i) { linkedList.AddBefore(linkedList.First, new LinkedListNode <T>(tailItems[i])); } T[] tempItems2 = new T[tailItemsReverse.Length + tempItems.Length]; Array.Copy(tailItemsReverse, 0, tempItems2, 0, tailItemsReverse.Length); Array.Copy(tempItems, 0, tempItems2, tailItemsReverse.Length, tempItems.Length); InitialItems_Tests(linkedList, tempItems2); //[] Call AddBefore several times remove all of the items linkedList = new LinkedList <T>(); linkedList.AddFirst(headItems[0]); for (int i = 1; i < arraySize; ++i) { linkedList.AddBefore(linkedList.First, new LinkedListNode <T>(headItems[i])); } for (int i = 0; i < arraySize; ++i) { linkedList.RemoveFirst(); } linkedList.AddFirst(tailItems[0]); for (int i = 1; i < arraySize; ++i) { linkedList.AddBefore(linkedList.First, new LinkedListNode <T>(tailItems[i])); } InitialItems_Tests(linkedList, tailItemsReverse); //[] Call AddBefore several times then call Clear linkedList = new LinkedList <T>(); linkedList.AddFirst(headItems[0]); for (int i = 1; i < arraySize; ++i) { linkedList.AddBefore(linkedList.First, new LinkedListNode <T>(headItems[i])); } linkedList.Clear(); linkedList.AddFirst(tailItems[0]); for (int i = 1; i < arraySize; ++i) { linkedList.AddBefore(linkedList.First, new LinkedListNode <T>(tailItems[i])); } InitialItems_Tests(linkedList, tailItemsReverse); //[] Mix AddBefore and AddAfter calls linkedList = new LinkedList <T>(); linkedList.AddLast(headItems[0]); linkedList.AddLast(tailItems[0]); for (int i = 1; i < arraySize; ++i) { linkedList.AddBefore(linkedList.First, new LinkedListNode <T>(headItems[i])); linkedList.AddAfter(linkedList.Last, new LinkedListNode <T>(tailItems[i])); } tempItems = new T[headItemsReverse.Length + tailItems.Length]; Array.Copy(headItemsReverse, 0, tempItems, 0, headItemsReverse.Length); Array.Copy(tailItems, 0, tempItems, headItemsReverse.Length, tailItems.Length); InitialItems_Tests(linkedList, tempItems); }