Java排序算法之冒泡、选择、插入、快速

JavaSort

Java经典排序算法代码

2018-1-26更新：冒泡排序，选择排序，插入排序，快速排序

1. 冒泡排序

• 特点：效率低，实现简单
• 思想（从小到大排）： 第1个数和第2个数比较，如果第1个数比第2个数小，则不动，如果第1个比第2个大，则交换。再比较第2个和第3个，如果第2个数比3个数小，则不动，如果第2个比第3个大，则交换。以此类推往后进行比较。一趟结束后，最大的数应该在最后一个（也可从后往前排）

public static void bubbleSort(int arr[]) {
    for(int i=0;i<arr.length-1;i++) {
        for(int j=0;j<arr.length-1-i;j++) {
            if(arr[j]>arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

2. 选择排序

• 特点：效率低，容易实现。
• 第一趟->第一个数和后面的数依次比较，大就换，小就不动，第一趟结束，第一个数为最小的数。第二趟->第二个数和后面的数依次比较，大就换，小就不动，第二趟结束，第二个数为第二小的数。
• 参考文章：https://www.cnblogs.com/shen-hua/p/5424059.html

public static void selectSort(int arr[]) {
    for(int i=0;i<arr.length-1;i++) {
        for(int j=i+1;j<arr.length;j++) {
            if(arr[i]>arr[j]) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

3. 插入排序

• 特点：效率低，容易实现。
• 分而治之的思想。就是把一串数字分成有序和无序的两部分。比如 8 3 2 5，首先把8看成有序（他就一个数，当然有序），然后 3 2 5就是无序的部分，再把3 2 5 中的 3 拿出来作为有序的部分 和 之前排好的有序部分 8 进行比较，发现 3 比 8 小，交换 现在排好的有序部分为 3 8,剩下的无序部分为 2 5 ，在剩下无序部分中把 2 看成有序，和排好的 3 8 依次比较，发现比3 小 ，交换 ，现在左边排好的是 2 3 8 ，还剩一个5.继续依次和排好的比较，2 比 5小，不交换，3 比 5 小不交换， 8 比5 大，交换，所以新的数组 2 3 5 8。
• 参考文章：https://www.cnblogs.com/loveyoume/p/6261941.html

public static void insertSort(int arr[]) {
    for(int i=1;i<arr.length;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;
            }
        }
    }
}

4. 快速排序

• 特点：高效，时间复杂度为nlogn。
• 思想：设置2个指针low指向第一个数，指针high指向最后一个数，high从后往前找，和low的数比较，如果high的数比low的数小，交换.此时high不动，low从前往后找，找到一个数比high大，交换，直到low，high指向同一个数，结束第一次排序。
• 参考文章：http://blog.csdn.net/as02446418/article/details/47395867

public static void quickSort(int arr[],int low,int high) {

    int start = low;
    int end = high;
    int key = arr[low];
    if(end<start) {
        return;
    }
    while(end>start) {
        //从后往前比
        while(end > start && arr[end] >= key) {//如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
            end--;
            if(arr[end]<=key) {
                int temp = arr[end];
                arr[end] = arr[start];
                arr[start] = temp;
            }
        }
        //从前往后比
        while(end > start && arr[start]<=key) {//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
            start++;
            if(arr[start]>=key) {
                int temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
        }
        //此时第一次循环比较结束，关键值的位置已经确定了。
        //左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
    }
    //递归
    if(start>low) quickSort(arr,low,start-1);//左边序列。第一个索引位置到关键值索引-1
    if(end<high) quickSort(arr,end+1,high);  //右边序列。从关键值索引+1到最后一个
}

详细代码可以去我的Github：https://github.com/weiliangchun/JavaSort

Java初级开发技术交流群：619201650。欢迎加入进行技术交流，禁止闲聊、斗图。