玩转算法面试：（二）面试中的复杂度分析

最新推荐文章于 2022-07-26 10:08:24 发布
最新推荐文章于 2022-07-26 10:08:24 发布
阅读量215 收藏 1
点赞数
文章标签： 面试 数据结构与算法 人工智能
原文链接：https://yq.aliyun.com/articles/630993
版权

面试中的时间复杂度分析

到底什么是大O

n表示数据规模
O(f(n)) fn是关于n的一个函数。表示运行算法所需要执行的指令数，和f(n)成正比。

常见算法复杂度

和a.b.c.d这些常数项关系不大。主要还是看它是哪个层级的。

算法A：O(n) 所需执行指令数：10000n
算法B：O(n^2) 所需执行指令数：10n^2

n的规模逐渐增大。算法a.b的指令数变化。

对比

当n大于某个临界点，a一定会超过b。这是量级上的差距。

复杂度很高的算法可能有前面的优势，在数据量很小的时候有意义。

对于所有高级的排序算法，当数据规模小到一定程度，我们都可以使用插入排序法进行优化。10%-15%。细节优化。

不同时间复杂度随着数据规模的增大，

在学术界，严格地讲，O(f(n))表示算法执行的上界
归并排序算法的时间复杂度是O(nlogn)的，同时也是O(n^2)
c.nlogn < a.n^2

在业界，我们就使用O来表示算法执行的最低上界
我们一般不会说归并排序是O(n^2)的

以主导作用的为准：

O( nlogn + n ) = O( nlogn )

O( nlogn + n^2 ) = O( n^2 )

上面的公式要求算法处理的n是一样的。

O( AlogA + B )
O( AlogA + B^2 )

上面这种不能省略

对邻接表实现的图进行遍历：
时间复杂度：O( V + E ) V是顶点个数，E是边的个数。

稠密图，甚至完全图。E是近乎V^2级别。

一个时间复杂度的问题

有一个字符串数组，将数组中的每一个字符串按照字母序排序；之后再将整个字符串数组按照字典序排序。整个操作的时间复杂度？

错误答案

每个字符串n*nlogn + 整个字符串数组：nlogn

错误：1. 字符串的长度和数组长度混淆

假设最长的字符串长度为s；数组中有n个字符串
对每个字符串排序：O(slogs)
将数组中的每一个字符串按照字母序排序：O(n*slog(s))

将整个字符串数组按照字典序排序：O(s*nlog(n))

解释：对于排序算法时间复杂度理解：
nlogn 是 比较的次数。对整型数组排序只需要nlogn次比较。因为两个整数之间比较

O(1)。两个字符串比较不一样O(s)。

O(n*slog(s)) + O(s*nlog(n)) = O( n*s*logs + s*n*logn )
                                            = O( n*s*(logs+logn) )
  1. 字符串数组进行字典序排序。比较nlogn次，每次比较需要O(s)时间复杂度。

算法复杂度在有些情况是用例相关的

插入排序算法 O(n^2)

  • 最差情况：O(n^2)
  • 最好情况：O(n)：近乎有序
  • 平均情况：O(n^2)

快速排序算法 O(nlogn)

  • 最差情况：O(n^2) 不随机。有序
  • 最好情况：O(nlogn) 随机化标定点
  • 平均情况：O(nlogn)

严谨算法最好最差平均。我们经常关注的是大多数。
极端情况心里有数就行了。

数据规模的概念

对 10^5 的数据进行选择排序，结果计算机假死？

int main() {

    for( int x = 1 ; x <= 9 ; x ++ ){
        //10的x次方的幂运算
        int n = pow(10, x);
        
        clock_t startTime = clock();

        int sum = 0;
        for( int i = 0 ; i < n ; i ++ )
            sum += i;
        clock_t endTime = clock();

        cout<<"10^"<<x<<" : "<<double(endTime - startTime)/CLOCKS_PER_SEC<<" s"<<endl;
    }
    return 0;
}
运行结果

