本文详细介绍了排序算法，包括内部排序和外部排序的概念，并重点探讨了算法的时间复杂度，阐述了度量时间复杂度的两种方法、时间频度的忽略项以及时间复杂度的计算方式。具体讲解了冒泡排序和简单选择排序的原理、代码实现及时间复杂度。通过对这两种O(n²)复杂度的排序算法的分析，突显了优化算法以提高效率的重要性。
排序（上）
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)=Ｏ( f(n) )，称Ｏ( 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）目录 | 六、排序（中：简单插入、希尔、快排） |
4926
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
