数据结构和算法学习（3）-简单排序

本次学习主要内容：冒泡排序、选择排序、插入排序

排序步骤总体思路

1.比较两个数据项

2.交换两个数据项或者复制其中一项

冒泡排序

-遵循规则

1.从第二项开始，依次与前一项进行比较

2.前一项大于后一项则交换位置，否则无动作

3.向右移动，进行下一次比较

4.比较至最后一项后从步骤1开始重复，直到整个数组有序

因为最大的数据项总是“冒泡”到数组的顶端，故称“冒泡排序”

-代码实现

int[] sort=new int[100];
Random r = new Random();
int temp=0;
for (int i = 0; i < sort.length; i++) {
	sort[i]=r.nextInt(100);
}
for (int i = sort.length; i > 0; i--) {
	for (int j = 1; j < i; j++) {
		if (sort[j]>sort[j-1]) {
			continue;
		}else {
			temp=sort[j];
			sort[j]=sort[j-1];
			sort[j-1]=temp;
		}
	}
}
for (int i : sort) {
	System.out.print(i+" ");
}

由于每一次都会将当前最大的数字排至队尾，所以内层循环应当循环（数组长度-外层循环次数）次

-排序效率

数组长度为N，则进行N次排序，第i次排序比较了N-i次

也就是做了N^2/2次比较

也就是时间复杂度为

O(N^2)

选择排序

-遵循规则

1.找到当前数据中最小值

2.与当前数据中下标最小值交换

3.重复步骤1开始，直到整个数组有序

-代码实现

int[] sort = new int[100];
Random r = new Random();
int temp = 0;
int sign = 0;
for (int i = 0; i < sort.length; i++) {
	sort[i] = r.nextInt(100);
}
for (int i = 0; i < sort.length; i++) {
	int min = sort[i];
	for (int j = i; j < sort.length; j++) {
		if (sort[j] < min) {
			min = sort[j];
			sign = j;
		}
	}
	temp = sort[i];
	sort[i] = min;
	sort[sign] = temp;
}
for (int i : sort) {
	System.out.print(i + " ");
}

-排序效率

根据比较次数来讲，与冒泡交换无异，但是交换次数要少的多，少于数组长度，虽然时间复杂度为

O(N^2)

但是无疑要比冒泡排序要快，当N值较小时，特别的交换时间级比比较时间级大得多的时候，选择排序是相当快的

插入排序

-遵循规则

1.选取一个标志，要求标志左端有序

2.从标志起，将右侧数据依次向左侧的有序数组中插入

3.从步骤1开始重复，直到整个数组有序

-代码实现

int[] sort = new int[100];
Random r = new Random();
int temp = 0;
for (int i = 0; i < sort.length; i++) {
	sort[i] = r.nextInt(100);
}
for (int i = 1; i < sort.length; i++) {
	if (sort[i - 1] > sort[i]) {
		temp = sort[i];
		int j = i;
		while (j > 0 && sort[j - 1] > temp) {
			sort[j] = sort[j - 1];
			j--;
		}
		sort[j] = temp;
	}
}
for (int i : sort) {
	System.out.print(i + " ");
}

-排序效率

在第一次排序中最多比较一次，第二次排序中最多比较两次，依次类推，最后一次比较N-1次。故最多比较N*(N-1)/2次

然而在每次次排序发现插入点之前平均只有一般的数据参与了比较，也就是约比较N*(N-1)/4次

复制次数大致等于比较次数，故对于随机数据而言，比冒泡排序快一倍，比选择排序略快

然而对于已经有序或者基本有序的数据而言，插入排序要好得多，由于while条件多数为假，故此之变成了外层循环的一个简单语句

所以

有序情况：O(N)

无序情况：O(N^2)