如果要想在1s之内解决问题：

  • O(n2)的算法可以处理大约104级别的数据；
  • O(n)的算法可以处理大约10^8级别的数据；
  • O(nlogn)的算法可以处理大约10^7级别的数据

因为我们刚才的操作很简单，就是简单的加法。所以正常还需要低估一点。

空间复杂度

  • 多开一个辅助的数组：O(n)

  • 多开一个辅助的二维数组：O(n^2)

  • 多开常数空间：O(1):原地数组排序

递归调用是有空间代价的：
在递归调用前的函数压入系统栈中的。

空间复杂度O(1):
不管n有多大，只开辟了ret。索引i。
不会增加空间。

int sum1( int n ){

    assert( n >= 0 );
    int ret = 0;
    for( int i = 0 ; i <= n ; i ++ )
        ret += i;
    return ret;
}

空间复杂度O(n)
深度是n，系统栈中就要装载n个状态。
递归深度就是递归的空间复杂度

int sum2( int n ){

    assert( n >= 0 );
    if( n == 0 )
        return 0;

    return n + sum2(n-1);
}
常见的复杂度分析

O(1)
没有数据规模的变化

// O(1)
void swapTwoInts( int &a , int &b ){
    int temp = a;
    a = b;
    b = temp;
    return;
}

O(n)
循环操作次数为c.n。c是个常数不一定为大于1的数

// O(n) Time Complexity
int sum( int n ){

    int ret = 0;
    for( int i = 0 ; i <= n ; i ++ )
        ret += i;
    return ret;
}

O(n)
循环次数为1/2 n次
字符串翻转。abc-cba.第一个和倒数第一个。第2个和倒数第二个
扫描一半就交换完了：1/2*n次swap操作：O(n)

void reverse( string &s ){

    int n = s.size();
    for( int i = 0 ; i < n/2 ; i ++ )
        swap( s[i] , s[n-1-i] );
    return;
}

O(n^2)
选择排序法。O(n^2)
双重循环: 第一重到n。第二重到n。都是+1.
所执行的指令数和n^2成比例。

i = 0;j执行了n-1次

(n-1) + (n-2) + (n-3) + … + 0
= (0+n-1)*n/2
= (1/2)n*(n-1)
= 1/2*n^2 - 1/2*n
= O(n^2)

等差数列求和

// O(n^2) Time Complexity
void selectionSort(int arr[], int n){

    for(int i = 0 ; i < n ; i ++){
        int minIndex = i;
        for( int j = i + 1 ; j < n ; j ++ )
            if( arr[j] < arr[minIndex] )
                minIndex = j;

        swap( arr[i] , arr[minIndex] );
    }
}

30n次基本操作：O(n)
因为第二层循环是固定的不受n影响的。

// O(n) Time Complexity
void printInformation(int n){

    for( int i = 1 ; i <= n ; i ++ )
        for( int j = 1 ; j <= 30 ; j ++ )
            cout<<"Class "<<i<<" - "<<"No. "<<j<<endl;
    return;
}

o(logn)
对有序数组找到中间元素来判断元素和中间元素的关系。
如果没有查找到，都可以扔掉一半的元素。

二分查找法

n经过几次除以2等于1.log2n = O(logn)

// O(logn) Time Complexity
int binarySearch(int arr[], int n, int target){

    int l = 0, r = n-1;
    while( l <= r ){
        int mid = l + (r-l)/2;
        if( arr[mid] == target ) return mid;
        if( arr[mid] > target ) r = mid - 1;
        else l = mid + 1;
    }
    return -1;
}

O(logn)

n经过几次“除以10”操作后，等于0？
log10n = O(logn)
while循环中每次除以10，直到0结束。
reverse(s)复杂度：1/2 n次的交换操作。s字符串有多少位。与n一致。

