数据结构 JAVA描述（十） 交换排序

冒泡排序

设初值i=1

在无序序列a[0], a1,……a[n-i]中，从头至尾依次比较相邻的两个元素，a[j]和a[j+1]，若a[j]>a[j+1]，则交换位置。

i=i+1

重复以上步骤

/**
* @description 冒泡排序算法
* @param before
* @return
* @time 2016年1月3日 下午9:06:50
*/
public static int[] bubbleSort(int[] before){
int[] a= Arrays.copyOf(before, before.length);
boolean flag = true;
for(int i = 1; i < a.length && flag; i++){
flag = false; //记录未交换
for(int j = 0; j < a.length - 1; j++){
if(a[j] > a[j + 1]){
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
flag = true;
}
}
}
return a;
}

算法性能分析

空间复杂度：O（1）

时间复杂度：O（n²）

最好情况：有序，只需比较n-1次

最坏情况：逆序，第i趟排序中，比较次数为n-i，移动次数为3（n-i），则总比较次数是∑（n-i）=1/2 n（n-1），总移动次数是∑3（n-i）= 3/2 n（n-1）

算法稳定性：稳定

快速排序

一趟快速排序的算法：（通俗说，就是选定第一个元素作为标志，然后从两头往中间和它比较，不断交换位置，要保证大的在它右边，小的在它左边）

设置两个变量i、j初值分别为low和high，分别表示待排序序列的起始下标和终止下标

将第i个元素暂存变量pivot中，即pivot = a[i]

从下标为j的位置由后向前搜索，找到第一个比pivot小的元素时，交换两者位置，然后i=i+1

从下标为i的位置由前向后搜索，找到第一个比pivot大的元素时，交换两者位置，然后j=j-1

-重复以上步骤，直到i==j

/**
* @description 这里说明一下，为了进入方法的数组before不被改变，所以就先赋值给a，
*              然后再调用快速排序算法的代码改变了数组a，因为用到了递归，所有不能跟前面的代码相同处理
* @return
* @time 2016年1月4日 上午1:03:21
*/
public static int[] qSort(int[] before) {
int[] a= Arrays.copyOf(before, before.length);
qSort(a, 0, a.length - 1);
return a;
}

/**
* @description 快速排序算法
* @param a
* @param low
* @param high
* @time 2016年1月4日 上午1:28:34
*/
private static void qSort(int[] a, int low, int high) {
int i = low, j = high;
if(i < j){
int pivot = a[i]; //设定支点的值,初始位置是low
int pivotLoc;  // 一趟排序后支点的位置

// 一趟快排的算法，此时在支点前的数据≤支点，支点后的数据≥支点
while(i < j){
//high为起点下标 从后往前和pivot支点比较
while(i < j && pivot <= a[j]){
j --;
}
if(i < j){ //说明上面跳出循环是因为有个high使得pivot > a[high]了
a[i] = a[j];
i++;
}
//low为起点下标 从前往后和pivot支点比较
while(i < j && pivot > a[i]){
i++;
}
if(i < j){
a[j] = a[i];
j--;
}
}
a[i] = pivot; //此时low和high相等
pivotLoc = i;
qSort(a, low, pivotLoc - 1);
qSort(a, pivotLoc + 1, high);
}
}

算法性能分析

空间复杂度：快排在系统内部需要一个栈实现递归，每层递归调用时的指针和参数均需要用栈存放。快排递归过程类似二叉树，所以栈空间为O（㏒₂ n）。最坏情况下，递归树是一个单枝树，所以栈空间是O（n）

时间复杂度：

最好情况：每次划分正好分成两个等长子序列，O（n ㏒₂ n）

最坏情况：基本有序，每次划分只能得到一个子序列，这样快速排序退化为冒泡排序，O（n²）

算法稳定性：不稳定