《算法》第二章部分程序 part 1

▶ 书中第二章部分程序，加上自己补充的代码，包括插入排序，选择排序，Shell 排序

● 插入排序

 package package01;

 import java.util.Comparator;
 import edu.princeton.cs.algs4.StdIn;
 import edu.princeton.cs.algs4.StdOut;

 public class class01
 {
     private class01() { }

     public static void sort(Comparable[] a)                     // 插入排序
     {
         int n = a.length;
         for (int i = 0; i < n; i++)
         {
             for (int j = i; j > 0 && less(a[j], a[j - 1]); j--)
             {
                 exch(a, j, j - 1);
             }
             //assert isSorted(a, 0, i);                         // 检验是否正确排序
         }
         //assert isSorted(a);
     }

     public static void sort(Comparable[] a, int lo, int hi)     // 部分插入排序
     {
         for (int i = lo; i < hi; i++)
         {
             for (int j = i; j > lo && less(a[j], a[j - 1]); j--)
             {
                 exch(a, j, j - 1);
             }
         }
         //assert isSorted(a, lo, hi);
     }

     public static void sort(Object[] a, Comparator comparator)  // 自定义比较运算的插入排序
     {
         int n = a.length;
         for (int i = 0; i < n; i++)
         {
             for (int j = i; j > 0 && less(a[j], a[j - 1], comparator); j--)
             {
                 exch(a, j, j - 1);
             }
             //assert isSorted(a, 0, i, comparator);
         }
         //assert isSorted(a, comparator);
     }

     public static void sort(Object[] a, int lo, int hi, Comparator comparator)  // 自定义比较运算的部分插入排序
     {
         for (int i = lo; i < hi; i++)
         {
             for (int j = i; j > lo && less(a[j], a[j - 1], comparator); j--)
             {
                 exch(a, j, j - 1);
             }
         }
         //assert isSorted(a, lo, hi, comparator);
     }

     public static void sort2(Comparable[] a)    // 改良版本，不使用逐两元交换，而是位移 - 赋值方法
     {
         int n = a.length;
         boolean exchanges = false;
         for (int i = n - 1; i > 0; i--)   // 倒着扫描一遍，将最小元素放到开头，并统计倒序
         {
             if (less(a[i], a[i - 1]))
             {
                 exch(a, i, i - 1);
                 exchanges = true;
             }
         }
         if (exchanges == false)         // 如果没有交换，说明已经排好序了
             return;

         for (int i = 2; i < n; i++)     // 正常的排序，从第 3 元素开始
         {
             Comparable v = a[i];
             int j = i;
             for (; less(v, a[j - 1]); j--)
                 a[j] = a[j - 1];
             a[j] = v;
         }
         //assert isSorted(a);
     }

     public static void sort3(Comparable[] a)    // 改良版本，使用二分搜索寻找插入位置，减少判断次数
     {
         int n = a.length;
         for (int i = 1; i < n; i++)
         {
             Comparable v = a[i];
             int lo = 0, hi = i;
             for (; lo < hi;)
             {
                 int mid = lo + (hi - lo) / 2;
                 if (less(v, a[mid]))            // 左边强调整，右边弱调整
                     hi = mid;
                 else
                     lo = mid + 1;
             }

             for (int j = i; j > lo; --j)        // 用前面的位移 - 赋值方法
                 a[j] = a[j - 1];
             a[lo] = v;
         }
         //assert isSorted(a);
     }

     public static int[] indexSort(Comparable[] a)   // 给定数组 a 及其排序后的数组 a'，对于任意 0 ≤ i ≤ a.length - 1，
     {                                               // a'[i] == a[index[i]]，即 a 排序后第 i 位的值可用 a 和 index 来查找
         int n = a.length;
         int[] index = new int[n];
         for (int i = 0; i < n; i++)
             index[i] = i;

         for (int i = 0; i < n; i++)
             for (int j = i; j > 0 && less(a[index[j]], a[index[j - 1]]); j--)
                 exch(index, j, j - 1);
         return index;
     }

     private static boolean less(Comparable v, Comparable w)                 // v < w ?
     {
         return v.compareTo(w) < 0;
     }

     private static boolean less(Object v, Object w, Comparator comparator)  // v < w ?
     {
         return comparator.compare(v, w) < 0;
     }

     private static void exch(Object[] a, int i, int j)  // 交换
     {
         Object swap = a[i];
         a[i] = a[j];
         a[j] = swap;
     }

     private static void exch(int[] a, int i, int j)     // 间接交换，用于 indexSort
     {
         int swap = a[i];
         a[i] = a[j];
         a[j] = swap;
     }

     // 检验是否完成排序的辅助函数，4 个
     private static boolean isSorted(Comparable[] a)
     {
         return isSorted(a, 0, a.length);
     }

     private static boolean isSorted(Comparable[] a, int lo, int hi)
     {
         for (int i = lo + 1; i < hi; i++)
         {
             if (less(a[i], a[i - 1]))
                 return false;
         }
         return true;
     }

     private static boolean isSorted(Object[] a, Comparator comparator)
     {
         return isSorted(a, 0, a.length, comparator);
     }

     private static boolean isSorted(Object[] a, int lo, int hi, Comparator comparator)
     {
         for (int i = lo + 1; i < hi; i++)
         {
             if (less(a[i], a[i - 1], comparator))
                 return false;
         }
         return true;
     }

     private static void show(Comparable[] a)    // 输出结果
     {
         for (int i = 0; i < a.length; i++)
             StdOut.println(a[i]);
     }

     public static void main(String[] args)
     {
         String[] a = StdIn.readAllStrings();
         int[] index = class01.indexSort(a);

         class01.sort(a);

         show(a);
         for (int i = 0; i<a.length; i++)
             StdOut.println(index[i]);
     }
 }