string intToString( int num ){

    string s = "";
    string sign = "+";
    if( num < 0 ){
        num = -num;
        sign = "-";
    }

    while( num ){
        s += '0' + num%10;
        num /= 10;
    }

    if( s == "" )
        s = "0";

    reverse(s);
    if( sign == "-" )
        return sign + s;
    else
        return s;
}
常数差距

2n 与 3n的常数级差别

O(nlogn)

第二重循环就是n
第一重size+=size就是乘以2.log2n

// O(nlogn)
void hello(int n){

    for( int sz = 1 ; sz < n ; sz += sz )
        for( int i = 1 ; i < n ; i ++ )
            cout<<"Hello, Algorithm!"<<endl;
}

O(sqrt(n))
x从n走一直走到根号n结束

// O(sqrt(n)) Time Complexity
bool isPrime( int num ){

    for( int x = 2 ; x*x <= num ; x ++ )
        if( num%x == 0 )
            return false;
    return true;
}

bool isPrime2( int num ){

    if( num <= 1 ) return false;
    if( num == 2 ) return true;
    if( num%2 == 0 ) return false;

    for( int x = 3 ; x*x <= num ; x += 2 )
        if( num%x == 0 )
            return false;

    return true;
}
复杂度实验。

我们自以为写出了一个O(nlogn)的算法，但实际是O(n^2)的算法？

如果要想在1s之内解决问题：

  • O(n2)的算法可以处理大约104级别的数据；
  • O(n)的算法可以处理大约10^8级别的数据；
  • O(nlogn)的算法可以处理大约10^7级别的数据

前面的常数差距有可能很大。

实验，观察趋势：

每次将数据规模提高两倍，看时间的变化

四个不同复杂度的算法。

namespace MyAlgorithmTester{

    // O(logN)
    int binarySearch(int arr[], int n, int target){

        int l = 0, r = n-1;
        while( l <= r ){

            int mid = l + (r-l)/2;
            if( arr[mid] == target ) return mid;
            if( arr[mid] > target ) r = mid - 1;
            else l = mid + 1;
        }

        return -1;
    }

    // O(N)
    int findMax( int arr[], int n ){

        assert( n > 0 );

        int res = arr[0];
        for( int i = 1 ; i < n ; i ++ )
            if( arr[i] > res )
                res = arr[i];

        return res;
    }

    // O(NlogN) 自底向上
    void __merge(int arr[], int l, int mid, int r, int aux[]){

        for(int i = l ; i <= r ; i ++)
            aux[i] = arr[i];

        int i = l, j = mid+1;
        for( int k = l ; k <= r; k ++ ){

            if( i > mid )   { arr[k] = aux[j]; j ++;}
            else if( j > r ){ arr[k] = aux[i]; i ++;}
            else if( aux[i] < aux[j] ){ arr[k] = aux[i]; i ++;}
            else                      { arr[k] = aux[j]; j ++;}
        }
    }

    void mergeSort( int arr[], int n ){

        int *aux = new int[n];
        for( int i = 0 ; i < n ; i ++ )
            aux[i] = arr[i];

        for( int sz = 1; sz < n ; sz += sz )
            for( int i = 0 ; i < n ; i += sz+sz )
                __merge(arr, i, i+sz-1, min(i+sz+sz-1,n-1), aux );

        delete[] aux;

        return;
    }

    // O(N^2) 选择排序
    void selectionSort( int arr[], int n ){

        for(int i = 0 ; i < n ; i ++){
            int minIndex = i;
            for( int j = i + 1 ; j < n ; j ++ )
                if( arr[j] < arr[minIndex] )
                    minIndex = j;

            swap( arr[i] , arr[minIndex] );
        }

        return;
    }
}

生成测试用例的代码：

namespace MyUtil {

    int *generateRandomArray(int n, int rangeL, int rangeR) {

        assert( n > 0 && rangeL <= rangeR );

        int *arr = new int[n];

        srand(time(NULL));
        for (int i = 0; i < n; i++)
            arr[i] = rand() % (rangeR - rangeL + 1) + rangeL;
        return arr;
    }

