两种常用的交换排序算法--冒泡排序、快速排序

本文介绍两种常用的交换排序算法：

1、冒泡排序算法 平均时间复杂度O（n^2） 稳定的排序算法

2、快速排序 最差时间复杂度为O（n^2） 但是平均时间复杂度为O（n ln n） 最坏情况下空间复杂度为O（n） 最好情况下空间复杂度为O（ln n）

下面用java代码来说明算法思路：

1、冒泡排序算法：

public class ExchangeRanker {
    //冒泡排序 不断比较相邻两个元素的大小，对这两个元素进行交换操作 每一趟交换之后都能增加一个最大（小）的元素
    public static void bubbleSort(int[] arr){
        /**
         * 冒泡排序 平均时间复杂度为o(n^2) 是稳定的排序算法 
         * */
        int i = 0, j = 0;
        for(i=0 ; i<arr.length ; i++){//第i趟比较
            boolean exchange = false;//判断是否交换 如果之后没有交换说明再也不会交换了 提前结束
            for(j = 1; j<arr.length-i ;j++){//具体某一趟中获取最大/小值的过程
                if(arr[j]<arr[j-1]){//比较相邻两个谁大 谁大谁往后
                    exchange = true;//标记该次遍历有交换
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
            if(!exchange){//如果某次遍历没有交换过说明之后比较也不会再交换了 提前结束算法
                break;
            }
        }
    }
}

不断对相邻的元素进行比较，决定这两个元素是否交换，从而达到排序的目的。第i趟比较完成之后有末尾i个最大的元素被比较出来。算法慢且冗余。

2、快速排序：

快速排序基于算法设计中的分治法 这几乎是最快的排序算法
    实现思路（用从小到大排序作为例子）：
    1、分割 取序列的一个元素作为轴元素 利用这个轴元素 把序列分成三段，所有小于等于轴的元素在轴的左边，所有大于轴的元素在轴的右边
          轴元素在这种情况下已经在正确的位置上了
    2、分治 使用该算法分别对轴元素左边的序列和右边的序列进行排序（可以想成递归）
    3、合并 每个元素都放到正确的位置之后，进行合并。

快速排序的平均时间复杂度为O(n ln n) 但是最差的情况时间复杂度为O(n^2) 空间复杂度最坏为O(n) 最好为O(ln n)

快速排序分割思路一：
    使用一个临时变量对首元素（把首元素当成轴元素）进行备份，取两个指针left right初始值分别是序列最左端最右端的下标
    保证整个过程left小于right，首先从right所指位置向左搜索，找到第一个小于等于轴的元素，把这个元素移到left的位置
    从left所指的位置开始向右搜索，找到第一个大于轴的元素，把这个元素放到right的位置
    重复以上left right指针 直到!left<right，下面用java实现这种分割思路：

    private static int quickRankDivide1(int[] arr, int left , int right){
        int shaft = arr[left];//定义一个轴 这个轴是最左端元素
        while(left<right){
            while(left<right && arr[right]>shaft){
                right--;//左移right指针
            }
            arr[left] = arr[right];//将不符合分割条件的元素更换位置
            while(left<right && arr[left]<=shaft){
                left++;//右移left指针
            }
            arr[right] = arr[left];//将不符合分割条件的元素更换位置
        } 
        arr[left] = shaft;//将轴元素放入准确的位置
        return left;
    }

快速排序分割思路二：

    使用一个临时变量对首元素（把首元素当成轴元素）进行备份，取两个指针left right初始值分别是序列最左端最右端的下标
    保证整个过程left小于right 分别从两边相向遍历 当left向右找到不满足条件的时暂停 right向左找到不满足条件的时交换left和right所处位置的元素
    使用这种方法分割结束之后是通过轴把序列分成两部分 新的right及其左边小于等于轴 新的left及其右边大于轴 因此轴在分割结束要放在right处

    private static void swap(int[] arr , int location1 , int location2){//swap方法交换数组中location1与location2的元素
        int temp = arr[location1];
        arr[location1] = arr[location2];
        arr[location2] = temp;
    }

    private static int quickRankDivide2(int[] arr, int left , int right){
        int shaft = arr[left];//定义一个轴
        int start = left++;//记录轴元素位置 left++ 减少一次轴元素与自己的无用比较 
        while(left<right){//只要left在right的右边 就持续进行
            while(left<right&&arr[right]>=shaft){//查找到不满足轴摆放要求的元素就暂停
                right--;//移动right指针
            }//循环结束时找到了不满足轴摆放要求的元素(大于轴元素的元素)
            while(left<right&&arr[left]<=shaft){
                left++;//移动left指针
            }//循环结束时找到了不满足轴摆放要求的元素(小于轴元素的元素)
            swap(arr, left , right);//交换left right指针的元素
        }
        swap(arr,start,left);//摆放轴元素到准确的位置
        return left;//返回轴元素的位置
    }

public static void quickRank1(int[] arr , int left , int right){//分治 递归
        if(left<right){
            //int location = quickRankDivide2(arr , left , right);//两种分割方法都可以
           int location = quickRankDivide1(arr, left, right);//找到轴的位置
            //location这个位置的元素位置已经是准确的了
            quickRank1(arr,left,location - 1 );
            quickRank1(arr,location + 1,right);//递归 
        }
    }

最后就实现了我们的快速排序quickRank(int[] arr , int left , int right)方法。

如果觉得参数过多不友好，我们就在定义一个函数，对这个quickRank进行封装：

public static void quickSort(int []arr){
    quickRank1(arr , 0 , arr.length-1);
}