重写2.2.18

Author: ikesnowy

2 Sorting/2.2/2.2.18/2.2.18.csproj

@@ -43,12 +43,19 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="LinkedList.cs" />
+    <Compile Include="MergeSuffle.cs" />
     <Compile Include="Node.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Merge\Merge.csproj">
+      <Project>{86319415-44d5-4beb-9bd9-87d7e1efa36e}</Project>
+      <Name>Merge</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

2 Sorting/2.2/2.2.18/LinkedList.cs

@@ -120,27 +120,18 @@ public Item Delete(int index)
         }
 
         /// <summary>
-        /// 将链表对半拆分。
+        /// 获得链表的中间元素。
         /// </summary>
-        /// <param name="A">左半部分。</param>
-        /// <param name="B">右半部分。</param>
-        public void SplitInHalf(out LinkedList<Item> A, out LinkedList<Item> B)
+        /// <returns>链表的中间元素。</returns>
+        public Node<Item> GetMiddle()
         {
+            Node<Item> middle = this.first;
             int mid = this.count / 2;
-            A = new LinkedList<Item>();
-            B = new LinkedList<Item>();
-            A.first = this.first;
-            A.count = mid;
-            B.first = this.first;
-            B.count = this.count - mid;
-            
             for (int i = 0; i < mid - 1; i++)
             {
-                B.first = B.first.next;
+                middle = middle.next;
             }
-            Node<Item> temp = B.first;
-            B.first = B.first.next;
-            temp.next = null;
+            return middle;
         }
 
         /// <summary>

2 Sorting/2.2/2.2.18/MergeSuffle.cs

@@ -0,0 +1,152 @@
+using System;
+
+namespace _2._2._18
+{
+    /// <summary>
+    /// 归并排序类。
+    /// </summary>
+    public class MergeShuffle
+    {
+        /// <summary>
+        /// 默认构造函数。
+        /// </summary>
+        public MergeShuffle() { }
+
+        /// <summary>
+        /// 利用分治法打乱链表。
+        /// </summary>
+        /// <typeparam name="T">链表元素类型。</typeparam>
+        /// <param name="a">等待打乱的链表。</param>
+        public void Shuffle<T>(LinkedList<T> a)
+        {
+            int blockLen = 1;
+            Random random = new Random();
+            while (blockLen <= a.Size())
+            {
+                // 找到第一个块
+                Node<T> lo = a.GetFirst();
+                Node<T> mid = FindBlock(lo, blockLen);
+
+                if (mid.next == null)
+                    break;
+
+                while (mid.next != null)
+                {
+                    Node<T> hi = FindBlock(mid.next, blockLen);
+                    Node<T>[] result;
+                    if (lo == a.GetFirst())
+                    {
+                        result = Merge(lo, mid, hi, random);
+                        a.SetFirst(result[0]);
+                    }
+                    else
+                    {
+                        result = Merge(lo.next, mid, hi, random);
+                        lo.next = result[0];
+                    }
+
+
+                    // 跳到表尾
+                    lo = result[1];
+
+                    if (lo.next != null)
+                        mid = FindBlock(lo.next, blockLen);
+                    else
+                        mid = lo;
+                }
+                blockLen *= 2;
+            }
+        }
+
+        /// <summary>
+        /// 将两个有序链表块随机归并，返回新的表头。
+        /// </summary>
+        /// <typeparam name="T">链表元素类型。</typeparam>
+        /// <param name="lo">第一个块起点。</param>
+        /// <param name="mid">第一个块终点（第二个块起点的前驱）。</param>
+        /// <param name="hi">第二个块的终点。</param>
+        /// <returns>新的表头。</returns>
+        private Node<T>[] Merge<T>(Node<T> lo, Node<T> mid, Node<T> hi, Random random)
+        {
+            Node<T> after = hi.next; // 要合并的两个块之后的元素
+            Node<T> first = null;
+            Node<T>[] result = new Node<T>[2];
+            Node<T> i = lo;          // 链表1
+            Node<T> j = mid.next;    // 链表2
+
+            // 切割链表
+            mid.next = null;
+            hi.next = null;
+
+            Node<T> current = null;
+            // 决定新的表头
+            if (random.NextDouble() >= 0.5)
+            {
+                current = i;
+                i = i.next;
+            }
+            else
+            {
+                current = j;
+                j = j.next;
+            }
+
+            first = current;
+
+            // 归并表
+            while (i != null && j != null)
+            {
+                if (random.NextDouble() >= 0.5)
+                {
+                    current.next = i;
+                    i = i.next;
+                    current = current.next;
+                }
+                else
+                {
+                    current.next = j;
+                    j = j.next;
+                    current = current.next;
+                }
+            }
+
+            if (i == null)
+                current.next = j;
+            else
+                current.next = i;
+
+            // 连接表尾（链表 1 的尾部或者链表 2 的尾部）
+            if (mid.next == null)
+            {
+                mid.next = after;
+                result[1] = mid;
+            }
+            else
+            {
+                hi.next = after;
+                result[1] = hi;
+            }
+            result[0] = first;
+            
+            return result;
+        }
+
+        /// <summary>
+        /// 获取从指定位置开始定长的链表。
+        /// </summary>
+        /// <typeparam name="T">链表的元素类型。</typeparam>
+        /// <param name="lo">链表的起始结点。</param>
+        /// <param name="length">需要获取的链表长度。</param>
+        /// <returns>结果链表的最后一个元素结点。</returns>
+        private Node<T> FindBlock<T>(Node<T> lo, int length)
+        {
+            Node<T> hi = lo;
+            for (int i = 0; i < length - 1 && hi.next != null; i++)
+            {
+                hi = hi.next;
+            }
+            
+            return hi;
+        }
+    }
+}

