Java实现8种排序算法的示例代码

public static void bubbleSort(int[] a) {
    //临时变量
    int temp;
    //i是循环次数,也是冒泡的结果位置下标，5个数组循环5次
    for (int i = 0; i  i; j--) {
        //让小的数字排在前面
        if (a[j] 

public static void selectSort(int[] a) {
    //临时变量
    int temp;
    //i是循环次数,也是选择交换的结果的位置下标，5个数组循环5次
    for (int i = 0; i  a[j]) {
          min = j;
        }
      }
      temp = a[i];
      a[i] = a[min];
      a[min] = temp;
    }
  }

public static void insertSort(int[] a) {
    int temp;
    //i是循环次数,也是插入的队列的长度，最后一位是a[i]
    //所以一开始a[0]是排好的一个队列，比较a.length-1次，最后一次循环是a[a.length-1]插入a[0]~a[a.length-2]
    for (int i = 0; i  0; j--) {
        //如果插入的数小，交换位置
        if (a[j] 

public static void shellSort(int[] a) {
    int temp;
    int d = a.length;
    for (; ; ) {
      d = d / 2;
      //根据差值分组为子序列
      for (int k = 0; k  k; j -= d) {
            //如果插入的数小，交换位置
            if (a[j] 

public void quickSort(int a[], int l, int r) {
    //左边必须大于右边
    if (l >= r) {
      return;
    }
    int i = l;
    int j = r;
    //选择第一个数为基准
    int base = a[l];
    while (i  base) {
        j--;
      }
      //从左向右找第一个大于base的值,如果小于右移一位，直到找到大值或者i/j重合
      while (i 

private static void mergeSort(int[] a, int first, int last, int temp[]) {
    if (first 

public static void heapSort(int a[]) {
    //堆顶最大值和数组最后（叶节点）交换 长度-1 次
    for (int i = a.length - 1; i > 0; i--) {
      //构建大顶堆（最大堆）
      buildHeap(a, i);
      //堆顶最大值和数组最后（叶节点）交换
      swap(a, 0, i);
    }
  }

  //构建大顶堆（最大堆）
  public static void buildHeap(int a[], int lastIndex) {
    //排最后的非叶节点为 长度/2-1，从第i检查到堆顶第0项，上浮大值
    for (int i = (lastIndex + 1) / 2 - 1; i >= 0; i--) {
      //必定存在的左叶节点，不一定存在的右叶节点
      int left = i * 2 + 1;
      int right = i * 2 + 2;
      //max为左右叶节点中的最大值
      int max = left;
      if (right <= lastIndex) {
        if (a[left] 

public static void radixSort(int[] a) {
    //位数
    int digit = 1;
    //作为排序后数组的新下标
    int newIndex = 0;
    //供基数排序使用的二维数组，第一维度固定10位0~9，第二维度根据下标依次存放每次基数排序的结果
    int[][] cOntainer= new int[10][a.length];
    //第一维度每个数组的内容计数，最少为10，防止数组全是个位数时越界，例如五位数组最大值为8，counter.length=5 ，counter[8]就越界
    int counterLength = 10;
    if (a.length > 10) {
      counterLength = a.length;
    }
    int[] counter = new int[counterLength];
    //算出数组中最大的值，用来确定最大位
    int max = a[0];
    int maxDigit = 0;
    for (int i = 0; i  max) {
        max = a[i];
      }
    }
    while (max > 0) {
      max /= 10;
      maxDigit++;
    }
    //对每位进行排序
    while (digit <= maxDigit) {
      //对每个数值该位取余,container[remainder]，并计数该位置上数值的下标counter[remainder]
      for (int num : a) {
        int remainder = (num / digit) % 10;
        container[remainder][counter[remainder]] = num;
        counter[remainder]++;
      }
      //将上一步放入容器的数值依次覆盖到远数组中
      for (int i = 0; i <10; i++) {
        for (int j = 0; j