排序(上)
1. 排序算法介绍
基本概要
排序是将一组数据,依指定的顺序进行排列的过程。
分类
- 内部排序:
指将需要处理的所有数据都加载到内部存储器中进行排序。- 外部排序法:
数据量过大,无法全部加载到内存中,需要借助外部存储进行
排序。
2. 算法的时间复杂度
2.1 度量一个程序(算法)执行时间的两种方法
- 事后统计法:这种方法可行, 但是有两个问题:
一是要想对设计的算法的运行性能进行评测,需要实际运行该程序;
二是所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式,要在同一台计算机的相同状态下运行,才能比较那个算法速度更快 - 事前估算法:通过分析某个算法的时间复杂度来判断哪个算法更优(
平时所说的时间复杂度即为这种方法
)
2.2 什么是时间频度
基本概念:
一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)
示例:计算1-100所有数字之和
// for循环计算:
// 时间频度T(n) = 1+1+(n+1)+n+n=3n+3
int sum = 0; // 1次
for (int i = 0; i < 100; i++) { // int i=0 一次;判断101次;i++100次;循环体内100次
sum+=i;
}
// 直接计算
// 时间频度T(n) = 1
sum = (1+100)*100/2;
2.3 时间频度的忽略项
数据规模大,忽略才有用
2.3.1 常数项
结论:n越大,常数项对曲线的影响越小,常数项可以忽略
2.3.2 低次项
结论:n越大,低次项对曲线影响越小,低次项可以忽略
2.3.3 系数
在指数≤2的时候,可以直接忽略;指数>2的时候,考虑到时间复杂度是渐进的,所以也能忽略
2.4 时间复杂度
2.4.1 基本介绍
一般情况下,算法中的基本操作语句的重复执行次数是问题规模n的某个函数,用T(n)表示,若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n) / f(n) 的极限值为不等于零的常数,则称f(n)是T(n)的同数量级函数。记作 T(n)=O( f(n) ),称O( f(n) ) 为算法的渐进时间复杂度,简称时间复杂度。
人话:就是将 T(n)这个公式,通过上面的三个忽略法 变成 f(n) ,再简写成 O(f(n))
T(n) 不同,但时间复杂度可能相同。
如:T(n)=n²+7n+6 与 T(n)=3n²+2n+2 它们的T(n) 不同,但时间复杂度相同,都为O(n²)。
计算方式:
- 复杂度为常数,如23,9999,等等 都表示为O(1)
- 复杂度包含n时,省略系数与常数项,只取n的最高阶项
- 复杂度为对数时:如log5(n)、log2(n) 等等 都表示为 O(logn)
- 省略低阶,只取高阶 (即取最大的) 如:logn+nlogn 表示为O(nlogn)
常见的时间复杂度
O(1) < O(logn) < O(n) < O(nlogn) < O(n^2)< O(n^3) < O(2^n) < O(n!) < O(n^n)
时间复杂度越小越好
常数阶O(1):无论代码执行了多少行,只要是没有循环等复杂结构,那这个代码的时间复杂度就都是O(1)
public void method(){
int i = 1;
int j = 2;
i++;
j++;
}
对数阶O(log2n):
如果a的x次方等于N(a>0,且a≠1),那么数x叫做以a为底N的对数(logarithm),记作x=loga N。其中,a叫做对数的底数,N叫做真数
如下示例中,i每次都乘上2,假设i乘上x次2之后等于n,那么程序执行了x次就退出了循环,可以推得2^x = n => log2N = x,因此时间复杂度为O(log2N)
public void method(){
int i = 1;
while(i<n){
i*=2;
}
}
线性阶O(n)
public void method(){
for(int i = 0; i < n; i++) {
}
}
线性对数阶O(nlogN):就是线性阶里面嵌套了对数阶
public void method(){
for(int i = 0; i < n; i++) {
int j = 1;
while(j<n){
j*=2;
}
}
}
平方阶O(n²):双重for循环就是平方阶
public void method(){
for(int i = 0; i < n; i++) {
for (int j = 0; j < n; j++){
}
}
}
2.4.2 平均时间复杂度和最坏时间复杂度
- 平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下,该算法的运行时间。
- 最坏情况下的时间复杂度称最坏时间复杂度。
一般讨论的时间复杂度均是最坏情况下的时间复杂度
。
这样做的原因
是:最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限,这就保证了算法的运行时间不会比最坏情况更长。- 平均时间复杂度和最坏时间复杂度是否一致,和算法有关
3. 冒泡排序
3.1 基本介绍
冒泡排序(Bubble Sorting)的基本思想是:通过对 待排序序列 从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒。
3.2 设计思路
3.3 代码实现
首先定义一个模板类,方便统计时间
public abstract class TimeTemplate {
public void sendTime(int[] arr, String sortName) {
long start = System.currentTimeMillis();
code(arr);
long end = System.currentTimeMillis();
System.out.println(sortName + "使用了:" + (end - start) + "毫秒");
}
public abstract void code(int[] arr);
}
排序实现
public class Demo16 extends TimeTemplate{
/**
* 冒泡排序 时间复杂度:O(N^2)
*/
@Override
public void code(int[] arr) {
// 用于交换的临时变量
int temp;
// 开始排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
// 如果前面的数比后面的数大,则交换
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, 20};
new Demo16().sendTime(arr,"冒泡排序");
System.out.println(Arrays.toString(arr));
// 性能测试
int[] arr2 = new int[80000];
for (int i = 0; i < 80000; i++) {
arr2[i] = (int) (Math.random() * 8000000);
}
new Demo16().sendTime(arr2, "冒泡排序");
}
}
算法优化:因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下来没有进行过交换,就说明序列有序,因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。
public class Demo16 extends TimeTemplate{
/**
* 冒泡排序 时间复杂度:O(N^2)
*/
@Override
public void code(int[] arr) {
// 用于交换的临时变量
int temp;
// 优化:用于标识,是否交换过
boolean flag = false;
// 开始排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
// 如果前面的数比后面的数大,则交换
if (arr[j] > arr[j + 1]) {
flag = true;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
// 在一趟排序中,一次交换都没有发生过,直接跳出循环
if (!flag) {
break;
}
// 重置flag
flag = false;
}
}
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, 20};
new Demo16().sendTime(arr,"冒泡排序");
System.out.println(Arrays.toString(arr));
int[] arr2 = new int[80000];
for (int i = 0; i < 80000; i++) {
arr2[i] = (int) (Math.random() * 8000000);
}
new Demo16().sendTime(arr2, "冒泡排序");
}
}
4. 简单选择排序
4.1 基本介绍
选择式排序是从欲排序的数据中,按指定的规则选出某一元素,再依规定交换位置后达到排序的目的。
基本思想是:
第一次从arr[0]~arr[n-1]中选取最小值,与arr[0]交换,
第二次从arr[1]~arr[n-1]中选取最小值,与arr[1]交换,
第三次从arr[2]~arr[n-1]中选取最小值,与arr[2]交换,…,
第i次从arr[i-1]~arr[n-1]中选取最小值,与arr[i-1]交换,…,
第n-1次从arr[n-2]~arr[n-1]中选取最小值,与arr[n-2]交换,
总共通过n-1次,得到一个按排序码从小到大排列的有序序列。
4.2 设计思路
4.3 代码实现
public class Demo17 extends TimeTemplate {
/**
* 简单选择排序 时间复杂度:O(N^2)
*/
@Override
public void code(int[] arr) {
// 存放最小值的下标
int minIndex;
// 存放最小值
int minArr;
for (int i = 0; i < arr.length - 1; i++) {
// 每次都假定待排序数组的第一个数为最小值
minIndex = i;
minArr = arr[i];
for (int j = i + 1; j < arr.length; j++) {
// 说明假定的最小不是最小
if (minArr > arr[j]) {
// 重新赋值最小的下标
minIndex = j;
// 重新赋值最小的值
minArr = arr[j];
}
}
// 如果最小的下标不是之前假定的下标,那么进行交换
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = minArr;
}
}
}
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, 20};
new Demo17().sendTime(arr, "选择排序");
System.out.println(Arrays.toString(arr));
int[] arr2 = new int[80000];
for (int i = 0; i < 80000; i++) {
arr2[i] = (int) (Math.random() * 8000000);
}
new Demo17().sendTime(arr2, "选择排序");
}
}
上一篇 | 总目录 | 下一篇 |
---|---|---|
四、递归 | 数据结构篇(Java)目录 | 六、排序(中:简单插入、希尔、快排) |