2. 程式人生 > >時間復雜度和空間復雜度計算

時間復雜度和空間復雜度計算

阿新 • • 發佈：2018-07-14
printf inter fine 次方 輸入 pre purple sizeof 如果

時間復雜度：
首先要說的是，時間復雜度的計算並不是計算程序具體運行的時間，而是算法執行語句的次數。
當我們面前有多個算法時，我們可以通過計算時間復雜度，判斷出哪一個算法在具體執行時花費時間最多和最少。

常見的時間復雜度有：
常數階O(1),
對數階O(log2 n),
線性階O(n),
線性對數階O(n log2 n),
平方階O(n^2)，
立方階O(n^3)
k次方階O(n^K),
指數階O(2^n)。
隨著n的不斷增大，時間復雜度不斷增大，算法花費時間越多。

計算方法
①選取相對增長最高的項
②最高項系數是都化為1
③若是常數的話用O（1）表示
如f（n）=2*n^3+2n+100則O（n）=n^3。

通常我們計算時間復雜度都是計算最壞情況
時間復雜度的計算：
（1）如果算法的執行時間不隨著問題規模n的增加而增長，即使算法中有上千條語句，其執行時間也不過是一個較大的常數。此類算法的時間復雜度是O(1)。

        int x=1;
    while (x <10)
    {
        x++;
    }
  • 1
  • 2
  • 3
  • 4
  • 5

該算法執行次數是10，是一個常數，用時間復雜度表示是O(1)。

（2）當有若幹個循環語句時，算法的時間復雜度是由嵌套層數最多的循環語句中最內層語句的頻度f(n)決定的。

    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            ;
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

該算法for循環，最外層循環每執行一次，內層循環都要執行n次，執行次數是根據n所決定的，時間復雜度是O（n^2）。

（3）循環不僅與n有關，還與執行循環所滿足的判斷條件有關。

int i=0;
while (i < n && arr[i]!=1)
    {
        i++;
    }
  • 1
  • 2
  • 3
  • 4
  • 5

在此循環，如果arr[i]不等於1的話，時間復雜度是O（n）。如果arr[i]等於1的話，則循環不能執行，時間復雜度是0。

空間復雜度
空間復雜度是對一個算法在運行過程中臨時占用存儲空間大小的量度。
計算方法：
①忽略常數，用O(1)表示
②遞歸算法的空間復雜度=遞歸深度N*每次遞歸所要的輔助空間
③對於單線程來說，遞歸有運行時堆棧，求的是遞歸最深的那一次壓棧所耗費的空間的個數，因為遞歸最深的那一次所耗費的空間足以容納它所有遞歸過程。

如：

int a;
int b;
int c;
printf("%d %d %d \n",a,b,c);
  • 1
  • 2
  • 3
  • 4

它的空間復雜度O（n）=O（1）；

int fun(int n,)
{
int k=10;
if（n==k)
return n;
else
return fun(++n);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

遞歸實現，調用fun函數，每次都創建1個變量k。調用n次，空間復雜度O（n*1）=O（n)。

舉例說明

1：實現二分查找算法的遞歸及非遞歸。（分析時間復雜度及空間復雜度）

叠代算法

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<string.h>
#include<assert.h>

int BinarySearch(int arr[], int len, int num)
{
    assert(arr);

    int left = 0;
    int right = len - 1;
    int mid;

    while (left <= right)
    {
        mid = left + (right - left) / 2;

        if (num > arr[mid])
        {
            left = mid + 1;
        }
        else if (num < arr[mid])
        {
            right = mid - 1;
        }
        else
        {
            return mid;
        }
    }

    return -1;
}



int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9 };
    int length = sizeof(arr) / sizeof(arr[0]);
    int aim = 9;
    int result;

    result = BinarySearch(arr, length, aim);

    if (result == -1)
    {
        printf("Can‘t find %d\n", aim);
    }
    else
    {
        printf("%d at %d postion\n", aim,result + 1);
    }


    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

二分查找時，每次都在原有查找內容進行二分，所以時間復雜度為O（log2 n）
因為變量值創建一次，所以空間復雜度為O（1）

遞歸算法

int BinarySearchRecursion(int arr[5], int lef, int rig,int aim)
{
    int mid = lef + (rig - lef) / 2;


    if (lef <= rig)
    {
        if (aim < arr[mid])
        {
            rig = mid - 1;
            BinarySearchRecursion(arr, lef, rig, aim);
        }
        else if (arr[mid] < aim)
        {
            lef = mid + 1;
            BinarySearchRecursion(arr, lef, rig, aim);
        } 
        else if (aim == arr[mid])
        {
            return mid;
        }

    }
    else
        return -1;

}