    int *generateOrderedArray(int n) {

        assert( n > 0 );

        int *arr = new int[n];

        for (int i = 0; i < n; i++)
            arr[i] = i;
        return arr;
    }

}

测试是不是O(n)级别的

int main() {

    // 数据规模倍乘测试findMax
    // O(n)
    cout<<"Test for findMax:"<<endl;
    for( int i = 10 ; i <= 26 ; i ++ ){

        int n = pow(2,i);
        int *arr = MyUtil::generateRandomArray(n, 0, 100000000);

        clock_t startTime = clock();
        MyAlgorithmTester::findMax(arr, n);
        clock_t endTime = clock();

        cout<<"data size 2^"<<i<<" = "<<n<<"\t";
        cout<<"Time cost: "<<double(endTime - startTime)/CLOCKS_PER_SEC<<endl;

        delete[] arr;
    }

    return 0;
}

运行结果：

运行结果

n增加了两倍。时间也大致增加两倍，所以该算法为O(n)级别的。

测试是不是O(n^2)

int main() {

    // 数据规模倍乘测试selectionSort
    // O(n^2)
    cout<<"Test for selectionSort:"<<endl;
    for( int i = 10 ; i <= 15 ; i ++ ){

        int n = pow(2,i);
        int *arr = MyUtil::generateRandomArray(n, 0, 100000000);

        clock_t startTime = clock();
        MyAlgorithmTester::selectionSort(arr,n);
        clock_t endTime = clock();

        cout<<"data size 2^"<<i<<" = "<<n<<"\t";
        cout<<"Time cost: "<<double(endTime - startTime)/CLOCKS_PER_SEC<<endl;

        delete[] arr;
    }

    return 0;
}
运行结果：大约4倍

数据量n增加了2倍。时间增加了4倍。

int main() {

    // 数据规模倍乘测试binarySearch
    // O(logn)
    cout<<"Test for binarySearch:"<<endl;
    for( int i = 10 ; i <= 28 ; i ++ ){

        int n = pow(2,i);
        int *arr = MyUtil::generateOrderedArray(n);

        clock_t startTime = clock();
        MyAlgorithmTester::binarySearch(arr,n,0);
        clock_t endTime = clock();

        cout<<"data size 2^"<<i<<" = "<<n<<"\t";
        cout<<"Time cost: "<<double(endTime - startTime)/CLOCKS_PER_SEC<<endl;

        delete[] arr;
    }

    return 0;
}

复杂度试验

 log2N / logN
=  (log2 + logN)/logN
= 1 + log2/logN

当数据规模变大两倍。运行效率增加1.几倍。

运行结果：

运行结果，变化小

顺序查找转换为二分查找，大大提高效率

int main() {

    // 数据规模倍乘测试mergeSort
    // O(nlogn)
    cout<<"Test for mergeSort:"<<endl;
    for( int i = 10 ; i <= 24 ; i ++ ){

        int n = pow(2,i);
        int *arr = MyUtil::generateRandomArray(n,0,1<<30);

        clock_t startTime = clock();
        MyAlgorithmTester::mergeSort(arr,n);
        clock_t endTime = clock();

        cout<<"data size 2^"<<i<<" = "<<n<<"\t";
        cout<<"Time cost: "<<double(endTime - startTime)/CLOCKS_PER_SEC<<endl;

        delete[] arr;
    }

    return 0;
}

运行结果：

大约两倍
递归算法的复杂度分析

不是有递归的函数就一定是O(nlogn)!

归并排序 & 快速排序

递归中进行一次递归调用的复杂度分析：

二分查找的递归实现：
左半边或者右半边。无论选那边都只进行一次
每次减半，递归调用的深度为logn，处理问题的复杂度为O(1)

