算法 排序算法之交换排序--冒泡排序和快速排序

交换排序

利用交换数据元素的位置进行排序的方法称为交换排序

常用的交换排序方法有

冒泡排序

快速排序

其中快速排序是一种分区交换方法[分治]

冒泡排序[相邻交换 一次交换只能消除一个逆序]

基本思想

设数组a中存放了n个数据元素，循环进行n-1次排序

第一次，依次比较相邻两个元素a[i]和a[i+1]，若为逆序，则交换两个元素，这样进行n-1次排序后数值最大的数据放在数组的末尾

第二次时，数据元素个数减1，操作方法与第一次类似，进行n-2次比较

排序过程

代码实现

有些待排序元素已经基本有 因此可以设置一个flag变量用于标记本次排序过程是否有交换动作，若没有则说明已经排好序，就可提前结束排序过程

Java代码

/**
* 冒泡排序
*/
public static void bubbleSort(int[] arr) {
int temp;
/*设置一个flag变量用于标记本次排序过程是否有交换动作，若没有则说明已经排好序，就可提前结束排序过程*/
boolean flag = false;
for (int i = 1; i < arr.length && !flag; i++) {
flag = true;
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
flag = false;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

C代码实现

void BubbleSort(Datatype a[],int n){
int i,j,flag=1;
DataType temp;

for (i=1;i<n&&flag==1;i++){
flag = 0;
for (j=0;j<n-1;j++){
if (a[j+1]<a[j]){
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
flag = 1;
}
}
}
}

算法分析

最好情况时间复杂度：

集合全部有序，每次都因无交换而退出，此时循环n-1次，时间复杂度为O(n);

最坏情况：

集合全部逆序存放，第一次比较n-1次，第二次比较n-2…最后比较1次，总的比较次数按照求和运算是n*(n-1)/2

移动次数是3n*(n-1)/2

平均时间复杂度

时间复杂度是O(n^2);

空间复杂度

没有使用额外的空间 因此空间复杂度是O(1)

稳定性

显然冒泡排序是一种稳定的排序算法

快速排序[不相邻交换 一次交换可能消除多个逆序]

快速排序是一种二叉树结构的交换排序方法

基本思想

设数组a中存放了n个数据元素，low为低端下标，high为高端下标

从数组中任取一个元素作为标准（一般取a[low]） 调整各个元素的位置，使排在标准元素之前的元素小于标准元素，排在后面的大于标准元素

一趟排序后，标准元素位置确定，且数组分为两个子数组，再分别最两个子数组进行方法类同的递归排序

递归的出口是high>low

排序过程

算法实现

C代码

void QuickSort(DataType a[],int low,int high){
int i=low,j=high;
DataType temp = a[low];

while (i<j){
while (i<j&&temp<=a[j]){//在数组右端扫描
j--;
}
if (i<j){
a[i++]=a[j];
}

while (i<j&&a[i]<temp){//在数组左端扫描
i++;
}
if (i<j){
a[j--]=a[i];
}
}
a[i] = temp;
if (low<i){//对左端子集合进行递归
QuickSort(a,low,i-1);
}
if (i<high){//对右端子集合进行递归
QuickSort(a,i+1,high);
}
}

Java代码实现

public static void quickSort(int[] arr, int head, int tail) {
if (head < tail) {
int left = head, right = tail;
int key = arr[head];
while (left < right) {
/*从右往左找出比key小的数*/
while (left < right && arr[right] >= key) {
right--;
}
if (left < right) {
/*找到的数放在left位置*/
arr[left++] = arr[right];
}

/*此时从左往右遍历出比key大的数*/
while (left < right && arr[left] < key) {
left++;
}
if (left < right) {
/*找到的数放在right位置*/
arr[right--] = arr[left];
}
}
arr[left] = key;
//递归遍历
quickSort(arr, head, left - 1);
quickSort(arr, left + 1, tail);
}
}

算法分析

最好情况时间复杂度

每次选取的标注元素都可以均分成两个子数组，此时是一个完全二叉树结构，每次比较的次数都接近n-1 因此时间复杂度是O（nlog2n）

最坏情况时间复杂度

当数组全部有序时，每次都分解成二叉退化树[单分支二叉树]，时间复杂度O(n^2)

平均时间复杂度

平均时间复杂度O（nlog2n）

空间复杂度

需要堆栈空间临时保存递归调用函数 堆栈空间的使用个数和递归调用的次数有关。最好情况是O（nlog2n），最坏情况是O(n)，平均空间复杂度O（log2n）

稳定性

快速排序是不稳定的排序算法