int main()
{
    int arr[] = { 1,2,3,5,6, };
    int sz = sizeof(arr)/sizeof(arr[0]);
    int result;

    result = BinarySearchRecursion(arr, 0, sz - 1, 4);

    if (-1 == result)
    {
        printf("Can‘t find it.\n");
    }
    else
        printf("Aim at %d location\n", result+1);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

時間復雜度為O（log2 n）
每進行一次遞歸都會創建變量，所以空間復雜度為O（log2 n）

2：實現斐波那契數列的遞歸及非遞歸。（分析時間復雜度及空間復雜度）

叠代算法

int FeiBoNaCciInteration(int a,int b,int num)
{
    int c;

    if (num <= 0)
        return -1;
    else if (num == 1)
        return a;
    else if (num == 2)
        return b;
    else
    {
        while (num - 2)
        {
            c = a + b;
            a = b;
            b = c;
            num--;
        }
        return c;
    }

}

int main()
{
    int n;
    int result;

    printf("Input n\n");
    scanf("%d", &n);

    result = FeiBoNaCciInteration(2, 3, n);//可自定義輸入第一個數和第二個數
    if (result == -1)
    {
        printf("Input Error!\n");
    }
    else
    {
        printf("n is %d\n", result);
    }

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

時間復雜度O（n)
空間復雜度為O（1）

遞歸算法

int FeiBoNaCciRecursion(int num)
{
    if (num < 0)
        return -1;
    if (num <= 2 && num > 0)
        return 1;
    else
        return FeiBoNaCciRecursion(num - 1) + FeiBoNaCciRecursion(num - 2);

}

int main()
{
    int n;
    int result;

    printf("Input n\n");
    scanf("%d", &n);

    result = FeiBoNaCciRecursion(n);

    if (result == -1)
        printf("Input Error!\n");
    else
        printf("Result is %d\n", result);

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

時間復雜度為O（2^n）
空間復雜度為O（n）

時間復雜度和空間復雜度計算

相關推薦

算法的時間復雜度和空間復雜度合稱為算法的復雜度

... 比例 和平 部分 i++ 兩個 表示 利用 最後一個元素 算法的時間復雜度和空間復雜度合稱為算法的復雜度。 1.時間復雜度 （1）時間頻度 一個算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個算法都上機測試，只需知

各個排序算法的時間復雜度和空間復雜度

性能 .com ima 快速 bsp img 程序 執行過程 堆排序 空間復雜度 空間性能是排序所需輔助空間大小 所有簡單排序和堆排序都是0(1) 快速排序為0(logn)，要為遞歸程序執行過程棧所需的輔助空間 歸並排序和基數排序所需輔助空間最多，為O(n) 各個排

常用的排序算法的時間復雜度和空間復雜度

排好序 dsm 特性 樹形選擇排序 臨時 快速排序 向上 [88 規律 常用的排序算法的時間復雜度和空間復雜度 排序法 最差時間分析 平均時間復雜度 穩定度 空間復雜度 冒泡排序 O(n2) O(n2)

算法的時間復雜度和空間復雜度詳解

時間復雜度 沒有 實例 可能 以及 基本操作 語句 存儲空間 們的 算法的時間復雜度和空間復雜度合稱為算法的復雜度。 1.時間復雜度 （1）時間頻度 一個算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個算法都上機測試，

Python(算法)-時間復雜度和空間復雜度

循環 次方 body Go algorithm 時間復雜度 過程 php 使用 時間復雜度 算法的時間復雜度是一個函數，它定量描述了該算法的運行時間，時間復雜度常用“O”表述，使用這種方式時，時間復雜度可被稱為是漸近的，它考察當輸入值大小趨近無窮時的情況 時間復雜度是用來估

算法時間復雜度和空間復雜度的計算

++ rdquo info 極限 時間 算法 空間 log 一次 算法，即解決問題的方法。同一個問題，使用不同的算法，雖然得到的結果相同，但是耗費的時間和資源是不同的。 就比如要擰一個螺母，使用扳手還是鉗子是有區別的，雖然使用鉗子也能擰螺母，但是沒有扳手好用。&ldquo

算法的時間復雜度和空間復雜度

常量 它的 並且 alt 綜合 nom 交換 等於 for 原文：https://blog.csdn.net/zolalad/article/details/11848739 博主：zolalad 　　通常，對於一個給定的算法，我們要做 兩項分析。第一是從數學上證明算法

EZ娛樂源碼出售時間復雜度和空間復雜度

end 規模 lse fun 註意 art QQ 級別 href 時間復雜度常見的時間復雜度有EZ娛樂源碼出售請添加鏈接描述（www.1159880099.com） QQ1159880099：常數階O(1)，對數階O(log2n)，線性階O(n)，線性對數階O(nlog2n

時間復雜度和空間復雜度計算

printf inter fine 次方 輸入 pre purple sizeof 如果 時間復雜度： 首先要說的是，時間復雜度的計算並不是計算程序具體運行的時間，而是算法執行語句的次數。 當我們面前有多個算法時，我們可以通過計算時間復雜度，判斷出哪一個算法在具體執行時

前塵----時間復雜度和空間復雜度計算

只需要 存在 基礎 n-1 因此 大致 for循環 長時間 計算機 算法：算法是解決特定問題求解步驟的描述，在計算機中表現為指令的有限序列，並且每條指令表示一個或者多個操作。 算法的五個特性：　 輸入輸出：算法具有零個或多個輸入，算法至少有一個或者多個輸出。輸出的形式可以

循序漸進帶你學習時間復雜度和空間復雜度。

準備 日常 數據結構 media 輸入數據 有時 學習過程 幫助 和平 本文字數：4894 字 閱讀本文大概需要：13 分鐘 寫在之前 我們都知道，對於同一個問題來說，可以有多種解決問題的算法。盡管算法不是唯一的，但是對於問題本身來說相對好的算法還是存在的，這

時間復雜度和空間復雜度

變量 效率 spa 表達式 圖像 .com urn 代碼 需要 B 先引入一段代碼： 1 int cal(int n) { 2 int ret = 0; 3 int i = 1; 4 for (; i < n; ++i) { 5

時間復雜度與空間復雜度

和平 變化 大小 關系 常數 工作 post 空間 div 時間復雜度： 　　1，時間頻度（Tn）:不能計算需上機測試，一個算法中語句執行次數稱為語句頻度或時間頻度。一個算法花費時間與算法中語句執行次數成正比。 　　2，時間復雜度0((fn)):當問題規模(n)不斷變化，時

算法基礎 -- 簡介時間復雜度與空間復雜度

耗時 需要 語言 忽略 turn text 綜合 color 關心 　　算法是為求解一個問題所需要遵循的、被清楚地指定的簡單指令的集合。對於一個問題，一旦給定某種算法並且確定其實正確的，那麽重要的一步就是確定該算法將需要多少諸如時間或空間等資源量的問題，這就是時間復雜度和空

關於時間復雜度與空間復雜度總結

條件語句 存儲空間 開始 每次 基本 對數 時間 strong 關於 簡單來說，時間復雜度指的是語句執行次數，空間復雜度指的是算法所占的存儲空間。 一般情況下，隨著n的增大，T(n)增長最慢的算法為最優算法。 1.對於簡單的輸入輸出語句或賦值語句(無循環語句)，近似認為

時間復雜度、空間復雜度，如何”不復雜“地學？

期望 roc blank 很多 ret 大於等於 如果 出了 付出 時間復雜度、空間復雜度，如何”不復雜“地學？ 2018-10-28 13:04獨立/大一/大學 作者 | Rocky0429 責編 | 胡巍巍 寫在之前 我們

均攤復雜度和防止復雜度的震蕩

png iter 平均值 ima ger throw memory ++ size 關於上一節中我們對添加操作的時間復雜度歸結為O(n)是考慮了擴容操作(resize)在內的。就addLast(e)操作而言，時間復雜度為O(1)，在考慮最壞情況下，每次添加均會觸發擴容操作，

循序漸進帶你學習時間複雜度和空間複雜度。

本文字數：4894 字 閱讀本文大概需要：13 分鐘   寫在之前  我們都知道，對於同一個問題來說，可以有多種解決問題的演算法。儘管演算法不是唯一的，但是對於問題本身來說相對好的演算法還是存在的，這裡可能有人會問區分好壞的標準是什

資料結構（排序演算法和查詢演算法的時間複雜度和空間複雜度）

這是從大神給多的網站上找到的演算法的時間複雜度趨勢和各個常用結構的複雜度截圖。     演算法的時間複雜度，用來度量演算法的執行時間，記作: T(n) = O(f(n))。它表示隨著 輸入大小n 的增大，演算法執行需要的時間的增長速度可以用 f(n) 來描

常用排序演算法的時間複雜度和空間複雜度及特點

一、常用排序演算法的時間複雜度和空間複雜度表格 二、特點 1.歸併排序： （1）n大時好，歸併比較佔用記憶體，記憶體隨n的增大而增大，但卻是效率高且穩定的排序演算法。 （2）歸併排序每次遞迴都要用到一個輔助表，長度與待排序的表長度相同，雖然遞迴次數是O(log2n)，但每次