零、前言
[1].从冒泡排序和快速排序引入算法 [2].时间复杂度的引入 [3].空间复杂度的引入 [4].数据结构和算法之间的杂谈
关于程序的执行
输入: 原生可用数据 = 数据获取 + 数据解析 处理：逻辑加工(算法核心) 输出：获得预期数据 拿一个排序算法来说:[输入原始杂乱数据,通过逻辑加工,生成预期有序数据]
一、从冒泡排序和快速排序开始说起
100W个随机数,存储到文件中,使用时解析数据形成int数组
问： 为什么要存到文件里,直接在内存里不就行了吗?
---- 数据固化之后,保证原始数据不变且容易查看和再加工
排序之前的前3000个
排序之前的前3000个
1、数据准备
1.1原始数据的生成
数据的来源可以多种多样,这里用最简单的方式生成大批量数据,随机100W个0~100W的数字
public class NumMaker { public static void main(String[] args) throws IOException { String path = "J:\\sf\\data\\num.txt"; int bound = 100 * 10000; initData(path, bound); } /** * 初始化数据 * * @param path 文件路径 * @param bound 数据个数 * @throws IOException */ private static void initData(String path, int bound) throws IOException { Random random = new Random(); FileHelper.mkFile(path); StringBuilder sb = new StringBuilder(); for (int i = 0; i < bound; i++) { sb.append(random.nextInt(bound)); if (i != bound - 1) { sb.append(","); } } FileWriter writer = new FileWriter(path); writer.write(sb.toString()); writer.close(); } } /** * 创建文件 * @param path 文件路径 * @return 文件是否被创建 */ public static boolean mkFile(String path) { boolean success = true; File file = new File(path);//1.创建文件对象 if (file.exists()) {//2.判断文件是否存在 return false;//已存在则返回 } File parent = file.getParentFile();//3.获取父文件 if (!parent.exists()) { if (!parent.mkdirs()) {//4.创建父文件 return false; } } try { success = file.createNewFile();//5.创建文件 } catch (IOException e) { success = false; e.printStackTrace(); } return success; }1.2.数据解析
/** * 解析原始数据,得到int数组 * @param path 路径 * @return int数组 */ private static int[] parseData(String path) throws IOException { FileReader reader = new FileReader(path); StringBuilder sb = new StringBuilder(); int len = 0; char[] buf = new char[1024]; while ((len = reader.read(buf)) != -1) { sb.append(new String(buf, 0, len)); } String[] data = sb.toString().split(","); //String数组转int int[] ints = new int[data.length]; for (int i = 0; i < ints.length; i++) { ints[i] = Integer.parseInt(data[i]); } return ints; }2.冒泡排序与快速排序
/** * 冒泡排序 * @param arr 数组 * @param n 个数 */ private static void bubbleSort(int arr[], int n) { int i, j, t; // 要遍历的次数，第i趟排序 for (i = 1; i < n - 1; i++) { for (j = 0; j < n - 1; j++) { // 若前者大于后者，则交换 if (arr[j] > arr[j + 1]) { t = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = t; } } } } /** * 快速排序 * * @param arr 数组 * @param start 起点 * @param end 重点 */ private static void fastSort(int[] arr, int start, int end) { int i, j, key; if (start >= end) { return; } i = start + 1; j = end; key = arr[start];//基准位 while (i < j) { while (key <= arr[j] && i < j) j--; //←-- while (key >= arr[i] && i < j) i++; //--→ if (i < j) {//交换 int t = arr[j]; arr[j] = arr[i]; arr[i] = t; } } arr[start] = arr[i];//交换基准位 arr[i] = key; fastSort(arr, start, j - 1);//左半 fastSort(arr, j + 1, end);//右半 }3.数据输出(固化到文件)
//使用冒泡排序 // System.out.println("bubbleSort开始-----------------------"); // long start = System.currentTimeMillis(); // bubbleSort(data, data.length); // long end = System.currentTimeMillis(); // System.out.println("bubbleSort耗时：" + (end - start) / 1000.f + "秒"); //使用快速排序 System.out.println("fastSort开始-----------------------"); long start = System.currentTimeMillis(); fastSort(data, 0, data.length-1); long end = System.currentTimeMillis(); System.out.println("fastSort耗时：" + (end - start) / 1000.f + "秒"); String path_sort = "J:\\sf\\data\\num_sort.txt"; saveInts(data, path_sort);//将结果保存到文件4.简单的散点图绘制
用python的matplotlib,就这么简单
由于100W条数据太多，渲染太慢,就算渲染出来也一片糊，这里取前3000个感受一下。
import matplotlib.pyplot as plt def init_data(): data_raw = open("J:\\sf\\data\\num_raw.txt").readline() data = data_raw.split(",") data = list(map(int, data)) # 将字符型列表转为int型 for i in range(2000, 3000): # 查看的数据索引范围 plt.scatter(i, data[i], alpha=0.6) if __name__ == '__main__': init_data() plt.show() # 显示所画的图5.关于排序算法
冒泡排序和使用快速
冒泡排序排列： fastSort开始----------------------- 等了一个小时都没排出来,算了，不等了，我就点了暂停... 使用快速排序： fastSort开始----------------------- fastSort耗时：0.216秒 这TM是"愚公移山"和"沉香劈山"的差距啊...,短短的几行代码，都是智慧的结晶。 等两个小时都排不出来和 0.216秒 完成任务,这就是算法带来的价值
这时你也许会问:两种排序的差距为何如此巨大，且听下面细细分解。
二、时间复杂度(简述):描述算法运行时间和输入数据之间的关系
1.一亿次加法+赋值的耗时：
System.out.println("fastSort开始-----------------------"); long start = System.nanoTime(); for (int i = 0; i < 100000000; i++) { int a = 1 + i; } long end = System.nanoTime(); System.out.println("fastSort耗时：" + (end - start) + "纳秒"); 结果在: 6324942 纳秒左右 即：6.324942 ms (1 ns = 100 0000 ms)2.关于计算机常识
CPU的主频:即CPU内核工作的时钟频率,例如我的笔记本是2.20GHz 频率(Hz)：描述周期性循环信号（包括脉冲信号）在单位时间内所出现的脉冲数量 1GHz=1000MHz，1MHz=1000kHz，1kHz=1000Hz 2.20GHz = 2200 MHz = 2200 000 kHz = 2200 000 000 Hz 即22亿Hz 即一秒钟内CPU脉冲震荡次数为 22 亿次 ,由于执行某指令需要多个时钟周期 但由于不同指令所需的周期数是不定的,具体1s能执行多少次指令很难量化 于是一个算法的时间复杂度应运而生,其中理想化了一个计算模型： 1.标准的简单指令系统：运算与赋值等 2.模型机处理简单指令的都恰好花费1个时间单位
3.冒泡算法的时间复杂度
/** * 冒泡排序 * @param arr 数组 * @param n 个数 */ private static void bubbleSort(int arr[], int n) { int i, j, t; // 要遍历的次数，第i趟排序 for (i = 1; i < n - 1; i++) { for (j = 0; j < n - 1; j++) { // 若前者大于后者，则交换 if (arr[j] > arr[j + 1]) { t = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = t; } } } } 其外层循环执行 N - 1 次。 内层循环最多的时候执行N次，最少的时候执行1次，平均执行 (N+1)/2 次。 所以循环体内的[交换逻辑]约执行：(N - 1)(N + 1) / 2 = (N^2 -1)/2 次。 按照计算复杂度的原则，去掉常数，去掉最高项系数，其复杂度为O(N^2)。 也就是说100W条数据, 最多要执行 100W*100W(即100亿) 次交换逻辑 测试了一下一次交换逻辑平均耗时500纳秒左右 所以总耗时： 500 * 100亿 ms = 5000 秒 = 1.3888889 时
4.快速排序的分析
我在交换时放了一个count计数，最终：
count = 3919355 远比冒泡排序要少
/** * 快速排序 * * @param arr 数组 * @param start 起点 * @param end 重点 */ private static void fastSort(int[] arr, int start, int end) { int i, j, key; if (start >= end) { return; } i = start + 1; j = end; key = arr[start];//基准位 while (i < j) { while (key <= arr[j] && i < j) j--; //←-- while (key >= arr[i] && i < j) i++; //--→ if (i < j) {//交换 int t = arr[j]; arr[j] = arr[i]; arr[i] = t; } } arr[start] = arr[i];//交换基准位 arr[i] = key; fastSort(arr, start, j - 1);//左半 fastSort(arr, j + 1, end);//右半 } 快速排序时间复杂度是:nlogn , 即平均执行 100W*log100W ≈ 20 * 100W = 2000W 次 , 快速排序时间复杂度的计算这里暂时就不分析了，后面会有专题三、空间复杂度(简述):描述算法消耗临时空间和输入数据之间的关系
暂略
四、散扯
1.数据结构与算法分析
数据结构离不开算法分析,结构本身是对现实中问题的抽象,算法使之呈现 算法虽然可以独立于结构存在,但数据结构可以使之绚丽多彩,变幻莫测 复制代码
2.数据与结构
其实我更愿意将数据和结构分开来说: 数据是应用程序存在和生存必不可少的部分,就像化学元素之于生物 而结构给了数据更好的承载体,复杂而优秀的结构有利于物种的存在与支配资源，就像人类之于酵母菌 一个生物的DNA结构决定了它的形貌,一个生物的骨架决定了它有何优势,如何生存。 在我眼中结构是自然的,纯正的。而数据会附和与结构形成一种美妙的状态 复制代码
3.算法与分析
坦白说,我的算法很渣,但我喜欢分析和计算，我一直觉得，算法和计算是两个不同的概念 计算是数学的,会依赖数学公式,特别是一些图形相、绘制相关的计算 但算法给人感觉很深沉或说深奥,而且条条大路通罗马,需要分析优劣 算法最令我失落的是: 我可以一字不落背下它，可以debug一步一步理解它，可以画图去演示它， 但我不想到它为何存在，第一个设计它的人是怎么想的,这种感觉让我很难受。 复制代码
4.杂谈
一开始接触队列时感觉so easy,不就是入队,出队,查看队首吗? 链表不就是一个一个接起来，这有什么难的?你知道一件事物是什么和你能运用它创造价值是天壤之别 当看到阻塞队列和信息队列,感觉自己是多么无知 也许可以硬记背出红黑树的特点,甚至实现的细节,如果不去思考一个算法为什么存在, 那它也许只是你脑子里的一团干草,没有养分而且占用空间。 因为算法中的巧妙之处太多太多,一深究就StackOver(栈溢出),导致我一直避让着算法,但是: 复制代码
5.如果把一个程序比作人 :
结构是支撑人体存在的骨架 数据是附着在骨架上的血液与肉体 算法是支配骨架和血肉的灵魂
随时随地看视频
