数据结构与算法笔记系列一：算法概述

一、数据结构与算法概述

1、数据结构

数据结构：用来组织和存储数据的集合

数据结构可分为逻辑结构和物理结构。逻辑结构从数据与数据之间的关系来划分，物理结构从计算机存储角度来分类（又称存储结构）。

• 逻辑结构：集合结构、线性结构、树形结构、图形结构
• 物理结构（存储结构）：顺序存储结构、链式存储结构

2、算法

算法：算法即分步骤解决问题的过程。

二、算法分析

衡量算法优劣的标准：时间、空间

1、算法的时间复杂度分析

分析一个算法的运行时间，最重要的就是把核心操作的次数和输入规模关联起来

1.1 函数渐进增长

概念：给定两个函数f(n),g(n)，如果存在一个整数N，使得对于所有的n>N,f(n)总是比g(n)大，那么我们说f(n)的增长渐进快于g(n)。

1.2 算法时间复杂度

1.2.1 大O记法

注：执行次数=执行时间

大O记法的规则：

1. 用常数1取代运行时间中的所有加法常数
2. 在修改后的运行次数中，只保留高阶项
3. 如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数

eg：

算法1:3次		O(1)
算法2:n + 3次		O(n)
算法1:2n^2 + 3次		O(n^2)

1.2.2 常见的大O阶

1、线性阶

int sum = 0;
int n = 100;
for (int i = 0; i < n; i++) {
  sum += i;
}
System.out.println("sum = " + sum);

时间复杂度 O(n)

2、平方阶

int sum = 0;
int n = 100;
for (int i = 0; i < n; i++) {
  for (int j = 0; j < i; j++) {
    sum += i;
  }
}
System.out.println("sum = " + sum);

时间复杂度：O(n^2)

3、立方阶

一般三重嵌套循环属于这种复杂度

4、对数阶

int i = 1, n = 100;
while (i < n) {
  i = i * 2;
}

由于每次i*2之后，就距离n更近一步，假设有x个2相乘后大于n，则会退出循环。由于是2^x=n,得到x=log(2)n,所以这个循环的时间复杂度为O(logn);
对于对数阶，由于随着输入规模n的增大，不管底数为多少，他们的增长趋势是一样的，所以我们会忽略底数。

5、常数阶

一般不涉及循环操作的都是常数阶，因为它不会随着n的增长而增加操作次数。时间复杂度O(1)

描述	增长的数量级	说明	举例
常数级别	1	普通语句	两个数相加
对数级别	logN	二分策略	二分查找
线性级别	N	循环	找出最大元素
线性对数级别	NlogN	分治思想	归并排序
平方级别	N^2	双层循环	检查所有元素对
立方级别	N*3	三层循环	检查所有三元组
指数级别	2^N	穷举查找	检查所有子集

时间复杂度从低到高依次为：

O(1) < O(logN)<O(N) < O(NlogN) < O(n^2) < O(n^3) < O(2^n)

1.2.3 最坏情况

public static int search(int num) {
int[] arr =[11, 8, 9, 7, 22, 32, 0];
for (int i = 0; i < arr.length; i++) {
  if (num == arr[i]) {
    return i;
  }
}
return -1;
}

最好情况：查找的第一个数字就是期望的数字，那么算法的时间复杂度为O(1)

最坏情况：查找的最后一个数字，才是期望的数字，那么算法的时间复杂度为O(n)

平均情况：任何数字查找的平均成本是O(n/2)

2、算法的空间复杂度分析

2.1 Java中常见内存占用

数据类型	内存占用字节数
byte	1
short	2
int	4
long	8
float	4
double	8
boolean	1
char	2

• 计算机访问内存的方式都是一次一个字节

• 一个引用（机器地址）需要8个字节表示

  Data date = new Date();	//date变量需要占用8个字节表示
  

• 创建一个对象，比如new Date()，除了Date对象内部存储的数据占用的内存，该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息。

• 一般内存的使用，如果不够8个字节，都会被自动填充为8字节。

  

• Java中数组被限定为对象。他们一般会因为记录长度而需要额外的内存。一个原始数据类型的数组一般需要24字节的头信息（16个自己的对象开销，4字节用于保存长度以及4个填充字节）再加上保存值所需的内存。

eg：

public static int[] reverse1(int[] arr) {
int n = arr.length; //申请4个字节
int temp; //申请4个字节
for (int start = 0, end = n - 1; start <= end; start++, end--) {
  temp = arr[start];
  arr[start] = arr[end];
  arr[end] = temp;
}
return arr;
}

public static int[] reverse2(int[] arr) {
int n = arr.length; //申请4个字节
int[] temp = new int[n];  //申请n*4个字节+数组自身头信息开销24个字节
for (int i = n - 1; i >= 0; i--) {
  temp[n - 1 - i] = arr[i];
}
return temp;
}

算法一：不管传入的数组大小为多少，始终额外申请4+4=8个字节；空间复杂度：O(1)

算法二：4+4n+24=4n+28；空间复杂度：O(n)