常见排序算法

---------------------------稳定的

--------------------------------------------------------------冒泡算法

/**
 * 冒泡排序算法的运作如下： 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
 * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 
 * 针对所有的元素重复以上的步骤，除了最后一个。
 * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
 * @param arr int[] 需要排序的数组
 * @return arr排序完成的数据
 */
public int[] sort(int[] arr) {
    int temp = 0;
    for (int i = arr.length - 1; i > 0; --i) {
        for (int j = 0; j < i; ++j) {//从开始第一对到结尾的最后一对
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}

-------------------------------------------------------------------直接插入排序

/**
 * 直接插入排序
 * (1)设置监视哨r[0]，将待插入纪录的值赋值给r[0]； 
 * (2)设置开始查找的位置j； 
 * (3)在数组中进行搜索，搜索中将第j个纪录后移，直至r[0].key≥r[j].key为止； 
 * (4)将r[0]插入r[j+1]的位置上。
 * @param arr 需要排序的数组
 * @return 排序完成的数组
 */
public int[] sort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int temp = arr[i];
        int j = i-1;
        for (; j >= 0; j--) {
            if(temp<arr[j]) {
                arr[j+1] = arr[j];
            } else {
                break;
            }
        }
        arr[j+1] = temp;
    }
    return arr;
}

-----------------------------------------------------------------------二分插入排序(折半插入排序)

/**
 * 折半排序算法 
 * 在将一个新元素插入已排好序的数组的过程中，寻找插入点时， 将待插入区域的首元素设置为a[low]，末元素设置为a[high]，
 * 则轮比较时将待插入元素与a[m]，其中m=(low+high)/2相比较,
 * 如果比参考元素小，则选择a[low]到a[m-1]为新的插入区域(即high
 * =m-1)，否则选择a[m+1]到a[high]为新的插入区域（即low=m+1），
 * 如此直至low<=high不成立，即将此位置之后所有元素后移一位 ，并将新元素插入a[high+1]。
 * @param arr 需要排序的数组
 * @return 排序完成的数组
 * ？如果是递归应该怎么做？
 */
public int[] sort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int temp = arr[i];
        int low = 0;
        int high = i - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (temp < arr[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        for (int j = i; j >= low + 1; j--) {
            arr[j] = arr[j - 1];
        }
        arr[high+1] = temp;
    }
    return arr;
}

-----------------------不稳定的

--------------------------------------------------------------------------选择排序

/**
 * 选择排序
 * 对着一群数组说,你们谁最小出列,站到最后边
 * 然后继续对剩余的无序数组说,你们谁最小出列,站到最前边
 * 再继续刚才的操作,一直到最后一个,继续站到最前边,现在数组有序了,从小到大
 * @param arr 需要排序的数组
 * @return 排序完成的数组
 */
public int[] sort(int[] arr) {
    int minIndex = 0;
    int temp = 0;
    for (int i = 0; i < arr.length - 1; i++) {
        minIndex = i;// 无序区的最小数据数组下标
        for (int j = i + 1; j < arr.length; j++) {
            // 在无序区中找到最小数据并保存其数组下标
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            // 如果不是无序区的最小值位置不是默认的第一个数据，则交换之。
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
    return arr;
}

--------------------------------------------------------------------------希尔排序

/**
 * 希尔排序 先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。
 * 先在各组内进行直接插入排序；然后，取第二个增量d2=d1-1重复上述的分组和排序，直至所取的增量 =1,
 * 即所有记录放在同一组中进行直接插入排序为止。
 * @param arr 需要排序的数组
 * @return 排序完成的数组
 */
public int[] sort(int[] arr) {
    int d = arr.length / 2;
    while (true) {
        for (int i = 0; i < d; i++) {// 分成几组，循环几次
            for (int j = i; j + d < arr.length; j += d) {// 组内成员两两比较，从小到大排列
                int temp;
                if (arr[j] > arr[j + d]) {
                    temp = arr[j];
                    arr[j] = arr[j + d];
                    arr[j + d] = temp;
                }
            }
        }
        if (d == 1) {
            break;
        }
        d--;
    }
    return arr;
}

--------------------------------------------------------------------------快速排序

/**
 * 1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
 * 2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
 * 3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
 * 4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。
 * @param arr 需要排序的数组
 * @param low 首元素
 * @param high 末元素
 * @return 排序完成的数组
 */
public int[] sort(int[] arr, int l, int r) {
    if (l < r) {
        int i = l, j = r, x = arr[l];
        while (i < j) {
            while (i < j && arr[j] >= x)
                // 从右向左找第一个小于x的数
                j--;
            if (i < j)
                arr[i++] = arr[j];
            while (i < j && arr[i] < x)
                // 从左向右找第一个大于等于x的数
                i++;
            if (i < j)
                arr[j--] = arr[i];
        }
        arr[i] = x;
        arr = sort(arr, l, i - 1); // 递归调用
        arr = sort(arr, i + 1, r);
    }
    return arr;
}

--------------------------------------------------------------------------