数据结构系列1——初识数据结构与算法

引言

Java的学习进入了二个阶段了，JavaSE部分是Java的基础入门，主要是对Java的基本语法进行学习。下面来到数据结构方面，数据结构对于算法的学习是至关重要的，在这里写下这一些系列的笔记，帮助自己学习数据结构，啥也不说了，努力学习就对了！！

下面开始数据结构系列。

一、什么是集合框架

Java集合框架（Java Collection FramWork）又称容器（Container），是定义在Java.util包下的一组接口（interface）和其实现类（class），其主要表现为多个元素置于一个单元里面，用于对这些元素进行快速的便捷的存储、检索、管理、即：增删改查。

接下来的学习就是围绕着上图进行学习。

二、数据结构

定义：数据结构是计算机存储、组织数据的方式，指相互之间存在一种或者多种特定关系的数据元素的集合。

学习数据结构需要注意哪些问题？

1. 数据结构是一门单独的学科，它跟语言是没有关系的。

2. 数据结构的实现只是语言不同，思想是一样的。

3. 我们描述和组织数据的方式不一致，所以我们有很多种数据结构用来应付不同的场景。

4. 数据库也是单独的学科是和数据结构不同的，数据库是用来存储数据的。

5. 数据库的底层会用到数据机构来描述存储数据。

6. Java集合类就时被封装好的数据结构。

三、什么是算法

1.定义

就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

2.算法的效率

算法的效率分为两种：

1.时间效率 （时间复杂度）衡量的是算法的运行速度

2.空间效率（空间复杂度）衡量的是算法运行所需要的空间

以上两种谁是最主要的影响因子呢？

答：时间复杂度

原因：随着时代的发展，计算机的存储容量达到了很高的一个程度，空间相对于时间来说就不是那么重要了。

3.时间复杂度

定义：简单的来说，时间复杂度是一个数学函数，它定义了该算法的运行时间。但是不同配置的计算机对于一个程序的运行时间是不相同的，所以通过我们了解一个算法运行时间和其执行的语句的次数是成正比的。所以 我们将算法中基本操作的执行次数，为算法的时间复杂度。

3.1大O的渐进表示法

void func1(int N){
    int count = 0;
    for (int i = 0; i < N ; i++) {
    for (int j = 0; j < N ; j++) {
      count++;
    }
    }
     for (int k = 0; k < 2 * N ; k++) {
    count++;
 }
    int M = 10;
    while ((M--) > 0) {
    count++;
    }
    System.out.println(count);
}

上面的算执行了多少次呢？

首先第一次for循环里面嵌套了个for循环：

接下来有事一个for循环执行了2N次

最后有一个while循环，执行了10次

总起来为：

在我我们实际中不需要精确的算出执行的次数，而只算出大概得次数就可以了，当N特变大的时候最主要的还是阶的数据了。

这里采用大O渐进法。

规则如下所示：

1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

时间复杂度又分为：最好时间复杂度、平均时间复杂度、最差时间复杂度。

比如查找一个数组的某一个元素：

最好的情况为第一个就查找到了，那么最好时间复杂度就时O(1)，最坏的情况就是第N次才找到，那么这就是最坏时间复杂度O(N)那么平均时间复杂度就是O(N/2)，一般情况下我们都是用最坏时间复杂度进行表示。

3.2 常见时间复杂度进行举例

实例1：

void func2(int N) {
    int count = 0;
    for (int k = 0; k < 2 * N ; k++) {
    count++;
    }
    int M = 10;
    while ((M--) > 0) {
    count++;
    }
    System.out.println(count);
}

时间复杂度：O(N)

---

实例2

void func3(int N, int M) {
    int count = 0;
    for (int k = 0; k < M; k++) {
    count++;
    }
    for (int k = 0; k < N ; k++) {
    count++;
    }
    System.out.println(count);
}

时间复杂度：O(N+M)

实例2基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)

---

实例3

void func4(int N) {
    int count = 0;
    for (int k = 0; k < 100; k++) {
    count++;
    }
    System.out.println(count);
}

时间复杂度：O(1)

实例3执行次数为100，化常数项为1

---

实例4

void bubbleSort(int[] array) {
    for (int end = array.length; end > 0; end--) {
    boolean sorted = true;
    for (int i = 1; i < end; i++) {
      if (array[i - 1] > array[i]) {
        Swap(array, i - 1, i);
        sorted = false;
         }
    }
    if (sorted == true) {
      break;
        }
    }
}

时间复杂度为：O()

是：N-1 N-2 N-3 。。。1 是一个等差数列求和，为N(N-1)/2 最后取最高阶，并且取出最高阶的系数为

---

实例5

int binarySearch(int[] array, int value) {
    int begin = 0;
    int end = array.length - 1;
    while (begin <= end) {
    int mid = begin + ((end-begin) / 2);
    if (array[mid] < value)
      begin = mid + 1;
    else if (array[mid] > value)
      end = mid - 1;
    else
      return mid;
    }
    return -1;
}

时间复杂度：O()

数据个数 次数

2 2

4 3

8 4

最后

按照大O渐进表示为O()

---

实例6

int fibonacci(int N) {
    return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}

上面是使用递归的方式进行求解斐波那契数字的第N项

时间复杂度：

解析：

执行的次数：

等比公式进行求和：

>>>时间复杂度：

那么这里我们回忆下使用循环的角度进行求解斐波那契数列，这种方式的时间复杂度是多少呢?

public static int fibonacci(int N){  
    if (N == 1 || N == 2){
        return 1;
    }else{
        int a = 1;
        int b = 1;
        int c = 0;
        for (int i = 3; i <= N; i++) {
            c = a+b;
            a = b;
            b = c;
        }
        return c;
    }
}

时间复杂度为：O(N)

所以求解斐波那契数列使用循环的效果是最好的。

---

实例7

long factorial(int N) {
    return N < 2 ? N : factorial(N-1) * N;
}

时间复杂度：O(N)

每次的递归次数都为1，递归了N次

4.空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。

---

实例1

void bubbleSort(int[] array) {
    for (int end = array.length; end > 0; end--) {
    boolean sorted = true;
    for (int i = 1; i < end; i++) {
      if (array[i - 1] > array[i]) {
        Swap(array, i - 1, i);
        sorted = false;
       }
    }
    if (sorted == true) {
      break;
       }
    }
}

无论执行多少次，只有一个变量sorted，所浪费的临时占用的空间不会随着问题的规模增大而增大，所以空间复杂度为 O(1)

---

实例2

int[] fibonacci(int n) {
    long[] fibArray = new long[n + 1];
    fibArray[0] = 0;
    fibArray[1] = 1;
    for (int i = 2; i <= n ; i++) {
    fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
    }
    return fibArray;
}

空间复杂度为：O(N)

此程序要将计算出来的斐波那契数存储到一个数组里面，所开辟的空间就是N个

---

实例3

long factorial(int N) {
    return N < 2 ? N : factorial(N-1)*N;
}

实例3递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)

递归一次在栈帧上开辟一个内存

---

实例4

int fibonacci(int N) {
    return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}

空间复杂度：O(N)

我们计算右边的时候，左边已经计算完了，组多开辟N个栈帧。

最常见的复杂度的大O的渐进法表示