Beispiel #1
0
        public void SwapHeadMidTest()
        {
            //[1] 2 [3] 4 => 3 2 1 4
            node1.Swap(node3);

            Assert.IsNull(node3.Prev);
            Assert.AreEqual(node2, node3.Next);
            Assert.AreEqual(node3, node2.Prev);
            Assert.AreEqual(node1, node2.Next);
            Assert.AreEqual(node2, node1.Prev);
            Assert.AreEqual(node4, node1.Next);
            Assert.AreEqual(node1, node4.Prev);
            Assert.IsNull(node4.Next);

            //[3] [2] 1 4 => 2 3 1 4
            node2.Swap(node3);

            Assert.IsNull(node2.Prev);
            Assert.AreEqual(node3, node2.Next);
            Assert.AreEqual(node2, node3.Prev);
            Assert.AreEqual(node1, node3.Next);
            Assert.AreEqual(node3, node1.Prev);
            Assert.AreEqual(node4, node1.Next);
            Assert.AreEqual(node1, node4.Prev);
            Assert.IsNull(node4.Next);
        }
Beispiel #2
0
 public void SwapTest1_2()
 {
     //[1] [2] 3 4 5   最左边两个相邻的交换
     node1.Swap(node2);
     Assert.IsNull(node2.Previous);
     Assert.AreEqual(node2.Next, node1);
     Assert.AreEqual(node1.Previous, node2);
     Assert.AreEqual(node1.Next, node3);
     Assert.AreEqual(node3.Previous, node1);
 }
 public void DLinkNodeSwapTest_1_2()
 {
     //[1] [2] 3 4 5=>2 1 3 4 5  相连-首和下一个交换
     node1.Swap(node2);
     Assert.IsNull(node2.Previous);
     Assert.AreEqual(1, node2.Next.Value);
     Assert.AreEqual(2, node1.Previous.Value);
     Assert.AreEqual(3, node1.Next.Value);
     Assert.AreEqual(1, node3.Previous.Value);
     Assert.AreEqual(4, node3.Next.Value);
     Assert.AreEqual(3, node4.Previous.Value);
     Assert.AreEqual(5, node4.Next.Value);
     Assert.AreEqual(4, node5.Previous.Value);
     Assert.AreEqual(null, node5.Next);
 }
        public void SwapTest()
        {
            //   [1] 2 3 4 5 [6]
            //=> [6] 2 3 4 5 [1]
            node1.Swap(node6);

            Assert.AreEqual(node2, node6.Next);
            Assert.AreEqual(node6, node2.Previous);
            Assert.IsNull(node6.Previous);
            Assert.AreEqual(node5, node1.Previous);
            Assert.AreEqual(node1, node5.Next);
            Assert.IsNull(node1.Next);


            //   [6] [2] 3 4 5 1

            // => [2] [6] 3 4 5 1
            node2.Swap(node6);
            Assert.AreEqual(node3, node6.Next);
            Assert.AreEqual(node2, node6.Previous);
            Assert.AreEqual(node6, node2.Next);
            Assert.AreEqual(node6, node3.Previous);
            Assert.IsNull(node2.Previous);


            //    2 6 3 4 [5] [1]

            // => 2 6 3 4 [1] [5]
            node5.Swap(node1);
            Assert.AreEqual(node5, node1.Next);
            Assert.AreEqual(node4, node1.Previous);
            Assert.AreEqual(node1, node5.Previous);
            Assert.AreEqual(node1, node4.Next);
            Assert.IsNull(node5.Next);


            //    [2] 6 [3] 4 1 5

            // => [3] 6 [2] 4 1 5
            node2.Swap(node3);
            Assert.AreEqual(node4, node2.Next);
            Assert.AreEqual(node6, node2.Previous);
            Assert.AreEqual(node2, node6.Next);
            Assert.AreEqual(node3, node6.Previous);
            Assert.AreEqual(node6, node3.Next);
            Assert.AreEqual(node2, node4.Previous);
            Assert.IsNull(node3.Previous);


            //    3 6 2 [4] 1 [5]

            // => 3 6 2 [5] 1 [4]
            node4.Swap(node5);
            Assert.AreEqual(node1, node5.Next);
            Assert.AreEqual(node2, node5.Previous);
            Assert.AreEqual(node4, node1.Next);
            Assert.AreEqual(node5, node1.Previous);
            Assert.AreEqual(node1, node4.Previous);
            Assert.IsNull(node4.Next);
            Assert.AreEqual(node5, node2.Next);


            //    3 [6] [2] 5 1 4

            // => 3 [2] [6] 5 1 4
            node6.Swap(node2);
            Assert.AreEqual(node5, node6.Next);
            Assert.AreEqual(node2, node6.Previous);
            Assert.AreEqual(node3, node2.Previous);
            Assert.AreEqual(node6, node2.Next);
            Assert.AreEqual(node2, node3.Next);
            Assert.AreEqual(node6, node5.Previous);

            //    3 [2] 6 [5] 1 4

            // => 3 [5] 6 [2] 1 4
            node2.Swap(node5);
            Assert.AreEqual(node6, node5.Next);
            Assert.AreEqual(node3, node5.Previous);
            Assert.AreEqual(node2, node6.Next);
            Assert.AreEqual(node5, node6.Previous);
            Assert.AreEqual(node6, node2.Previous);
            Assert.AreEqual(node1, node2.Next);
            Assert.AreEqual(node5, node3.Next);
            Assert.AreEqual(node2, node1.Previous);


            //    [3] 5 6 2 1 [4]先
            // => [4] 5 6 2 1 [3]

            node4.Swap(node3);
            Assert.AreEqual(node4, node5.Previous);
            Assert.AreEqual(node5, node4.Next);
            Assert.AreEqual(node1, node3.Previous);
            Assert.AreEqual(node3, node1.Next);
            Assert.IsNull(node3.Next);
            Assert.IsNull(node4.Previous);


            // 5先
            //    [4] [5] 6 2 1 3
            // => [5] [4] 6 2 1 3
            node5.Swap(node4);
            Assert.AreEqual(node6, node4.Next);
            Assert.AreEqual(node5, node4.Previous);
            Assert.AreEqual(node4, node5.Next);
            Assert.AreEqual(node4, node6.Previous);
            Assert.IsNull(node5.Previous);


            //  3先
            //    5 4 6 2 [1] [3]
            // => 5 4 6 2 [3] [1]
            node3.Swap(node1);
            Assert.AreEqual(node1, node3.Next);
            Assert.AreEqual(node2, node3.Previous);
            Assert.AreEqual(node3, node1.Previous);
            Assert.AreEqual(node3, node2.Next);
            Assert.IsNull(node1.Next);


            // 6先
            //    [5] 4 [6] 2 3 1
            // => [6] 4 [5] 2 3 1
            node6.Swap(node5);
            Assert.AreEqual(node5, node4.Next);
            Assert.AreEqual(node6, node4.Previous);
            Assert.AreEqual(node2, node5.Next);
            Assert.AreEqual(node4, node5.Previous);
            Assert.AreEqual(node4, node6.Next);
            Assert.AreEqual(node5, node2.Previous);
            Assert.IsNull(node6.Previous);


            // 1先
            //    6 4 5 [2] 3 [1]
            // => 6 4 5 [1] 3 [2]
            node1.Swap(node2);
            Assert.AreEqual(node2, node3.Next);
            Assert.AreEqual(node1, node3.Previous);
            Assert.AreEqual(node3, node1.Next);
            Assert.AreEqual(node5, node1.Previous);
            Assert.AreEqual(node3, node2.Previous);
            Assert.IsNull(node2.Next);
            Assert.AreEqual(node1, node5.Next);
        }