// binarySearch
int binarySearch(int arr[], int l, int r, int target){

    if( l > r )
        return -1;

    int mid = l + (r-l)/2;
    if( arr[mid] == target )
        return mid;
    else if( arr[mid] > target )
        return binarySearch(arr, l, mid-1, target);
    else
        return binarySearch(arr, mid+1, r, target);

}

如果递归函数中，只进行一次递归调用，
递归深度为depth;
在每个递归函数中，时间复杂度为T;
则总体的时间复杂度为O( T * depth )

求和递归实现
递归深度：n
时间复杂度：O(n)

// sum
int sum( int n ){

    assert( n >= 0 );

    if( n == 0 )
        return 0;
    return n + sum(n-1);
}

计算x的n次方的幂运算
我在计算x的n次方时候，如果知道n.2次方
就是x^n/2 * x^n/2

// pow2
double pow( double x, int n ){

    assert( n >= 0 );

    if( n == 0 )
        return 1.0;

    double t = pow(x, n/2);
    //奇数
    if( n%2 )
        return x*t*t;

    return t*t;
}

递归深度：logn
时间复杂度：O(logn)

递归中进行多次递归调用
在进行一次递归调用，深度就是次数。

递归树

20 + 21 + 22 + 23 + … + 2n
= 2n+1 - 1
= O(2^n)

指数级的算法：非常慢。n在20左右。30就。
剪枝操作：动态规划。人工智能：搜索树

// f
int f(int n){

    assert( n >= 0 );

    if( n == 0 )
        return 1;

    return f(n-1) + f(n-1);
}
归并排序n=8

当n等于8时，层数为3层。每一层处理的数据规模越来越小
一个分成logn层。每一层相加的总体规模还是n

// mergeSort
void mergeSort(int arr[], int l, int r){

    if( l >= r )
        return;

    int mid = (l+r)/2;
    mergeSort(arr, l, mid);
    mergeSort(arr, mid+1, r);
    merge(arr, l, mid, r);
}

分治算法。

主定理

规定了递归情况所有的时间复杂度可能。

均摊复杂度分析 Amortized Time

一个算法复杂度相对较高，但是它是为了方便其他的操作。
比较高的会均摊到整体。

动态数组（Vector）

template <typename T>
class MyVector{

private:
    T* data;
    int size;       // 存储数组中的元素个数
    int capacity;   // 存储数组中可以容纳的最大的元素个数

    // O(n)：一重循环。
    void resize(int newCapacity){

        assert( newCapacity >= size );
        T *newData = new T[newCapacity];
        for( int i = 0 ; i < size ; i ++ )
            newData[i] = data[i];
        delete[] data;

        data = newData;
        capacity = newCapacity;
    }

public:
    MyVector(){

        data = new T[100];
        size = 0;
        capacity = 100;
    }

    ~MyVector(){

        delete[] data;
    }

    // Average: O(1)
    void push_back(T e){

        //动态数组
        if( size == capacity )
            resize( 2* capacity );

        data[size++] = e;
    }

    // O(1)
    T pop_back(){

        assert( size > 0 );
        size --;

        //size是从0开始的。也就是0号索引size为1.
        //所以要拿到最后一个元素，就得size-1
        return data[size];
    }

};

假设当前数组容量为n

均摊

第n+1次会花费O(n)但是会把这n分摊到前面n次操作。也就是变成了O(2)
还是常数O(1)级的。
resize是有条件的，而不是每次都调用。

int main() {

    for( int i = 10 ; i <= 26 ; i ++ ){

        int n = pow(2,i);

        clock_t startTime = clock();
        MyVector<int> vec;
        for( int i = 0 ; i < n ; i ++ ){
            vec.push_back(i);
        }
        clock_t endTime = clock();

        cout<<n<<" operations: \t";
        cout<<double(endTime - startTime)/CLOCKS_PER_SEC<<" s"<<endl;
    }

    return 0;
}
基本满足2倍关系
删除元素缩小空间。
删除