● 选择排序，结构类似前面的插入排序，删掉了检查等辅助函数

 package package01;

 import java.util.Comparator;
 import edu.princeton.cs.algs4.StdIn;
 import edu.princeton.cs.algs4.StdOut;

 public class class01
 {
     private class01() {}

     public static void sort(Comparable[] a)
     {
         int n = a.length;
         for (int i = 0; i < n; i++)
         {
             int min = i;
             for (int j = i + 1; j < n; j++)
             {
                 if (less(a[j], a[min]))
                     min = j;
             }
             exch(a, i, min);
         }
     }

     public static void sort(Object[] a, Comparator comparator)
     {
         int n = a.length;
         for (int i = 0; i < n; i++)
         {
             int min = i;
             for (int j = i + 1; j < n; j++)
             {
                 if (less(a[j], a[min], comparator))
                     min = j;
             }
             exch(a, i, min);
         }
     }

     private static boolean less(Comparable v, Comparable w)
     {
         return v.compareTo(w) < 0;
     }

     private static boolean less(Object v, Object w, Comparator comparator)
     {
         return comparator.compare(v, w) < 0;
     }

     private static void exch(Object[] a, int i, int j)
     {
         Object swap = a[i];
         a[i] = a[j];
         a[j] = swap;
     }

     private static void show(Comparable[] a)
     {
         for (int i = 0; i < a.length; i++)
             StdOut.println(a[i]);
     }

     public static void main(String[] args)
     {
         String[] a = StdIn.readAllStrings();

         class01.sort(a);

         show(a);
     }
 }

● Shell 排序

 package package01;

 import edu.princeton.cs.algs4.StdIn;
 import edu.princeton.cs.algs4.StdOut;

 public class class01
 {
     private class01() {}

     public static void sort(Comparable[] a)
     {
         int n = a.length, h = 1;
         for (; h < n / 3; h = 3 * h + 1);   // a[n+1] = 3 * a[n] + 1 : 1, 4, 13, 40, 121, 364, 1093, ...
         for (; h >= 1; h /= 3)              // 使用 h 递增序列来逐步排序
         {
             for (int i = h; i < n; i++)
             {
                 for (int j = i; j >= h && less(a[j], a[j - h]); j -= h)
                     exch(a, j, j - h);
             }
             //assert isHsorted(a, h);
         }
         //assert isSorted(a);
     }

     private static boolean less(Comparable v, Comparable w)
     {
         return v.compareTo(w) < 0;
     }

     private static void exch(Object[] a, int i, int j)
     {
         Object swap = a[i];
         a[i] = a[j];
         a[j] = swap;
     }

     private static boolean isHsorted(Comparable[] a, int h) // 检查函数与前面不同，保留
     {
         for (int i = h; i < a.length; i++)
         {
             if (less(a[i], a[i - h]))
                 return false;
         }
         return true;
     }

     private static boolean isSorted(Comparable[] a)
     {
         for (int i = 1; i < a.length; i++)
             if (less(a[i], a[i - 1])) return false;
         return true;
     }

     private static void show(Comparable[] a)
     {
         for (int i = 0; i < a.length; i++)
             StdOut.println(a[i]);
     }

     public static void main(String[] args)
     {
         String[] a = StdIn.readAllStrings();

         class01.sort(a);

         show(a);
     }
 }