private static void InsertionSort(DoublyLinkedList<double> bucket)
        {
            if (bucket.Head == null)
            {
                return;
            }

            var currentNode = bucket.Head.Next;
            while (currentNode != null)
            {
                var node = currentNode.Previous;
                while (node != null && node.Value > currentNode.Value)
                {
                    node = node.Previous;
                }

                bucket.Delete(currentNode);
                if (node != null)
                {
                    bucket.InsertAfter(node, currentNode.Value);
                }
                else
                {
                    bucket.Insert(currentNode.Value);
                }

                currentNode = currentNode.Next;
            }
        }

 public void should_make_the_node_head_and_tail_of_the_list()
 {
     var list = new DoublyLinkedList<int>();
     list.Add(3);
     Assert.That(list.Head.Data.Equals(3), Is.True);
     Assert.That(list.Tail.Data.Equals(3), Is.True);
 }

        public static void Sort(double[] array)
        {
            var buckets = new DoublyLinkedList<double>[10];
            for (var i = 0; i < buckets.Length; i++)
            {
                buckets[i] = new DoublyLinkedList<double>();
            }

            foreach (var v in array)
            {
                if (v < 0 || v >= 1)
                {
                    throw new InvalidOperationException($"{v} is not in [0..1) range.");
                }
                buckets[(int)(v * 10)].Insert(v);
            }

            foreach (var bucket in buckets)
            {
                InsertionSort(bucket);
            }

            var index = 0;
            foreach (var bucket in buckets)
            {
                for (var node = bucket.Head; node != null; node = node.Next)
                {
                    array[index++] = node.Value;
                }
            }
        }

        public static void Main()
        {
            var list = new DoublyLinkedList<int>();

            list.ForEach(Console.WriteLine);
            Console.WriteLine("--------------------");

            list.AddLast(5);
            list.AddFirst(3);
            list.AddFirst(2);
            list.AddLast(10);
            Console.WriteLine("Count = {0}", list.Count);

            list.ForEach(Console.WriteLine);
            Console.WriteLine("--------------------");

            list.RemoveFirst();
            list.RemoveLast();
            list.RemoveFirst();

            list.ForEach(Console.WriteLine);
            Console.WriteLine("--------------------");

            list.RemoveLast();

            list.ForEach(Console.WriteLine);
            Console.WriteLine("--------------------");
        }

 public void should_return_the_node_if_the_value_exists()
 {
     var list = new DoublyLinkedList<int>();
     list.Add(5);
     list.Add(3);
     var node = list.Find(5);
     Assert.That(node.Data.Equals(5), Is.True);
 }

 public void BeginTestMethod()
 {
     target = new DoublyLinkedList<int>();
     Assert.AreEqual(target.Leng, 0);
     target.Add(2);
     target.Add(3, 1);
     target.AddLast(5);
 }

        public void TestDoublyLinkedListAdd()
        {
            DoublyLinkedList<string> list = new DoublyLinkedList<string>();
            list.Add("One");
            list.Add("Two");
            list.Add("Three");

            Assert.AreEqual(3, list.Count);
        }

 public void AddAfterTailPUT([PexAssumeUnderTest]IList<int> values, int toAddValue)
 {
     PexAssume.IsTrue(values.Count > 1);
     PexAssume.IsFalse(values.Contains(toAddValue));
     DoublyLinkedList<int> dll = new DoublyLinkedList<int> (values);
     dll.AddAfter(dll.Tail, toAddValue);
     PexAssert.AreEqual(toAddValue, dll.Tail.Value);
     PexAssert.AreEqual(values[values.Count - 1], dll.Tail.Previous.Value);
 }

 public void Contains()
 {
     DoublyLinkedList<int> list = new DoublyLinkedList<int>();
     list.Add(3);
     list.Add(5);
     list.Add(7);
     bool isTrue = list.Contains(3);
     Assert.AreEqual(true, isTrue);
 }

 public void Clear()
 {
     DoublyLinkedList<int> list = new DoublyLinkedList<int>();
     list.Add(3);
     list.Add(5);
     list.Add(7);
     list.Clear();
     list.ShouldBeEmpty();
 }

 public void CopyToWithLessSpaceInTheArray()
 {
     DoublyLinkedList<int> list = new DoublyLinkedList<int>();
     int[] array = new int[3];
     list.Add(3);
     list.Add(5);
     list.Add(7);
     list.CopyTo(array, 2);
 }

 public void CopyTo()
 {
     DoublyLinkedList<int> list = new DoublyLinkedList<int>();
     int[] array = new int[3];
     list.Add(3);
     list.Add(5);
     list.Add(7);
     list.CopyTo(array, 0);
 }

        public void CopyTo()
        {
            var list = new DoublyLinkedList<int>(new[] { 1, 2, 3 });
            var array = new int[4];

            list.CopyTo(array, 1);

            CollectionAssert.AreEqual(new[] {0, 1, 2, 3}, array);
        }

        public void AddAfterTailTest()
        {
            DoublyLinkedList<int> dll = new DoublyLinkedList<int> {10};

            dll.AddAfter(dll.Head, 20);

            Assert.AreEqual(20, dll.Tail.Value);
            Assert.AreEqual(10, dll.Tail.Previous.Value);
        }

 public static void ClassInitializer(TestContext context)
 {
     head = new DoublyLinkedListNode<int>(-1);
       doublyLinkedList= new DoublyLinkedList<int>(head);
      doublyLinkedList.Add(4);
      doublyLinkedList.Add(41);
       doublyLinkedList.Add(54);
       doublyLinkedList.Add(9);
 }

        private static void RunDoublyLinkedList()
        {
            var doublyLinkedList = new DoublyLinkedList<int>();
            Console.WriteLine("Creating a new list");
            Utils.PrintList(doublyLinkedList.Head);

            foreach (var key in new[] {10, 17, 1, 4, 9})
            {
                Console.WriteLine($"Inserting {key}");
                doublyLinkedList.Insert(key);
            }
            Utils.PrintList(doublyLinkedList.Head);
            Utils.PrintListReverse(doublyLinkedList.Tail);

            Console.WriteLine("Appending 19");
            doublyLinkedList.Append(19);
            Utils.PrintList(doublyLinkedList.Head);
            Utils.PrintListReverse(doublyLinkedList.Tail);

            var node = doublyLinkedList.Search(17);
            Console.WriteLine($"Inserting 20 before {node.Value}");
            doublyLinkedList.InsertBefore(node, 20);
            Utils.PrintList(doublyLinkedList.Head);
            Utils.PrintListReverse(doublyLinkedList.Tail);

            Console.WriteLine($"Inserting 13 after {node.Value}");
            doublyLinkedList.InsertAfter(node, 13);
            Utils.PrintList(doublyLinkedList.Head);
            Utils.PrintListReverse(doublyLinkedList.Tail);

            Console.WriteLine("Deleting first element");
            node = doublyLinkedList.Search(9);
            doublyLinkedList.Delete(node);
            Utils.PrintList(doublyLinkedList.Head);
            Utils.PrintListReverse(doublyLinkedList.Tail);

            Console.WriteLine("Deleting last element");
            node = doublyLinkedList.Search(10);
            doublyLinkedList.Delete(node);
            Utils.PrintList(doublyLinkedList.Head);
            Utils.PrintListReverse(doublyLinkedList.Tail);

            Console.WriteLine("Deleting element in the middle");
            node = doublyLinkedList.Search(1);
            doublyLinkedList.Delete(node);
            Utils.PrintList(doublyLinkedList.Head);
            Utils.PrintListReverse(doublyLinkedList.Tail);

            Console.WriteLine("Deleting all nodes");
            while (doublyLinkedList.Head != null)
            {
                Console.WriteLine($"Deleting {doublyLinkedList.Head.Value}");
                doublyLinkedList.Delete(doublyLinkedList.Head);
            }
            Utils.PrintList(doublyLinkedList.Head);
            Utils.PrintListReverse(doublyLinkedList.Tail);
        }

        public void RemoveAt()
        {
            var list = new DoublyLinkedList<int>(new[] { 1, 2, 3 });

            list.RemoveAt(1);

            Assert.AreEqual(2, list.Count);
            Assert.AreEqual(1, list[0].Value);
            Assert.AreEqual(3, list[1].Value);
        }

        public void AddFirstTest()
        {
            var list = new DoublyLinkedList<int>();
            list.AddFirst(2);
            list.AddFirst(4);
            list.AddFirst(6);

            Assert.AreEqual(list.Head.Value, 6);
            Assert.AreEqual(list.Tail.Value, 2);
        }

        public void AddAfterTest()
        {
            DoublyLinkedList<int> dll = new DoublyLinkedList<int> {10, 20, 30};

            dll.AddAfter(dll.Head.Next, 25);

            Assert.AreEqual(25, dll.Head.Next.Next.Value);
            Assert.AreEqual(20, dll.Head.Next.Next.Previous.Value);
            Assert.AreEqual(30, dll.Head.Next.Next.Next.Value);
            Assert.AreEqual(25, dll.Tail.Previous.Value);
        }

        public void ClearTest()
        {
            var list = new DoublyLinkedList<int>();
            list.AddLast(2);
            list.AddLast(4);
            list.AddLast(6);

            list.Clear();

            Assert.AreEqual(list.Head, null);
        }