Java---交换类排序（冒泡排序，快速排序）

Java—交换类排序（冒泡排序，快速排序）

Tags: 排序算法

---

• 冒泡排序
  1.算法思想：反复扫描带排序序列，在扫描过程中，顺次比较两个相邻元素的，如果逆序则调换位置。
  2.代码实现：

/* 冒泡排序
 * 相邻元素比较，大的后移。每一趟遍历都将得出当前未排序最大的一个；
 * 知道某趟遍历没有发现逆序元素，则排序成功，结束循环。
 * 或者全部遍历完
 */
public class BubbleSort {
    public int[] bubbleSort(int[] array) {
        boolean flag = true;//是否还有逆序标记量
        for(int i=1; i<array.length && flag; i++) {
            flag = false;//遍历前标记为false，若没有逆序存在，便利后值仍未false，会结束循环。
            for(int j=0;j<array.length-i;j++) {//每一趟遍历都会排好一个值，所以每次遍历都少一次，直至全部被排序。
                if(array[j+1]<array[j]) {//逆序置换位置
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;//有逆序存在，标记为ture
                }
            }
        }
        return array;
    }
}

3：时间空间效率：
时间复杂度：

$$T(n)=O(n^2)$$
空间复杂度： $$S(n)=O(1)$$
最好情况：顺序排列；
最坏情况：逆序排列；

---

• 快速排序
  1.算法思想：利于一个序列中的值将带排序序列划分成两个子序列，将大于该值的元素放在该值的后边，将小于该值的元素                   放在前面，从而形成两个子序列，对子序列分别进行同样的操作，直至所有子序列长度不超过1，此时，已经                排好序。
  2.代码实现：

/* 快速排序
 * 从待排序序列中选取一个记录为标记值
 * 以标记值为准，将其余记录中大于标记的放在标记后面，小于标记的放在标记前面
 * 将前面和后面两个子序列重复以上步骤排序
 * 直到子序列长度不超过1为止
 */
public class QKSort {
    //一趟快速排序
    public int QKPass(int[] array,int low,int high) {//low为顺序遍历标记，初始为数组第一位，high为逆序遍历标记，初始为数组最后一位
        int temp = array[low];//将数组第一位作为标记量，进行一趟快速排序
        while(low<high) {
            while(low<high && array[high]>temp) {
                high--;//high从后往前遍历寻找小于标记量的值
            }
            if(low<high) {
                array[low] = array[high];//将high找到的值放在low的位置，此时low为空，原值缓存在temp，作为标记量
                low++;
            }

            while(low<high && array[low]<temp) {
                low++;//low从前往后遍历寻找大于标记两的值
            }   
            if(low<high) {
                array[high] = array[low];//将大于标记两的值放在high标记的位置，此时high为空，原值被放入上一次空出的low中。
                high--;
            }
        }
        array[low] = temp;//在一趟快排完成后，low与high标记与相同的位置，将标记量放入，此标记的位置将数组划分成两个子序列
        return low;//返回标记位置，为递归的下一次快拍提供位置信息
    }

    //完整快速排序
    public void qkSort(int[] array,int low,int high) {
        if(low<high) {//递归，终止条件为，low=high时，及最小序列长为1
            int pos = QKPass(array,low,high);//一趟快排返回一个位置信息，前面时小于位置上值的子序列，后面是大于位置上值的子序列
            qkSort(array,low,pos-1);//前面的子序列快排
            qkSort(array,pos+1,high);//后面的子序列快排
        }
    }

    public void main(String[] args) {
        int[] arrayIn = {12,2,32,3,9,15,56,78,34,99,21};
        qkSort(arrayIn,0,arrayIn.length-1);
        for(int i=0;i<arrayIn.length;i++) {
            System.out.print(arrayIn[i] + " ");
        }
    }
}

3.时间空间效率
最好情况为每趟将序列分为两个大小相等的字表，类似于折半查找，此时时间复杂度为：

$$T(n)=O(nlog_2n)$$
最坏情况顺序排列。此时时间复杂度为： $$T(n)=O(n^2)$$
空间复杂度平均为： $$S(n)=O(log_2n)$$