java五种排序算法汇总工具类

下面是编程之家 jb51.cc 通过网络收集整理的代码片段。

编程之家小编现在分享给大家，也给大家做个参考。

这个工具类简单明了地总结了java的快速排序，希尔排序，插入排序，堆排序，归并排序五种排序算法，代码中并没有对这几种排序算法的一个说明，关于思想部分希望在自行查阅相关说明，这里只是对这几种算法进行一个概括，以供大家使用。

public class Sort {
  public static <AnyType extends Comparable<? super AnyType>> void insertionSort(AnyType[] a) {
    insertionSort(a,a.length - 1);
  }

  private static <AnyType extends Comparable<? super AnyType>> void insertionSort(AnyType[] a,int left,int right) {
    int j;  // 记录第一个比tmp小的元素的后边一位的位置

    for (int p = left; p <= right; p++) {
      AnyType tmp = a[p];
      for (j = p; j > left && tmp.compareTo(a[j - 1]) < 0; j--) {
        a[j] = a[j - 1];
      }
      a[j] = tmp;
    }
  }

  public static <AnyType extends Comparable<? super AnyType>> void shellSort(AnyType[] arr) {
    int j;

    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
      for (int i = gap; i < arr.length; i++) {
        AnyType tmp = arr[i];
        for (j = i; j >= gap && tmp.compareTo(arr[j - gap]) < 0; j -= gap) {
          arr[j] = arr[j - gap];
        }
        arr[j] = tmp;
      }
    }
  }

  private static int leftChild(int i) {
    return i * 2 + 1;
  }

  private static <AnyType extends Comparable<? super AnyType>> void perculateDown(AnyType[] arr,int i,int size) {
    AnyType tmp = arr[i];

    for (int child; (child = leftChild(i)) < size; i = child) {
      if (child != size - 1 && arr[child].compareTo(arr[child + 1]) < 0) {
        child++;
      }
      if (tmp.compareTo(arr[child]) < 0) {
        arr[i] = arr[child];
      } else {
        break;
      }
    }
    arr[i] = tmp;
  }

  public static <AnyType extends Comparable<? super AnyType>> void heapSort(AnyType[] arr) {
    for (int i = arr.length / 2; i >= 0; i--) {
      perculateDown(arr,i,arr.length);
    }
    for (int i = arr.length - 1; i >= 0; i--) {
      swapReferences(arr,i);
      perculateDown(arr,i);
    }
  }

  private static <AnyType extends Comparable<? super AnyType>> void swapReferences(AnyType[] arr,int j) {
    AnyType tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
  }

  public static <AnyType extends Comparable<? super AnyType>> void mergeSort(AnyType[] arr) {
    AnyType[] tmp = ((AnyType[]) new Comparable[arr.length]);
    mergeSort(arr,arr.length - 1,tmp);
  }

  private static <AnyType extends Comparable<? super AnyType>> void mergeSort(AnyType[] arr,int start,int end,AnyType[] tmp) {
    if (start < end) {
      int mid = (start + end) >> 1;
      mergeSort(arr,start,mid,tmp);
      mergeSort(arr,mid + 1,end,tmp);
      merge(arr,tmp);
    }
  }

  private static <AnyType extends Comparable<? super AnyType>> void merge(AnyType[] arr,int mid,AnyType[] tmp) {
    int i = start,j = mid + 1,k = start;
    while (i <= mid && j <= end) {
      if (arr[i].compareTo(arr[j]) < 0) {
        tmp[k++] = arr[i++];
      } else {
        tmp[k++] = arr[j++];
      }
    }

    while (i <= mid) {
      tmp[k++] = arr[i++];
    }

    while (j <= end) {
      tmp[k++] = arr[j++];
    }

    for (int m = start; m <= end; m++) {
      arr[m] = tmp[m];
    }
  }

  public static <AnyType extends Comparable<? super AnyType>> void quickSort(AnyType[] arr) {
    quickSort(arr,arr.length - 1);
  }

  private static <AnyType extends Comparable<? super AnyType>> void quickSort(AnyType[] arr,int right) {
    if (left + LENGTH_DIFF <= right) {

      AnyType pivot = medium(arr,left,right);

      int i = left,j = right;
      while (true) {
        while (arr[++i].compareTo(pivot) < 0);
        while (arr[--j].compareTo(pivot) > 0);

        if (i < j) {
          swapReferences(arr,j);
        } else {
          break;
        }
      }

      swapReferences(arr,right);
      quickSort(arr,i - 1);
      quickSort(arr,i + 1,right);
    } else {
      insertionSort(arr,right);
    }
  }

  private static <AnyType extends Comparable<? super AnyType>> AnyType medium(AnyType[] arr,int right) {
    int center = (left + right) / 2;
    if (arr[center].compareTo(arr[left]) < 0) {
      swapReferences(arr,center,left);
    }
    if (arr[left].compareTo(arr[right]) > 0) {
      swapReferences(arr,right);
    }
    if (arr[center].compareTo(arr[right]) < 0) {
      swapReferences(arr,right);
    }
    
    return arr[right];
  }

  private final static int LENGTH_DIFF = 20;
}

以上是编程之家(jb51.cc)为你收集整理的全部代码内容，希望文章能够帮你解决所遇到的程序开发问题。

如果觉得编程之家网站内容还不错，欢迎将编程之家网站推荐给程序员好友。