Java 排序算法

1、归并排序：

public class MergeSort {
    public static void main(String[] args) {
        int[] ans = {6, 8, 4, 4, 6, 36, 673, 13, 6, 7, 3, 4, 6, 8, 3, 7, 5, 7, 9, 5};
        System.out.print("原数组：");
        for (int i = 0; i < ans.length; i++) {
            System.out.print(ans[i]+",");
        }
        System.out.println();
        mergeSort(ans);
        System.out.print("归并排序之后的数组：");
        for (int i = 0; i < ans.length; i++) {
            System.out.print(ans[i]+",");
        }
    }

    //sort方法的驱动程序
    private static void mergeSort(int[] ans) {
        sort(ans, 0, ans.length - 1);
    }

    //将tmp和Cctr当做参数传入，方便调用merge方法时获得这两个参数
    private static void sort(int[] ans, int left, int right) {
        int mid = (left + right) / 2;
        //当分到只剩下一个元素的情况,则退出递归程序
        if (left >= right) {
            return;
        }
        sort(ans, left, mid);
        sort(ans, mid + 1, right);
        merge(ans, left, mid, right);
    }

    private static void merge(int[] ans, int left, int mid, int right) {
        //声明三个计时器
        int Actr = left;
        int Bctr = mid + 1;
        int Cctr = 0;
        int lenA = mid - left + 1;
        int lenB = right - mid;
        //创建临时数组,长度为A，B数组长度之和
        int[] tmp = new int[right - left + 1];
        //循环A，B中长度较短的长度次数的二倍的次数
        while (Actr <= mid && Bctr <= right) {
            if (ans[Actr] <= ans[Bctr]) {
                tmp[Cctr++] = ans[Actr];
                Actr++;
            } else {
                tmp[Cctr++] = ans[Bctr];
                Bctr++;
            }
        }
        //如果左边的还有剩余，将左边剩余的归并
        while (Actr <= mid){
            tmp[Cctr ++] = ans[Actr ++];
        }
        //如果右边的还有剩余，将右边剩余的归并
        while (Bctr <= right){
            tmp[Cctr ++] = ans[Bctr ++];
        }
        //将临时数组更新到原数组
        for (int i = 0; i < tmp.length; i++) {
            ans[left++] = tmp[i];
        }
    }
}

 

快速排序：

public class QuickSort {

    

    /**

     * 根据下标交换数组的两个元素

     * @param arr 数组

     * @param index1  下标1

     * @param index2  下标2

     */

    public static void swap(int[] arr, int index1, int index2) {

        int temp = arr[index1];

        arr[index1] = arr[index2];

        arr[index2] = temp;

    }

    

    /**

     * 递归循环实现快排

     * @param arr 数组

     * @param startIndex 快排的开始下标

     * @param endIndex 快排的结束下标

     */

    public static void quickSort(int[] arr, int startIndex, int endIndex) {

        if(arr != null && arr.length > 0) {

            int start = startIndex, end = endIndex;

            //target是本次循环要排序的元素，每次循环都是确定一个元素的排序位置，这个元素都是开始下标对应的元素

            int target = arr[startIndex];

            //开始循环，从两头往中间循环，相遇后循环结束

            while(start<end) {

                //从右向左循环比较，如果比target小，就和target交换位置，让所有比target小的元素到target的左边去

                while(start < end) {

                    if(arr[end] < target) {

                        swap(arr, start, end);

                        break;

                    }else {

                        end--;

                    }

                }

                

                //从左向右循环比较，如果比target大，就和target交换位置，让所有比target大的元素到target的右边去

                while(start < end) {

                    if(arr[start] > target) {

                        swap(arr, start, end);

                        break;

                    }else {

                        start++;

                    }

                }

            }

            //确定target的排序后，如果target左边还有元素，继续递归排序

            if((start-1)>startIndex) {

                quickSort(arr, startIndex, start-1);

            }

            //确定target的排序后，如果target右边还有元素，继续递归排序

            if((end+1)<endIndex) {

                quickSort(arr, end+1, endIndex);

            }

        }

    }

    

    public static void main(String[] args) {

        int[] arr = new int[]{4,1,8,5,3,2,9,10,6,7};

        quickSort(arr,0,9);

        for (int i = 0; i < arr.length; i++) {

            System.out.print(arr[i]+",");

        }

    }

}