數據結構與算法-一個好的算法如何測評 一、算法： 二、數據結構 三、時間複雜度和空間複雜度

一、算法：

1、解釋

算法是解決問題的方法，如何更好地更有效的解決問題，就需要設計一個好的算法，好的算法有以下要求。

2、算法特性

• 有窮性：算法必須在執行有限的次數後結束
• 確定性：算法的每一步必須有確定的含義
• 可行性：算法的每一步必須可執行，每一步都能通過執行有限次數完成
• 輸入輸出：算法要有輸入有輸出

3、算法的評價標準

• 正確性：算法要能正確的解決問題並輸出正確結果
• 可讀性：設計的算法要讓人能看明白
• 健壯性：算法要能對不合理的數據輸入有反應能力和處理能力
• 高效性：算法需要高效的處理問題，快速得到結果

二、數據結構

算法要存儲到內存中執行，這就要有數據結構，以下是幾種數據結構

數據結構是計算機存儲、組織數據的方式。

1、邏輯結構

• 集合結構：數據元素的集合，元素與元素之間沒有任何關係

• 線性結構：一對一

• 樹形結構：一對多

• 圖形結構：多對多

2、物理結構

• 順序存儲結構：按順序存儲，存儲地址是連續的
• 鏈式存儲結構：有方向性的存儲，存儲地址不連續，需要同時保存元素的數據和地址，通過地址找到關聯的數據

三、時間複雜度和空間複雜度

時間複雜度和空間複雜度是衡量一個算法好壞的重要指標

時間複雜度

時間複雜度計算的是算法執行最差情況下的執行次數，非常數的取最高階，存在最高階的則省去最高階前的係數

• 常數階，>1的常數都記作1： O(1)

//1+1+1 = 3 O(1)
void testSum1(int n){
    int sum = 0;                //執行1次
    sum = (1+n)*n/2;            //執行1次
    printf("testSum1:%d\n",sum);//執行1次
}

//1+1+1+1+1+1+1 = 7 O(1)
void testSum2(int n){
    int sum = 0;                //執行1次
    sum = (1+n)*n/2;            //執行1次
    sum = (1+n)*n/2;            //執行1次
    sum = (1+n)*n/2;            //執行1次
    sum = (1+n)*n/2;            //執行1次
    sum = (1+n)*n/2;            //執行1次
    printf("testSum2:%d\n",sum);//執行1次
    
}
//x=x+1; 執行1次
void add(int x){
    x = x+1;
}

• 線性階，取最高階並省去最高階前的係數： O(n)

//x=x+1; 執行n次 O(n)
void add2(int x,int n){
    for (int i = 0; i < n; i++) {
        x = x+1;
    }
}

//1+(n+1)+n+1 = 3+2n -> O(n)
void testSum3(int n){
    int i,sum = 0;               //執行1次
    for (i = 1; i <= n; i++) {   //執行n+1次
        sum += i;                //執行n次
    }
    printf("testSum3:%d\n",sum);  //執行1次
}

• 對數階 O(log n)

/*執行log 2 n 次 -> O(logn)*/
void test(int n){
   for(int i=1; i<n; i*=2){  //執行log 2 n 次
       printf("%d\n",i);
}

/*2的x次方等於n x = log 2 n  -> O(logn)*/
void testA(int n){
    int count = 1;         //執行1次
    //n = 10
    while (count < n) {    //執行log 2 n 次
        count = count * 2;
    }
    
}

• 平方階 O(n^2)

//x=x+1; 執行n*n次 ->O(n^2)
void add3(int x,int n){
    for (int i = 0; i< n; i++) {
        for (int j = 0; j < n ; j++) {
            x=x+1;
        }
    }
}

//n+(n-1)+(n-2)+...+1 = n(n-1)/2 = n^2/2 + n/2 = O(n^2)
//sn = n(a1+an)/2
void testSum4(int n){
    int sum = 0;
    for(int i = 0; i < n;i++)
        for (int j = i; j < n; j++) {
            sum += j;
        }
    printf("textSum4:%d",sum);
    
}

//1+(n+1)+n(n+1)+n^2+n^2 = 2+3n^2+2n -> O(n^2)
void testSum5(int n){
    int i,j,x=0,sum = 0;           //執行1次
    for (i = 1; i <= n; i++) {     //執行n+1次
        for (j = 1; j <= n; j++) { //執行n(n+1)
            x++;                   //執行n*n次
            sum = sum + x;         //執行n*n次
        }
    }
    printf("testSum5:%d\n",sum);
}

• 立方階 O(n^3)

//1+n+n*n+n*n*n+n*n*n = 1+n+n^2+2*n^3 -> O(n^3)
void testB(int n){
    int sum = 1;                         //執行1次
    for (int i = 0; i < n; i++) {        //執行n次
        for (int j = 0 ; j < n; j++) {   //執行n*n次
            for (int k = 0; k < n; k++) {//執行n*n*n次
                sum = sum * 2;          //執行n*n*n次
            }
        }
    }
}

• n(log n)階 O(n(log n))

• 指數階 O(2^n)

時間複雜度的比較

O(1) < O(log n) < O(n) < O(n(log n)) < O(n^2) < O(n^3) < O(2^n)

空間複雜度

空間複雜度計算的是執行算法的輔助空間，比如藉助一個臨時變量交換兩個字符的位置，這個臨時變量所佔空間就是算法的空間複雜度

  //兩種算法的空間複雜度比較
    int n = 5;
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    
    //算法實現(1)，只需要一個臨時變量
    int temp;
    for(int i = 0; i < n/2 ; i++){
        temp = a[i];
        a[i] = a[n-i-1];
        a[n-i-1] = temp;
    }

    for(int i = 0;i < 10;i++)
    {
        printf("%d\n",a[i]);

    }
    
    //算法實現(2)，數組作臨時變量佔用更多內存，增加了空間複雜度
    int b[10] = {0};
    for(int i = 0; i < n;i++){
        b[i] = a[n-i-1];
    }
    for(int i = 0; i < n; i++){
        a[i] = b[i];
    }
    for(int i = 0;i < 10;i++)
    {
        printf("%d\n",a[i]);
        
    }