数据结构的时间复杂度与空间复杂度

数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
算法：算法就是一系列的计算步骤，用来将输入数据转化成输出结果。
算法效率分为两种：一种是时间复杂度（衡量一个算法的运行速度），另一种是空间复杂度（衡量一个算法所需要的额外的空间）。

时间复杂度

cpu每秒运行百万条指令数是恒定的，因此衡量算法快慢的标准为：数据规模（n)与算法运行的指令个数（F（n））。
一个算法的时间复杂度是算法运行的指令个数。
衡量算法时不需要精确描述，使用大O渐进表示法：1.只保留最高阶项2.最高此项系数变为1.

常见时间复杂度

O（n）:

int String.indexOf(int ch);

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

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); 
}

O(m+n)

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(1)

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

O(n^2)

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(log(n))

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^n)

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

利用时间复杂度估算算法耗时

1.了解主机的CPU主频
耗时=时间复杂度/主频

空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度（不考虑输入输出中用到的空间），也使用O渐进表示法
冒泡排序空间复杂度：O（1）
空间复杂度：O（n）

long[] 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次，每个栈祯使用了常数个空间，空间复杂度为O（N）

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