每次普通删除时间复杂度都为O(1)

只剩下n个。这次resize n 删除这个元素为1

临界点震荡无法均摊

重复这个过程，无法均摊，复杂度为O(n)

当元素个数为数组容量的1/4时，resize.为再添加元素留出余地

template <typename T>
class MyVector{

private:
    T* data;
    int size;       // 存储数组中的元素个数
    int capacity;   // 存储数组中可以容纳的最大的元素个数

    // O(n)
    void resize(int newCapacity){

        assert( newCapacity >= size );
        T *newData = new T[newCapacity];
        for( int i = 0 ; i < size ; i ++ )
            newData[i] = data[i];
        delete[] data;

        data = newData;
        capacity = newCapacity;
    }

public:
    MyVector(){

        data = new T[100];
        size = 0;
        capacity = 100;
    }

    ~MyVector(){

        delete[] data;
    }

    // Average: O(1)
    void push_back(T e){

        if( size == capacity )
            resize( 2* capacity );

        data[size++] = e;
    }

    // Average: O(1)
    T pop_back(){

        assert( size > 0 );
        T ret = data[size-1];
        size --;
        if( size == capacity/4 )
            resize( capacity/2 );
        //resize之后会把data[size]元素抹掉
        return ret;
    }

};
运行结果

均摊复杂度：

  • 动态数组
  • 动态栈
  • 动态队列
