数据结构——第一章绪论

数据结构——绪论

数据结构在学什么？

1. 如何用程序代码把现实世界的问题信息化；
2. 如何用计算机高效地处理这些信息从而创造价值。

四大件——计组、计网、操作系统、数据结构的关系

数据结构的基本概念和三要素

数据结构的基本概念

1. 数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。数据是计算机程序加工的原料。
2. 数据元素：数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，把账号当作一个数据元素，它由昵称、姓别、生日等数据项组成。
   
3. 数据结构：数据结构是相互之间存在一种或多种特定关系（指数据的逻辑结构）的数据元素的集合。
4. 数据对象：数据对象是具有相同性质的数据元素（指数据的逻辑结构）的集合，是数据的一个子集。
5. 数据类型：数据类型是一个值的集合和定义再此集合上的一组操作的总称。
   5.1 原子类型：其值不可再分的数据类型。如bool 类型和int 类型等；
   5.2 结构类型：其值可以再分解为若干成分（分量）的数据类型。如Java中的某个实体类Class等；
   5.3 抽象数据类型（ADT）：抽象数据组织及与之相关的操作。
   

数据结构的三要素

1. 数据的逻辑结构：数据元素之间的逻辑关系，即从逻辑关系上描述数据。
   1.1 集合结构：结构中的数据元素之间除同属一个集合外，别无其它关系；
   1.2 线性结构：结构中的数据元素之间只存在一对一的关系，除了第一个元素，所有元素都有唯一前驱；除了最后一个元素，所有元素都有唯一后继；
   1.3 树形结构：结构中数据元素之间存在一对多的关系；
   1.4 图状结构：数据元素之间是多对多的关系。
   
2. 数据的存储结构（物理结构）：数据结构在计算机中的表示（又称映像），也称物理结构。
   在数据的存储结构中，顺序存储结构以外的存储结构都是非顺序存储结构；数据的存储结构会影响存储空间分配的方便程度以及对数据运算的速度。
   2.1 顺序存储：把逻辑上相邻的元素存储在物理位置也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现；
   2.2 链式存储：逻辑上相邻的元素在物理位置上可以不相邻，借助指示元素存储地址的指针来表示元素之间的逻辑关系；
   2.3 索引存储：在存储元素信息的同时，还建立附加的索引表，索引表中的每项称为索引项，索引项的一般形式是（关键字，地址）；
   
   2.4 散列存储：根据元素的关键字直接计算出该元素的存储地址 ，又称哈希（Hash）存储。
3. 数据的运算：施加在数据上的运算包括运算的定义何实现。运算的定义是针对逻辑结构的，指出运算的功能；运算的实现是针对存储结构的，指出运算的具体操作步骤。

算法的基本概念

1. 程序=数据结构+算法。
2. 算法的特性：
   2.1 有穷性：一个算法必须总在执行有穷步之后结束，且每一步都可在有穷时间内完成；（PS:算法是有穷的，但程序可以是无穷的）
   2.2 确定性：算法中每条指令必须有确定的含义，对于相同的输入只能得到相同的输出；
   2.3 可行性：算法中描述的操作都可以通过已经实现的基本运算执行有限次来实现；
   2.4 输入：一个算法有零个或多个输入，这些输入取自于某个特定的对象的集合；
   2.5 输出：一个算法有一个多个输出，这些输出是与输入有着某种特定关系的量。
3. 好的算法达到的目标：
   3.1 正确性：算法应能够正确的求接问题；
   3.2 可读性：算法应具有良好的可读性，以帮助人们理解；
   3.3 健壮性：输入非法数据时，算法能适当地做出反应或进行处理，而不会产生莫名奇妙地输出结果；
   3.4 效率与低存储量需求：效率是指算法执行的时间，存储量需求是指算法执行过程中所需要的最大存储空间，这两者都与问题的规模有关。

算法的时间复杂度

1. 时间复杂度的概念：事前预估算法时间开销T(n)与问题规模n的关系（T表示“Time”），T(n) = O(f(n))。
2. 时间复杂度的例子：

