本文介绍了数据结构的基础知识，强调了其在编程中的重要性，并讲解了如何评判算法的好坏，特别是通过大O表示法分析算法的时间复杂度。文章探讨了算法优化的方向，包括空间和时间的权衡，并预告了更多复杂度相关的深入内容。
1.数据结构概述
-
数据结构用途
当你用着java里面的容器类很爽的时候，你有没有想过，怎么ArrayList就像一个无限扩充的数组，也好像链表之类的。好用吗？好用，这就是数据结构的用处，只不过你在不知不觉中使用了。
现实世界的存储，我们使用的工具和建模。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还能方便地查询到所需要的数据吗？而算法，在这么多的数据中如何做到最快的插入，查找，删除，也是在追求更快。
我们java是面向对象的语言，就好似自动档轿车，C语言好似手动档吉普。数据结构呢？是变速箱的工作原理。你完全可以不知道变速箱怎样工作，就把自动档的车子从 A点 开到 B点，而且未必就比懂得的人慢。写程序这件事，和开车一样，经验可以起到很大作用，但如果你不知道底层是怎么工作的，就永远只能开车，既不会修车，也不能造车。当然了，数据结构内容比较多，细细的学起来也是相对费功夫的，不可能达到一蹴而就。我们将常见的数据结构：堆栈、队列、数组、链表和红黑树 这几种给大家介绍一下，作为数据结构的入门,掌握基本,打好基础,才能走的更远.
-
学习第一阶段总体思路
第一阶段:侧重于常用的经典数据结构[比如 二叉树、哈希表、Trie 等]
2.数据结构开篇
1.什么是数据结构与算法
所谓算法:便是解决特定问题的一系列的执行步骤.
// 计算 两个数的和
public static int plus(int a , int b ){
return a + b ;
}
//计算 1 + 2 + 3 + ....n 的和
public static int sum(int n){
int sum = 0;
for (int i = 0; i <= n; i++) {
sum += i;
}
return sum;
}
上述的代码均能体现出解决了实际问题,虽然简单,但是这也是算法.
注意: 面对同样的问题,使用不同的解决策略,虽然结果相同,但是效率可能大有不同,这便是算法的精妙之处.
例子:
求 第 n 个斐波那契数(fibonacci number) .关于斐波那契数的描述,可以去 Leecode上查看
-
代码分析
//测试代码运行时间的一个类 package cn.yespatal; import java.text.SimpleDateFormat; import java.util.Date; public class Times { private static final SimpleDateFormat fmt = new SimpleDateFormat("HH:mm:ss.SSS"); public interface Task { void execute(); } public static void test(String title, Task task) { if (task == null) return; title = (title == null) ? "" : ("【" + title + "】"); System.out.println(title); System.out.println("开始：" + fmt.format(new Date())); long begin = System.currentTimeMillis(); task.execute(); long end = System.currentTimeMillis(); System.out.println("结束：" + fmt.format(new Date())); double delta = (end - begin) / 1000.0; System.out.println("耗时：" + delta + "秒"); System.out.println("-------------------------------------"); } }
/* *
* 解决斐波那契数的几种思路
* 0 1 1 2 3 5 8 13 21 ...n-2, n-1 ,n 前两个数的和是第三 个数 斐波那契数
*
*/
public class FibonacciNumber {
public static void main(String[] args) {
System.out.println(fib1(0));
System.out.println(fib1(1));
System.out.println(fib2(2));
System.out.println(fib1(3));
System.out.println(fib2(4));
System.out.println(fib1(40));
//基本到这里,它就跑不动了,很慢
//System.out.println(fib1(50));
System.out.println(fib2(70));
System.out.println("=============测试代码性能,也就是测试代码所用时间================");
Times.test("递归测试斐波那契数", new Times.Task() {
@Override
public void execute() {
//测试递归所用时间
System.out.println(fib1(40));
}
});
Times.test("第二种方法测试斐波那契数", new Times.Task() {
@Override
public void execute() {
测试第二种所用时间
System.out.println(fib2(40));
}
});
}
//第一种做法 :递归,如果要计算第 N 个 斐波那契数,则要递归进行n次相加.程序的执行效率大大降低.
/* 索引值 0 1 2 3 4 5 6 7 .... n
* 斐波数 0 1 1 2 3 5 8 13 ....fib(n)
* first second sum
*/
public static int fib1(int n) {
if (n <= 1) return n;
return fib1(n - 2) + fib1(n - 1);
}
public static int fib2(int n){
if (n <= 1) return n;
int first = 0;
int second = 1;
for (int i = 0; i < n - 1; i++) {
//前两个数的和给到第三的数sum
int sum = first + second;
//提前把 second 的值 给到 first,防止覆盖
first = second;
second = sum;
}
return second;
}
}
结果:
0
1
1
2
3
102334155
885444751
=============测试代码性能,也就是测试代码所用时间================
【递归测试斐波那契数】
开始：14:57:04.276
102334155
结束：14:57:04.992
耗时：0.693秒
-------------------------------------
【第二种方法测试斐波那契数】
开始：14:57:05.003
102334155
结束：14:57:05.003
耗时：0.0秒
-------------------------------------
总结:
通过上述代码实现:观察前几次结果,和我们预先的相同.采用时间测试,发现使用递归效率大大降低.影响性能.那么如何评判一个算法的好坏呢
2.如何评判一个算法的好坏
1.先回忆一下计算 1 - 100 之间的和
//计算 1 + 2 + 3 + ....n 的和
public static int sum(int n){
int sum = 0;
for (int i = 0; i <= n; i++) {
sum += i;
}
return sum;
}
高中的知识 : 利用等差公式求前n项和会不会更快更好呢 ? ?
public static int sum1(int n){
return (1 + n) * n / 2 ;
}
如果单从执行效率上进行评估，可能会想到这么一种方案
比较不同算法对同一组输入的执行处理时间.这种方案也叫做：事后统计法
上述方案有比较明显的缺点
执行时间严重依赖硬件以及运行时各种不确定的环境因素
必须编写相应的测算代码
测试数据的选择比较难保证公正性
面对上述情况的解决方案,现在一般从以下维度来评估算法的优劣:
正确性、可读性、健壮性（对不合理输入的反应能力和处理能力）
时间复杂度（time complexity):估算程序指令的执行次数（执行时间）
空间复杂度（space complexity):估算所需占用的存储空间
3.复杂度的概述[大O表示法（Big O) ]
1.一般用大O表示法来描述复杂度，它表示的是数据规模n对应的复杂度
- 忽略常数、系数、低阶
9>>O(1)
2n+3>>O(n)
n2+2n+6>>O(n2)
4n3+3n2+22n+100>>O(n3)
写法上，n3等价于n^3
注意：大O表示法仅仅是一种粗略的分析模型，是一种估算，能帮助我们短时间内了解一个算法的执行效率
- 对数阶的细节
对数阶一般省略底数
log2n = log29 * logon
所以log2n、loggn统称为logn
- 常见的复杂度
复杂度大小的判断 :
O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n3)<O(2")<O(n!)<O(n")
可以借助函数生成工具对比复杂度的大小
函数生成工具对比复杂度
代码分析复杂度的问题
-
分析斐波那契数
- fib函数的时间复杂度分析
- 斐波那契的线性代数解法 - 特征方程
-
注意:并不是面对的每一种问题,都能找见符合这种情况的数学模型,因此,算法的优化将会是一个不小的挑战.
-
多个数据规模的情况
-
代码部分
public class Main {
/* 0 1 2 3 4 5
* 0 1 1 2 3 5 8 13 ....
*/
// O(2^n)
public static int fib1(int n) {
if (n <= 1) return n;
//执行的指令次数在于 :这个函数执行了多少次
return fib1(n - 1) + fib1(n - 2);
}
// O(n)
public static int fib2(int n) {
if (n <= 1) return n;
int first = 0;
int second = 1;
for (int i = 0; i < n - 1; i++) {
int sum = first + second;
first = second;
second = sum;
}
return second;
}
//第三种解决办法,代码优化
public static int fib3(int n) {
if (n <= 1) return n;
int first = 0;
int second = 1;
while (n-- > 1) {
//节省了一个变量,两个变量产生关系.
second += first;
first = second - first;
}
return second;
}
public static void test1(int n) {
// 汇编指令
// 1
if (n > 10) {
System.out.println("n > 10");
} else if (n > 5) { // 2
System.out.println("n > 5");
} else {
System.out.println("n <= 5");
}
// 1 + 4 + 4 + 4
for (int i = 0; i < 4; i++) {
System.out.println("test");
}
// 140000
// O(1)
// O(1)
}
public static void test2(int n) {
// O(n)
// 1 + 3n
for (int i = 0; i < n; i++) {
System.out.println("test");
}
}
public static void test3(int n) {
// 1 + 2n + n * (1 + 3n)
// 1 + 2n + n + 3n^2
// 3n^2 + 3n + 1
// O(n^2)
// O(n)
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.println("test");
}
}
}
public static void test4(int n) {
// 1 + 2n + n * (1 + 45)
// 1 + 2n + 46n
// 48n + 1
// O(n)
for (int i = 0; i < n; i++) {
for (int j = 0; j < 15; j++) {
System.out.println("test");
}
}
}
public static void test5(int n) {
// 8 = 2^3
// 16 = 2^4
// 3 = log2(8)
// 4 = log2(16)
// 执行次数 = log2(n)
// O(logn)
while ((n = n / 2) > 0) {
System.out.println("test");
}
}
public static void test6(int n) {
// log5(n)
// O(logn)
while ((n = n / 5) > 0) {
System.out.println("test");
}
}
public static void test7(int n) {
// 1 + 2*log2(n) + log2(n) * (1 + 3n)
// 1 + 3*log2(n) + 2 * nlog2(n)
// O(nlogn)
for (int i = 1; i < n; i = i * 2) {
// 1 + 3n
for (int j = 0; j < n; j++) {
System.out.println("test");
}
}
}
public static void test10(int n) {
// O(n)
int a = 10;
int b = 20;
int c = a + b;
int[] array = new int[n];
for (int i = 0; i < array.length; i++) {
System.out.println(array[i] + c);
}
}
// 计算 两个数的和
public static int plus(int a , int b ){
return a + b ;
}
//计算 1 + 2 + 3 + ....n 的和
public static int sum(int n){
int sum = 0;
for (int i = 0; i <= n; i++) {
sum += i;
}
return sum;
}
public static int sum1(int n){
return (1 + n) * n / 2 ;
}
public static void main(String[] args) {
//int n = 12;
System.out.println(plus(50, 100));
System.out.println(sum(100));
/*System.out.println(fib2(n));
System.out.println(fib3(n));*/
// TimeTool.check("fib1", new Task() {
// public void execute() {
// System.out.println(fib1(n));
// }
// });
//
// TimeTool.check("fib2", new Task() {
// public void execute() {
// System.out.println(fib2(n));
// }
// });
}
}
4.算法优化方向
- 用尽量少的存储空间
- 用尽量少的执行步骤（执行时间）
- 根据情况，可以
- 空间换时间
- 时间换空间
5.更多复杂度相关的知识
更多复杂度相关的知识，会在后续学习数据结构、算法的过程中穿插
- 最好、最坏复杂度
- 均摊复杂度
- 复杂度震荡
- 平均复杂度
扫一扫
3845
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
