二分查找，插入排序，归并排序三者练习，加上泛型

由于最近在学习数据结构和算法之美时用到了一些排序和查找的算法，所以在这块列出。

以下示例皆为Java代码，文中由于顺带练习泛型所以写了基于泛型泛型的代码，纯粹就是分享一下，希望专注于算法本身的去下面的网站看就好了，有图解，有代码、顺便练练英语
以下图片来自 geeksforgeeks

1. 二分查找

   binary-search

   

   就像我们平时猜数一样，一堆数组，我们要查一个数，我们先找到数组的中间元素，如果它比我们要查找的元素小，就在它前面找，否则在它后面找。

   本来想专注于算法本身的，后来想着也是顺带着练练泛型。

   public class BinarySearch {
       public static <T> int indexOf(T[] array, Comparator<? super T> comparator, T value) {
           if (value == null) {
               for (int i = 0; i < array.length; i++) {
                   if (array[i] == null) {
                       return i;
                   }
               }
               return -1;
           } else {
               int start = 0;
               int end = array.length - 1;
               int mid;
   
               while (start <= end) {
                   mid = (start + end) / 2;
                   if (comparator.compare(value, array[mid]) == 0) {
                       return mid;
                   } else if (comparator.compare(value, array[mid]) < 0) {
                       end = mid - 1;
                   } else {
                       start = mid + 1;
                   }
               }
   
               return -1;
           }
       }
   }
   

2. 插入排序也是。看这个网站的视频就可以搞懂了insertion-sort。

   

   public class InsertionSort implements ArraySort{
       @Override
       public <T> void sort(T[] array, Comparator<? super T> comparator) {
           for (int i = 1; i < array.length; i++) {
               T key = array[i];
               int j = i - 1;
   
               while (j >= 0 && comparator.compare(key, array[j]) < 0) {
                   array[j + 1] = array[j];
                   j--;
               }
               array[j + 1] = key;
           }
       }
   }
   

3. 折半插入排序（二分和插入排序结合）

   public class BinarySort implements ArraySort{
       @Override
       public <T> void sort(T[] array, Comparator<? super T> comparator) {
           for (int i = 1; i < array.length; i++) {
               T key = array[i];
   
               int start = 0;
               int end = i - 1;
               int mid;
   
               while (start <= end) {
                   mid = (start + end) / 2;
                   if (comparator.compare(key, array[mid]) < 0) {
                       end = mid - 1;
                   } else {
                       start = mid + 1;
                   }
               }
   
               for (int j = i - 1; j >= start; j--) {
                   array[j + 1] = array[j];
               }
               array[start] = key;
           }
       }
   }
   

4. 递归版的归并排序。

   

   public class RecursionMergeSort implements ArraySort {
   
       @SuppressWarnings("unchecked")
       private <T> void combine(T[] array, Comparator<? super T> comparator, int from, int mid, int to) {
           int i = from;
           int j = mid + 1;
           int k = 0;
   
           Object[] result = new Object[to - from + 1];
           while (i < mid + 1 && j <= to) {
               if (comparator.compare(array[i], array[j]) < 0) {
                   result[k++] = array[i++];
               } else {
                   result[k++] = array[j++];
               }
           }
   
           while (i < mid + 1) {
               result[k++] = array[i++];
           }
   
           while (j <= to) {
               result[k++] = array[j++];
           }
   
           int x = from;
           for (int y = 0; y < k; y++) {
               array[x++] = (T) result[y];
           }
       }
   
       private <T> void mergeSort(T[] array, Comparator<? super T> comparator, int from, int to) {
           if (to - from == 0) {
               return ;
           }
   
           int mid = (from + to) / 2;
           mergeSort(array, comparator, from, mid);
           mergeSort(array, comparator, mid + 1, to);
           combine(array,comparator, from, mid, to);
       }
   
       @Override
       public <T> void sort(T[] array, Comparator<? super T> comparator) {
           mergeSort(array, comparator,0, array.length - 1);
       }
   }