2.1 时间复杂度为O(n)
package DataStructure;
public class TimeComplexity {
    public static void N(int n) {
        for (int i = 1; i <= n; i++) {
            System.out.println("Hello,World!!!");
        }
    }
}

2.2 时间复杂度为O(n的平方)
package DataStructure;
public class TimeComplexity {
    public static void N2(int n) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                System.out.println("Hello,World!!!");
            }
        }
    }
}

2.3 时间复杂度为O(log2n)
log2n的计算过程：设x为总共循环的次数，则当2的x次方>n时，循环结束，所以解得x=log2n
package DataStructure;
public class TimeComplexity {
    public static void log2N(int n) {
        for (int i = 1; i <= n; i = i * 2) {
            System.out.println("Hello,World!!!");
        }
    }
}

3. 时间复杂度的最终阶数的判定标准：
   3.1 可以忽略常数项，即O(n+1000) = O(n)；O(1000) = O(1)；
   3.2 可以忽略除最高次项外的低次项；
   3.3 可以忽略最高次项的系数。
4. 时间复杂度的计算规则：
   3.1 加法规则：O(f(n)) + O(g(n)) = O(max(f(x),g(x)))；
   3.2 乘法规则：O(f(n)) * O(g(n)) = O(f(n)*g(n))。
5. 阶数排序（时间复杂度排序）：越小越好
   
6. 时间复杂度的三种情况
   6.1 最坏时间复杂度：考虑输入数据“最坏”的情况；
   6.2 平均时间复杂度：考虑所有输入数据都等概率出现的情况；
   6.3 最好时间复杂度：考虑输入数据“最好”的情况。

算法的空间复杂度

1. 空间复杂度的概念：事前预估算法空间开销S(n)与问题规模n的关系（S表示“Space”），S(n) = O(f(n))。
   因为一个int变量占4B，所以int[n]所需内存空间为：4+4n，其他的数据类型以此类推。
2. 空间复杂度的例子

时间复杂度为O(1)——算法原地工作
package DataStructure;
public class SpaceComplexity {
    public static void One(int n) {
       int i = 1;
       while (i <= n){
            System.out.println("Hello,World!!!");
            i++;
        }
    }
}

时间复杂度为O(n)
package DataStructure;
public class SpaceComplexity {
    public static void N(int n) {
		int[] flag = new int[n];
    }
}    

S(n) = O(n的平方) + O(n) + O(1) = O(n的平方)
时间复杂度为O(n的平方)
package DataStructure;
public class SpaceComplexity {
    public static void N2(int n) {
       int[][] flag = new int[n][n];
       int[] other = new int[n];
       int m = 1;
    }
}    

3. 空间复杂度的最终阶数的判定标准：
   3.1 可以忽略常数项，即O(n+1000) = O(n)；O(1000) = O(1)；
   3.2 可以忽略除最高次项外的低次项；
   3.3 可以忽略最高次项的系数。
4. 空间复杂度的计算规则：
   3.1 加法规则：O(f(n)) + O(g(n)) = O(max(f(x),g(x)))；
   3.2 乘法规则：O(f(n)) * O(g(n)) = O(f(n)*g(n))。
5. 阶数排序（空间复杂度排序）：越小越好
   
6. 函数递归调用带来的内存开销

6.1 递归函数中的空间复杂度为O(1),即递归调用的深度 = 空间复杂度
总函数的空间复杂度为O(n)
package DataStructure;
public class SpaceComplexity {
    public static void RecursionN(int n) {
        int a,b,c;
        if (n > 1) {
            RecursionN(n-1);
        }
        System.out.println("Hello,World!!!");
    }
}    

6.2 空间复杂度为O(n的平方)
1 + 2 + 3 + ... + n = [n(1+n)]/2 = 1/2*n*n + 1/2*n 
package DataStructure;
public class SpaceComplexity {
    public static void RecursionN(int n) {
        int[] flag = new int[n];
        if (n > 1) {
            RecursionN(n-1);
        }
        System.out.println("Hello,World!!!");
    }
}    

7. Java中常见内存占用