算法基础之----直接交换排序

 算法基础之----直接交换排序（冒泡排序（BubbleSort））

在要排序的一组数中，对当前序列的每两个相邻的元素进行比较，做出合适的调整。即，较小的数左移，较大的数右移（此为升序，降序反之），此为交换排序的思想。

例：（假设待排序序列的长度为n）

待排序列：5 8 4 3 6 9 7 2 0 1

对应下标：0 1 2 3 4 5 6 7 8 9

第1趟：  5 4 3 6 8 7 2 0 1 9

第2趟：  4 3 5 6 7 2 0 1 8 9

…

第n-1趟：0 1 2 3 4 5 6 7 8 9

手工过程：假设一共为i趟



如上，可得出，一共进行了n-1次比较

伪代码：

for(比较次数 = 0； 比较次数 < 长度-1； ++) {

 for(intI = 0; i < 长度-1-比较次数; i++) {

if(array[i] > array[i+1]) {

array[i+1] <=>array[i];

 }

}

}

完整代码的实现：

C语言：

#include<stdio.h>
#include<malloc.h>
#include<time.h>
#include<stdlib.h>

typedef unsigned char boolean;

#define TRUE		1
#define FALSE		0

void initData(int *array, int count, int minValue, int maxValue);
void showArray(int *array, int count);
void bubbleSort(int *data, int count);

void bubbleSort(int *data, int count) {
int times;
int tmp;
int i;
boolean isSwap = TRUE;

for(times = 0; isSwap && times < count-1; times++) {
for(isSwap = FALSE, i = 0; i < count-1-times; i++) {
if(data[i] > data[i+1]) {
tmp = data[i];
data[i] = data[i+1];
data[i+1] = tmp;
isSwap = TRUE;
}
}
}
}

void showArray(int *array, int count) {
int i;

for(i = 0; i < count; i++) {
printf(i == 0 ? "%d" : ", %d", array[i]);
}
printf("\n");
}

void initData(int *array, int count, int minValue, int maxValue) {
int i = 0;
int value = maxValue - minValue + 1;

srand(time(0));
for(i = 0; i < count; i++) {
array[i] = minValue + rand()%value;
}
}

void main(void) {
int *array;

array = (int *)calloc(sizeof(int), 20);
initData(array, 20, 1, 100);
showArray(array, 20);

bubbleSort(array, 20);

showArray(array, 20);
}

注：

如果是在Linux环境下，gcc编译，则，需要将main函数的返回值改为int，并且在最后加一句return 0;

Java语言：

public class BubbleSort {
public static void main(String[] args) {
int[] array = new int[20];
initData(array, 200);
showData(array);

bubbleSort(array);

showData(array);
}

/**
* 升序
* 冒泡排序的核心代码
* @param array
*/
private static void bubbleSort(int[] array) {
int len = array.length;
boolean isSwap = true;
for(int times = 0; isSwap && times < len-1; times++) {
isSwap = false;
for(int i = 0; i < len-1-times; i++) {
if(array[i] > array[i+1]) {
array[i] = array[i] ^ array[i+1];
array[i+1] = array[i] ^ array[i+1];
array[i] = array[i+1] ^ array[i];
isSwap = true;
}
}
}
}

/**
* 显示数组
* @param array
*/
private static void showData(int[] array) {
for(int i = 0; i < array.length; i++) {
System.out.printf(i == 0 ? "%d" : ", %d", array[i]);
}
System.out.println();
}

/**
* 初始化一个数组，元素随机产生
* @param array		要初始化的数组
* @param maxValue	数组元素的最大值
*/
private static void initData(int[] array, int maxValue) {
for(int i = 0; i < array.length; i++) {
array[i] = (int)(Math.random()*maxValue);
}
}
}

讨论：

1、  时间复杂度和空间复杂度的分析：

时间复杂度：

比较和交换的总次数和为n(n-1)/2，则，时间复杂度为O(n^2)

空间复杂度：O(1)

2、  稳定性：

稳定排序

3、  极端情况：

直接交换排序有一个特点，当某轮排序过程程中没有进行交换，则，表名排序已经完成，这也就是代码中isSwap的作用。

当完全顺序的情况下，只需要进行一轮比较即可结束，此时为最好情况，时间复杂度为O(n)

当完全逆序的情况下，需要交换的次数最多，此时为最坏情况，时间复杂度为O(n^2)