面试常见五种排序算法

1.冒泡排序

• 思路：两两交换，大的放在后面，第一次排序后最大值已在数组末尾。因为俩俩交换，需要n-1趟排序（比如10个数，需要9趟排序）
• 代码实现要点：两个for循环，外层循环控制排序的趟数，内层循环控制比较的次数。
• 空间复杂度O（1） 时间复杂度O（n²）
• 稳定性：稳定

public class 冒泡排序 {//空间复杂度O（1） 时间复杂度O（n²）
    public static void main(String[] args) {
        int[] arr=new int[]{2,1,7,9,5,8};
        for(int i=0;i<arr.length-1;i++) {
            for(int j=0;j<arr.length-i-1;j++) {
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i:arr){
            System.out.print(i+" ");
        }
    }
}

2.选择排序

• 思路：找到数组中最大或最小的元素，与数组最后（最前）一位元素交换。当只有一个数时，则不需要选择了，因此需要n-1趟排序
• 代码实现要点：两个for循环，外层循环控制排序的趟数，内层循环找到当前趟数的最小值，随后与当前趟数组第一的一位元素交换
• 空间复杂度O（1） 时间复杂度O（n²）
• 稳定性：不稳定

public class 选择排序 {
    public static void main(String[] args) {
        int[] arr = {49, 38, 65, 97, 76, 13, 27, 49};
        selectSort(arr, arr.length);
        System.out.println(Arrays.toString(arr));
    }
    public static void selectSort(int[] arr, int n) {
        for (int i = 0; i < n - 1; i++) {
            int index = i;
            int j;
            // 找出最小值得元素下标
            for (j = i + 1; j < n; j++) {
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            int tmp = arr[index];
            arr[index] = arr[i];
            arr[i] = tmp;
        }
    }
}

3.插入排序

将一个元素插入到已有序的数组中，在初始时未知是否存在有序的数据，因此将元素第一个元素看成是有序的。与有序的数组进行比较，
比它大则直接放入，比它小则移动数组元素的位置，找到个合适的位置插入。当只有一个数时，则不需要插入了，因此需要n-1趟排序

• 空间复杂度O（1） 时间复杂度O（n²）
• 稳定性：稳定

public class 插入排序 {//空间复杂度O（1） 时间复杂度O（n²）
    public static void main(String[] args) {
        int[] nums=new int[]{2,1,7,9,5,8};
        for(int i=1,j,current;i<nums.length;i++){
            current=nums[i];
            for(j=i-1;j>=0&&nums[j]>current;j--){
                nums[j+1]=nums[j];
            }
            nums[j+1]=current;
        }
        for(int i:nums){
            System.out.print(i+" ");
        }
    }
}

4.快速排序

在数组中找一个元素(节点)，比它小的放在节点的左边，比它大的放在节点右边。一趟下来，比节点小的在左边，比节点大的在右边。不断执行这个操作

• 空间复杂度O（nlogn） 时间复杂度O（nlogn）
• 稳定性：不稳定

public class 快速排序 {//算法时间复杂度：T（nlongn），空间复杂度：O（logn）
    public static int[] qsort(int arr[],int start,int end) {
        int pivot = arr[start];
        int i = start;
        int j = end;
        while (i<j) {
            while ((i<j)&&(arr[j]>pivot)) { j--; }
            while ((i<j)&&(arr[i]<pivot)) { i++; }
            if ((arr[i]==arr[j])&&(i<j)) { i++; }
            else {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        if (i-1>start) arr=qsort(arr,start,i-1);
        if (j+1<end) arr=qsort(arr,j+1,end);
        return arr;
    }
}

5.归并排序

将两个已排好序的数组合并成一个有序的数组。将元素分隔开来，看成是有序的数组，进行比较合并。不断拆分和合并，直到只有一个元素。

• 空间复杂度O（n） 时间复杂度O（nlogn）
• 稳定性：稳定

public class 归并排序 {//时间复杂度T（nlog(n)） 空间复杂度O（n）
    public static int[] mergeSort(int[] nums, int l, int h) {
        if (l == h) return new int[] { nums[l] };
        int mid = l + (h - l) / 2;
        int[] leftArr = mergeSort(nums, l, mid); //左有序数组
        int[] rightArr = mergeSort(nums, mid + 1, h); //右有序数组
        int[] newNum = new int[leftArr.length + rightArr.length]; //新有序数组
        int m = 0, i = 0, j = 0;
        while (i < leftArr.length && j < rightArr.length) {
            newNum[m++] = leftArr[i] < rightArr[j] ? leftArr[i++] : rightArr[j++];
        }
        while (i < leftArr.length)
            newNum[m++] = leftArr[i++];
        while (j < rightArr.length)
            newNum[m++] = rightArr[j++];
        return newNum;
    }
}