时间空间复杂度

数据元素：组成数据的基本单位

数据项：一个数据元素由多个数据项组成

数据对象：性质相同的数据元素的集合

数据类型：不同数据的集合

struct student   // 数据类型
{
    char *name;  // 数据项
    char age;
};
student zsy;    　　　//数据元素
student class[50];   //数据对象

 数据结构：数据对象中数据元素之间存在特定关系的集合。

 数据之间的关系：

　　 数据逻辑结构：集合结构，线性结构（一对一），树形结构（一对多），图形结构（多对多）。

　　 数据物理存放结构：顺序存储结构（连续内存地址），链式存储结构（这一个保存下一个数据元素的地址）。

算法依附于数据结构。算法是程序的灵魂。

算法效率：算法中算法操作数（执行步骤）的最高阶项。常数项，低次项对于效率没有影响。  　　

算法复杂度：时间复杂度：算法运行时间（定性的描述）

 　　　　　   空间复杂度：算法占用空间（定性的描述）

 大O(operation)表示法：算法效率依赖于操作数，操作数量是时间复杂度， 

long sum1(int n)  
{
    long ret = 0;    // 执行1次
    int *array = new int[n];  // 执行n
    for(int i = 0; i<n; i++)   // 执行1次
    {
        array[i] = i + 1;
    }
}

时间复杂度：O(n+2) = O(n)

O(5)                    = O(1)
O(2n+1)     = O(2n)  　 = O(n)
O(n*n+n+1)              = O(n*n)
O(3n*n*n+1) = O(3n*n*n) = O(n*n*n) 

 线性时间复杂度：O(n)　　

 对数阶时间复杂度：O(logn)

 平方阶时间复杂度：O(n*n)

for(i=0;i<n;i++){}  O(n)    //线性时间复杂度
while(i<n){i*=2}    O(log2n) //对数时间复杂度
for(i=0;i<n;i++)
{
    for(j=0;j<n;j++)
    {}              O(n*n)  // 平方时间复杂度
}

 常见时间复杂度：

 算法时间复杂度应该小于O(n*n*n)

算法空间复杂度：算法运行期间所占用的内存。

 Space Complexity --> S( )

long sum1(int n)  // 1
{
    long ret = 0;    // 1 
    int *array = new int[n];  // n
    for(int i = 0; i<n; i++)   // 1
    {
        array[i] = i + 1;
    }
}

所需内存单位：n + 4;
空间复杂度：S(n+4) = S(n)

时间复杂度优先于空间复杂度。有必要空间换时间。

/*
    问题： 
    在一个由自然数1-1000中某些数字所组成的数组中，每个数字可能出现零次或者多次。
    设计一个算法，找出出现次数最多的数字。
*/

#include <iostream>

using namespace std;

void search(int a[], int len)     // O(n)
{
    int sp[1000] = {0};
    int max = 0;
    
    for(int i=0; i<len; i++)
    {
        sp[a[i] - 1]++;
    }    
    for(int i=0; i<1000; i++)
    {
        if( max < sp[i] )
        {
            max = sp[i];
        }
    }    
    for(int i=0; i<1000; i++)
    {
        if( max == sp[i] )
        {
            cout << i + 1 << endl;
        }
    }
}

int main(int argc, char* argv[])
{
    int a[] = {1, 1, 3, 4, 5, 6, 6, 6, 3, 3};
    search(a, sizeof(a)/sizeof(*a));
    return 0;
}