2 Sorting/2.2/2.2.18/Program.cs

@@ -14,60 +14,18 @@ class Program
     {
         static void Main(string[] args)
         {
-            // 对于两个只有一个元素的链表，打乱操作等于50%可能交换+50%可能不交换。
-            // 将链表不断对半切分，再随机决定是否交换
             LinkedList<int> a = new LinkedList<int>();
-            Random random = new Random();
+            MergeShuffle shuffle = new MergeShuffle();
             a.Insert(1);
             a.Insert(2);
             a.Insert(3);
             a.Insert(4);
             a.Insert(5);
             a.Insert(6);
-
-            a = Shuffle(a, random);
-            foreach (int i in a)
-            {
-                Console.Write(i + " ");
-            }
-            Console.WriteLine();
-        }
-
-        /// <summary>
-        /// 随机打乱链表。
-        /// </summary>
-        /// <typeparam name="T">链表中的元素类型。</typeparam>
-        /// <param name="a">需要打乱的链表。</param>
-        static LinkedList<T> Shuffle<T>(LinkedList<T> a, Random random)
-        {
-            if (a.Size() == 1)
-                return a;
-
-            a.SplitInHalf(out LinkedList<T> A, out LinkedList<T> B);
-
-            A = Shuffle(A, random);
-            B = Shuffle(B, random);
-            return RandomMerge(A, B, random);
-        }
-
-        /// <summary>
-        /// 随机合并两个链表，返回合并后的链表。
-        /// </summary>
-        /// <typeparam name="T">链表中的元素类型。</typeparam>
-        /// <param name="a">需要合并的链表。</param>
-        /// <param name="b">需要合并的链表。</param>
-        /// <returns>合并后的链表。</returns>
-        static LinkedList<T> RandomMerge<T> (LinkedList<T> a, LinkedList<T> b, Random random)
-        {
-            if (random.Next(10) > 4)
-            {
-                LinkedList<T>.Merge(a, b);
-                return a;
-            }
-            else
+            for (int i = 0; i < 200; i++)
             {
-                LinkedList<T>.Merge(b, a);
-                return b;
+                shuffle.Shuffle(a);
+                Console.WriteLine(a.ToString());
             }
         }
     }