四大排序算法（Java版本）-面试必备（冒泡，选择，插入，快速）

---

一、冒泡排序

基本思想：冒泡排序就是，它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

下面是动图演示

java代码：

/**
 * 冒泡排序
 * 1.从当前元素起，向后依次比较每一对相邻元素，若逆序则交换
 * 2.对所有元素均重复以上步骤，直至最后一个元素。
 */
public class TwoNums {
    public static void main(String[] args) throws CloneNotSupportedException {
        int[] arr = new int[]{1,4,3,6,7,5,2,8,9};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int[] arr){
        int len = arr.length;
        for(int i=0;i<len-1;i++){//外循环为排序趟数，len个数进行len-1趟
            for(int j=0;j<len-1-i;j++){//内循环为每趟比较的次数，第i趟比较len-i次
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

二、选择排序

基本思想：它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

动图演示：

java代码：

/**
 * 选择排序
 * 1.每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处
 * 的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
 * 2.交换第一个索引处和最小值所在的索引处的值
 */
public class TwoNums2 {
    public static void main(String[] args){
        int[] arr = new int[]{1,4,3,6,7,5,2,8,9};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int[] arr){
        int len = arr.length;
        for(int i=0;i<len-1;i++){
            //假定本次遍历，最小值所在的索引是i
            int minIndex = i;
            for(int j=i+1;j<len;j++){
                if(arr[j]<arr[minIndex]){
                    //跟换最小值所在的索引
                    minIndex = j;
                }
            }
            //交换i索引处和minIndex索引处的值
            swap(arr,i,minIndex);
        }
    }
    public static void swap(int[] arr,int i,int minIndex){
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

三、插入排序

基本思想：插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动

动图演示

代码：

/**
 * 插入排序：
 * 选择排序和插入排序，这两种排序方法都会将原数组分为两个部分：待排序数组与已排好序的数组，
 */
public class TwoNums3 {
    public static void main(String[] args) {
        int[] arr = new int[]{1,4,3,6,7,5,2,8,9};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int[] arr){
        //代码就不写注释了，如果后面看不懂就去看看黑马pdf
        int len = arr.length;
        for(int i=1;i<len;i++){
            for(int j=i-1;j>=0;j--){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }else{
                    break;
                }
            }
        }
    }
}

四、快速排序

基本思想：快速排序（Quick Sort）是从冒泡排序算法演变而来的，实际上是在冒泡排序基础上的递归分治法。快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分。

动如演示：

代码：

/**
 * 快速排序
 */
public class TwoNums4 {
    public static void main(String[] args) {
        int[] arr = new int[]{1,4,3,6,7,5,2,8,9};
        sort(arr,0,8);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int[] arr,int start,int end){
        if(start>end) return;
        int base = arr[start];
        int i = start;
        int j = end;
        while(i<j){
            while(i<j && arr[j]>=base) j--;
            while(i<j && arr[i]<=base) i++;
            if(i<j){
                swap(arr,i,j);
            }
        }
        swap(arr,start,i);
        sort(arr,start,i-1);
        sort(arr,j+1,end);
    }
    public static void swap(int[] nums,int left,int right){
        int temp=nums[left];
        nums[left]=nums[right];
        nums[right]=temp;
    }

---

总结

以上就是我总结的四种排序算法，仅仅提供了代码实现，要结合着动图和每一章排序算法的基本思想来看，代码不是很难理解。面试经常让手写排序算法，一定要理解并记下来。