weixin_34326429
关注
2024年携程大数据分析面试题及参考答案
大模型大数据攻城狮的专栏
09-03 902
因此，在树的深度较大时，决策树的训练速度会明显变慢，而随机森林的速度相对较稳定。抽样调查：在进行抽样调查时，统计学的方法可以帮助我们确定样本的大小和抽样方法，以保证样本的代表性和可靠性。例如，在进行民意调查时，可以使用随机抽样的方法，从总体中抽取一定数量的样本进行调查，然后通过统计分析的方法，推断总体的特征和趋势。需要注意的是，阿尔法值的选择并不是绝对的，它取决于具体的研究问题和实际情况。而随机森林可以通过随机选择特征的方式来减少特征数量的影响，因此在特征数量较多时，随机森林的速度可能会更快。
玩转算法面试 第二章_算法复杂度分析
宁宁的博客
12-17 271
第二章 面试中的复杂度分析 文章目录第二章 面试中的复杂度分析2.1 面试中的算法复杂度分析2.2 对数据规模有一个概念2.2.1 数据规模概念程序实例：2.2.2 空间复杂度：2.3 常见的代码模式对应的时间复杂度2.4 复杂度试验2.5 递归算法的复杂度分析2.6 均摊复杂度分析 2.1 面试中的算法复杂度分析 nnn表示数据规模，O（f(n)）O（f(n)）O（f(n)）表示运行算法所需要执...
玩儿转算法面试Chapter2_时间复杂度分析
Keep Learning
04-10 464
Section 1 随着算法规模n的增大，常数项系数的影响并不那么大，甚至可以忽略。 由上可知，时间复杂度衡量的是一个量级上的东西，当N超过一个点时，时间复杂度低的算法一定比时间复杂度高的算法执行慢。而我们研究的一般是大规模数据，因为对于小规模数据，研究算法其实没什么意思，比如排序，当N小于一个值时，便使用插入排序。 以上是针对数据规模一样的情况，可以选取量级大的那个代表整个算法...
算法复杂度
曾飞的博客
11-18 367
什么是算法？ 算法(algorithm) 是一个很古老的概念，来自于数学。 在数学领域里，算法是用于解决某一类问题的公式和思想。 在计算机科学领域里，算法的本质是一系列程序指令，用于解决特定的运算和逻辑问题。 算法的应用领域 运算 查找 百度、谷歌搜索；数据库执行一条 SQL 语句 排序 成绩排名、价格排序、热门等等 最优决策 推箱子最短路径 面试 ???? 为什么面试官那么喜欢考查算法呢？ 可...
面试时候常说的复杂度到底是什么？
热门推荐
LoveSummer
07-26 1万+
我们在面试的时候，总有面试官喜欢问，时间复杂度，空间复杂度，就比如像O(n²)这种，那么这种时间复杂度是怎么定义的，为啥用这种定义的，最后时间复杂度都代表和你程序有什么关系呢？今天来说说关于复杂度自己的看法。...
笔试面试——算法篇
写作帮助思考
04-30 786
排序算法 选择原则：数据量小考虑编程量；数据量大考虑执行时间和存储空间。 按数据量： 大列表：快排，归并，桶排序，基数排序 小列表：冒泡，选择，插入，Shell O(1)&lt; O(log2n)&lt; O(n) &lt; O(nlog2n) &lt; O(n^2) 平均时间复杂度排序：基数&lt; 堆、归并、快排 &lt; shell &lt; 插入、冒泡、选择 冒泡排序 ...
玩转算法面试 leetcode
最新发布
01-13
1 算法面试到底是什么鬼？...2 面试中的复杂度分析 3 数组中的问题其实最常见 4 查找表相关问题 5 在链表中穿针引线 6 栈、队列、优先队列 7 二叉树和递归 8 递归和回溯法 9 动态规划基础 10 谈心算法 11 课程总结
一起玩转算法面试，保姆级攻略（附高清无码算法总结导图）,建议收藏
启舰
06-29 1万+
本文已收录至启舰的电子书《逆天改命—程序员的成神之路》，github地址：https://github.com/harvic/FightingCoder 欢迎star。点击【阅读原文】也可直达。 我大学时候也很傻，为了校招，看了不下于五本算法书，加上LeetCode，刷了大半年。 总共一两千道题啊……不刷怕考到……忘了刷，刷了忘……毛都快掉没了…… 现在工作近十年，辗转几个大厂，由当年的应试者变成了出题人，才知道，完全不必这么辛苦。 任何事情都遵循28原则，我们只要把握住那20%，就能拿到80..
玩转算法leetcode.docx
09-26
"玩转算法LeetCode"的文档很可能包含了大量关于如何有效地解决LeetCode上算法题目的技巧和策略。 LeetCode上的问题覆盖了排序、搜索、图论、动态规划、回溯、贪心算法等多种类型。以下是一些关键的算法知识点： 1....
韩顺平程序员一周玩转算法的ppt，图解，笔记
11-20
《韩顺平程序员一周玩转算法的PPT、图解及笔记》是针对初学者和有一定编程基础的程序员设计的一套全面的算法学习资源。这个资料包由知名IT教育专家韩顺平老师精心制作，旨在帮助学员在短时间内理解和掌握算法的核心...
时间复杂度 & 空间复杂度
Razera的博客
11-15 425
时间复杂度 & 空间复杂度 一.时间复杂度 一.简介 定义：算法中某个函数有n次基本操作重复执行，用T(n)表示，现在有某个辅助函数 f(n)，使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度 T(n)：循环次数（操作次数） f(n)：量级函数...
时间复杂度/空间复杂度
ysj1218的博客
12-11 341
时间复杂度、空间复杂度我之前从来没有了解过，他们是什么，有什么作用呢？？ 最近偶然的机会看算法遇到了这两个东西，所以就简单的来了解一下，以下纯属个人理解，有问题欢迎指出~~ 那么什么是时间复杂度，什么是空间复杂度呢？？ 时间复杂度：一个算法的执行时间根据数据规模增加的一个趋势。 空间复杂度：占用内存的趋势。 T(n) = O(f(n)) S(n) = O(f(n)) 这个叫做大O表示法，表示随着输入的值变化，程序运行所需要的时间与输入值的变化关系。 T表示算法需要执行的总时间 S表示算法需要
算法时间复杂度计算-以前一直不懂，现在好像有点懂了！
我仅仅是一个Coder
01-06 1915
算法的时间复杂度 2007年12月02日 星期日 01:17 定义：如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)，它是n的某一函数 T(n)称为这一算法的“时间复杂性”。 当输入量n逐渐加大时，时间复杂性的极限情形称为算法的“渐近时间复杂性”。 我们常用大O表示法表示时间复杂性，注意它是某一个算法的时间复杂性。大O表示只是说有上界，由定义如
数据结构—算法时间复杂度、空间复杂度和问题规模
小K同学
01-19 1万+
1、时间复杂度 （1）时间频度一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。（2）时间复杂度在刚才提到...
面试用算法复杂度总结
woaidapaopao的博客
05-16 3156
面试时被问到了很多算法复杂度的东西，现在做个总结。主要从树结构和排序的角度分析这些常用算法的时间和空间复杂度。 一、复杂度简介 1、空间复杂度 空间复杂度有很多影响因素，如指令空间、数据空间（动态数组、动态类实例、常量和简单变量的存储空间）、环境栈空间（常在递归时使用）。一般说的空间复杂度是指所需要的可变空间，也就是动态数据或栈所用所需的空间。 2、时间复杂度 主要关注运行时间，常用
一天一道笔试题之常用算法的复杂度
Mrhuang的博客
04-26 690
数组A由1000W个随机正整数(int)组成，设计算法，给定整数n，在A中找出符合如下等式:n=a+b的a和b，说明算法思路以及时间复杂度是多少?参考答案方法一、数组排序，二分 1000w数字存到数组中，需要的地址空间为1000w*4byte=4w kb =40 Mb。这个容量是可以接受的。 将数组快速排序，时间复杂度n*logn 对任给的n n=a+b a,b组合无非是 0,n 1,n-1 .....
java定时器只执行一次_面试Java后端却问我时间轮（Time Wheel）算法，面试官没想到我看过Dubbo源码！
weixin_39750854的博客
11-29 275
1 定时任务Netty、Quartz、Kafka 以及 Linux 都有定时任务功能。常规的JDK 的 java.util.Timer 和 DelayedQueue 等工具类，可实现简单的定时任务，底层用的是堆数据结构，存取复杂度都是 O(nlog(n))，无法支撑海量定时任务。而在定时任务量大、性能要求高的场景，为将任务存取及取消操作时间复杂度降为 O(1)，会使用时间轮方案。2 时间轮模型及其...
算法的时间复杂度和空间复杂度评估
诸葛小猿
10-27 856
通常，对于一个给定的算法，我们要做 两项分析。第一是从数学上证明算法的正确性，这一步主要用到形式化证明的方法及相关推理模式，如循环不变式、数学归纳法等。而在证明算法是正确的基础上，第二部就是分析算法的时间复杂度。算法的时间复杂度反映了程序执行时间随输入规模增长而增长的量级，在很大程度上能很好反映出算法的优劣与否。因此，作为程序员，掌握基本的算法时间复杂度分析方法是很有必要的。 算法执行时间需通过依据该算法编制的程序在计算机上运行时所消耗的时间来度量。而度量一个程序的执行时间通常有两种方法。 一、事后统计的方
一个由IsPrime算法引发的细节问题
weixin_30883271的博客
09-18 105
//******************************* // // 2014年9月18日星期四，于宿舍撰写 // 作者：夏华林 // //******************************** 好久没有没有更新博客了，最近确实烦心事儿挺多，已经大三了，真的静下心来好好看看书了。 今天要说的，就是一个由IsPrime算法引发的细节问题，我这里说的细节，...
排序算法详解：稳定性与时间复杂度分析
此外，文档还提到了快速排序，强调了面试中测试工程师应关注的技术点，特别是算法的重要性。文档来自于牛客网，一个提供海量校招笔试面试真题的在线学习平台，同时也提供了面试题库的下载和学习建议。" **排序算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值