常用的排序算法

常用的排序算法（java实现）

冒泡排序

冒泡排序就是从数组的一端开始，让数组中的相邻两个数逐一比较，以降序排序4，5，1，2，3来举例，第一次4和5比较，因为4小于5，所以4,5要调换位置，4，5，1，2，3 ——>5，4，1，2，3，之后比较下标为1和下标为2的数，也就是4和1比较，因为4大于1，所以不交换顺序，依次按照此逻辑执行，结束后数组为5，4，2，3，1，最小的1到了数组的最后面，冒泡排序之所以叫冒泡排序，正是因为这种排序算法的每一个元素都可以向小气泡一样，根据自身大小，向着数组的一侧移动。每一轮都会将数组中最小的移动到数组的最右端，当除了最大的数其它所有数都按顺序排序完成了，那么最大那个数自然也找到了自己的位置。当一个数组长度为n，只要执行n-1次就可以完成排序。

代码实现：

public static void changeSort(int[] arr){
        for(int i=0; i<arr.length-1; i++)//交换长度减1次
            for (int j=0; j<arr.length-i-1; j++){
                if(arr[j] < arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
    }

 

选择排序

选择排序非常好理解，以升序排序为例，就是每次找出数组里的最大的数将其放到左边，之后对放置完的数之外的数进行相同操作，执行长度-1次就能完成排序。

代码实现：

for (int i=0; i<arr.length-1; i++){//执行length-1轮
            int min = arr[i];//记录这一轮中的最小值
            int index = i;//记录要交换的下标
            for(int j=i+1; j<arr.length; j++){
                if(arr[j] < min){
                    min = arr[j];
                    index = j;
                }
            }
            //交换最左边的数和最小值
            int temp = arr[i];
            arr[i] = min;
            arr[index] = temp;
        }

 

插入排序

默认从第二个数据开始比较。如果第二个数据比第一个小，则交换。然后在用第三个数据比较，如果比前面小，则插入（交换）。否则，退出循环

说明：默认将第一数据看成有序列表，后面无序的列表循环每一个数据，如果比前面的数据小则插入（交换）。否则退出。

代码实现：

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

 

快速排序

先拿一组数举例5,4,1,3,2,9,0,6,8,7，先找到一个数作为基准数，一般都用数组的第一个数作为基准数，称之为pivot数，这组数中的第一位5就是基准数。要做的事情就是实现基准数左边的数都小于基准数，右边的数都大于基准数，现在我们要定义两个指针一个指向左边最低位，一个指向右边最高位，右边的指针先开始走，当遇到了小于基准数的位置停下来，之后，左边的指针开始走，直到找到比基准数大的数停下来，然后将两个指针的数交换，再重复上述行为。当左右指针在同一位置相交，将基准数与该位置的数交换，这样就实现了基准数左边都是小于基准数，右边都是大于基准数。之后对基准数左右两边分别进行相同操作，就能实现将数组从小到大排序。

 如果让左边低位的指针先走会怎么样呢？如果低位的指针先走的话，肯定会在第一个大于基准数的位置停下来，然后高位的指针会在这个位置与低位指针相遇，然后该位置的数与基准数交换之后，该位置的数就到了基准数左边，但是显然这个数比基准数大，应该要移到基准数右边。如果高位指针先走的话，就能一定保证在比基准数小的数的位置停下来。

代码实现：

public static void quickSort(int[] arr, int start, int end){
        //start和end参数标记需要排序的数组下标区间
        if(start>=end)
            return;//排序结束
        int pivot = arr[start];//默认把数组的第一位当成基准值
        int low = start;//标记数组高位的指针
        int high = end;//标记数组低位的指针

        while (low<high){

            while (low<high && arr[high]>=pivot){
                //如果高位的数大于等于基准数，则指针递减
                high--;
            }

            while (low<high && arr[low]<=pivot){
                //如果低位的数小于于等于基准数，则指针递增
                low++;
            }

            //当出现高位数小于基准数，低位数大于基准数时将其交换
            if(low<high){
                int temp = arr[low];
                arr[low] = arr[high];
                arr[high] = temp;
            }
        }
        //最后将基准数与low和high相等位置的数字交换
        arr[start] = arr[low];
        arr[low] = pivot;
        //分别对基准数左右两边区间进行递归
        quickSort(arr, start, low-1);
        quickSort(arr, low+1, end);
    }

 

常见的排序算法信息

 

 

 

什么是稳定性？

稳定性定义：

排序前后两个相等的数相对位置不变，则算法稳定。