n維數組取數問題


編寫一個程序:void f(int dim, int *data, int *s, int *p, int *st, int *out)

輸入為 : int dim     //代表整數型數組的維數,比如dim=2,就是2維數組
         int *data   //代表對應維數已經存在的數組 比如int data[10][20];將要從中取數據
         int *length //代表對data對應維的長度。比如 dim=2 的2維數組 int data[10][20]; 則length[0]=10,length[1]=20

         int *p      //代表data數組中的一個坐標點 比如 dim=2時  p[0]=1,p[0]=2,
                     //data[ p[0] ][ p[1] ]=data[1][2] 是data數組中的一個數

         int *st     //代表要取出的數組大小,即取出st[0]*st[1]*...*st[dim-1]個數
                     //比如dim=2,p[0]=1,p[0]=2 時,  st[0]=2, st[1]=3,
                     //代表data數組中取出從 data[1][2] 開始,長高分別為2和3的數據塊,即:
                       data[1][2]  data[1][3]
                       data[2][2]  data[2][3]
                       data[3][2]  data[3][3]


輸出為 :int *out     //把取出的數組放在out數組中

輸入限制:st[0]<=2,st[1]<=2,...st[dim-1]<=2




16 个解决方案

#1




又來?

#2


引用 1 樓 max_min_ 的回復:


又來?


這題的時間復雜性太讓人頭疼了

#3


#4


抱歉, 修改上面的打字錯誤:


編寫一個程序:void f(int dim, int *data, int *length, int *p, int *st, int *out)

輸入為 : int dim     //代表整數型數組的維數,比如dim=2,就是2維數組
         int *data   //代表對應維數已經存在的數組 比如int data[10][20];將要從中取數據
         int *length //代表對data對應維的長度。比如 dim=2 的2維數組 int data[10][20]; 則length[0]=10,length[1]=20

         int *p      //代表data數組中的一個坐標點 比如 dim=2時  p[0]=1,p[1]=2,
                     //data[ p[0] ][ p[1] ]=data[1][2] 是data數組中的一個數

         int *st     //代表要取出的數組大小,即取出st[0]*st[1]*...*st[dim-1]個數
                     //比如dim=2,p[0]=1,p[0]=2 時,  st[0]=2, st[1]=3,
                     //代表data數組中取出從 data[1][2] 開始,長高分別為2和3的數據塊,即:
                       data[1][2]  data[1][3]
                       data[2][2]  data[2][3]
                       data[3][2]  data[3][3]


輸出為 :int *out     //把取出的數組放在out數組中

輸入限制:st[0]<=2,st[1]<=2,...st[dim-1]<=2



#5


為了簡單些,這里不需要考慮數組的邊界條件。


比如一維數組 int data[1000];


       不需要考慮會出現下面情況
             int length[1]={0};
             int p[1]={999}; 
             int st[1]={2};

      因為這種情況下是要求從數組最后一位開始,向后取兩個,顯然超出了數組范圍。


所以為了簡單些,在這道題中假設輸入不會有超出數組范圍的可能。不需要考慮邊界條件。






#6


引用 3 樓 wtx_sonery 的回復:


騷年,100分等你

#7


電腦內存或文件內容只是一個一維二進制字節數組及其對應的二進制地址;
人腦才將電腦內存或文件內容中的這個一維二進制字節數組及其對應的二進制地址的某些部分看成是整數、有符號數/無符號數、浮點數、復數、英文字母、阿拉伯數字、中文/韓文/法文……字符/字符串、匯編指令、函數、函數參數、堆、棧、數組、指針、數組指針、指針數組、數組的數組、指針的指針、二維數組、字符點陣、字符筆畫的坐標、黑白二值圖片、灰度圖片、彩色圖片、錄音、視頻、指紋信息、身份證信息……

#8


引用 7 樓 zhao4zhong1 的回復:
電腦內存或文件內容只是一個一維二進制字節數組及其對應的二進制地址;
人腦才將電腦內存或文件內容中的這個一維二進制字節數組及其對應的二進制地址的某些部分看成是整數、有符號數/無符號數、浮點數、復數、英文字母、阿拉伯數字、中文/韓文/法文……字符/字符串、匯編指令、函數、函數參數、堆、棧、數組、指針、數組指針、指針數組、數組的數組、指針的指針、二維數組、字符點陣、字符筆畫的坐標、黑白二值圖片、灰度圖片、彩色圖片、錄音、視頻、指紋信息、身份證信息……


#9


暈,沒人會?

#10


//在堆中開辟一個4×5的二維int數組
#include <stdio.h>
#include <malloc.h>
int **p;
int i,j;
void main() {
    p=(int **)malloc(4*sizeof(int *));
    if (NULL==p) return;
    for (i=0;i<4;i++) {
        p[i]=(int *)malloc(5*sizeof(int));
        if (NULL==p[i]) return;
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            p[i][j]=i*5+j;
        }
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            printf(" %2d",p[i][j]);
        }
        printf("\n");
    }
    for (i=0;i<4;i++) {
        free(p[i]);
    }
    free(p);
}
//  0  1  2  3  4
//  5  6  7  8  9
// 10 11 12 13 14
// 15 16 17 18 19

//在堆中開辟一個3×4×5的3維int數組
#include <stdio.h>
#include <malloc.h>
int ***p;
int i,j,k;
void main() {
    p=(int ***)malloc(3*sizeof(int **));
    if (NULL==p) return;
    for (i=0;i<3;i++) {
        p[i]=(int **)malloc(4*sizeof(int *));
        if (NULL==p[i]) return;
        for (j=0;j<4;j++) {
            p[i][j]=(int *)malloc(5*sizeof(int));
            if (NULL==p[i][j]) return;
        }
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            for (k=0;k<5;k++) {
                p[i][j][k]=i*20+j*5+k;
            }
        }
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            for (k=0;k<5;k++) {
                printf(" %2d",p[i][j][k]);
            }
            printf("\n");
        }
        printf("---------------\n");
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            free(p[i][j]);
        }
        free(p[i]);
    }
    free(p);
}
//  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 59
//---------------

//在堆中開辟一個2×3×4×5的4維int數組
#include <stdio.h>
#include <malloc.h>
int ****p;
int h,i,j,k;
void main() {
    p=(int ****)malloc(2*sizeof(int ***));
    if (NULL==p) return;
    for (h=0;h<2;h++) {
        p[h]=(int ***)malloc(3*sizeof(int **));
        if (NULL==p[h]) return;
        for (i=0;i<3;i++) {
            p[h][i]=(int **)malloc(4*sizeof(int *));
            if (NULL==p[h][i]) return;
            for (j=0;j<4;j++) {
                p[h][i][j]=(int *)malloc(5*sizeof(int));
                if (NULL==p[h][i][j]) return;
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    p[h][i][j][k]=h*60+i*20+j*5+k;
                }
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    printf(" %3d",p[h][i][j][k]);
                }
                printf("\n");
            }
            printf("--------------------\n");
        }
        printf("=======================\n");
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                free(p[h][i][j]);
            }
            free(p[h][i]);
        }
        free(p[h]);
    }
    free(p);
}
//   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  59
//--------------------
//=======================
//  60  61  62  63  64
//  65  66  67  68  69
//  70  71  72  73  74
//  75  76  77  78  79
//--------------------
//  80  81  82  83  84
//  85  86  87  88  89
//  90  91  92  93  94
//  95  96  97  98  99
//--------------------
// 100 101 102 103 104
// 105 106 107 108 109
// 110 111 112 113 114
// 115 116 117 118 119
//--------------------
//=======================
//

#11


引用 10 樓 zhao4zhong1 的回復:
//在堆中開辟一個4×5的二維int數組
#include <stdio.h>
#include <malloc.h>
int **p;
int i,j;
void main() {
    p=(int **)malloc(4*sizeof(int *));
    if (NULL==p) return;
    for (i=0;i<4;i++) {
        p[i]=(int *)malloc(5*sizeof(int));
        if (NULL==p[i]) return;
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            p[i][j]=i*5+j;
        }
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            printf(" %2d",p[i][j]);
        }
        printf("\n");
    }
    for (i=0;i<4;i++) {
        free(p[i]);
    }
    free(p);
}
//  0  1  2  3  4
//  5  6  7  8  9
// 10 11 12 13 14
// 15 16 17 18 19

//在堆中開辟一個3×4×5的3維int數組
#include <stdio.h>
#include <malloc.h>
int ***p;
int i,j,k;
void main() {
    p=(int ***)malloc(3*sizeof(int **));
    if (NULL==p) return;
    for (i=0;i<3;i++) {
        p[i]=(int **)malloc(4*sizeof(int *));
        if (NULL==p[i]) return;
        for (j=0;j<4;j++) {
            p[i][j]=(int *)malloc(5*sizeof(int));
            if (NULL==p[i][j]) return;
        }
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            for (k=0;k<5;k++) {
                p[i][j][k]=i*20+j*5+k;
            }
        }
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            for (k=0;k<5;k++) {
                printf(" %2d",p[i][j][k]);
            }
            printf("\n");
        }
        printf("---------------\n");
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            free(p[i][j]);
        }
        free(p[i]);
    }
    free(p);
}
//  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 59
//---------------

//在堆中開辟一個2×3×4×5的4維int數組
#include <stdio.h>
#include <malloc.h>
int ****p;
int h,i,j,k;
void main() {
    p=(int ****)malloc(2*sizeof(int ***));
    if (NULL==p) return;
    for (h=0;h<2;h++) {
        p[h]=(int ***)malloc(3*sizeof(int **));
        if (NULL==p[h]) return;
        for (i=0;i<3;i++) {
            p[h][i]=(int **)malloc(4*sizeof(int *));
            if (NULL==p[h][i]) return;
            for (j=0;j<4;j++) {
                p[h][i][j]=(int *)malloc(5*sizeof(int));
                if (NULL==p[h][i][j]) return;
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    p[h][i][j][k]=h*60+i*20+j*5+k;
                }
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    printf(" %3d",p[h][i][j][k]);
                }
                printf("\n");
            }
            printf("--------------------\n");
        }
        printf("=======================\n");
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                free(p[h][i][j]);
            }
            free(p[h][i]);
        }
        free(p[h]);
    }
    free(p);
}
//   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  59
//--------------------
//=======================
//  60  61  62  63  64
//  65  66  67  68  69
//  70  71  72  73  74
//  75  76  77  78  79
//--------------------
//  80  81  82  83  84
//  85  86  87  88  89
//  90  91  92  93  94
//  95  96  97  98  99
//--------------------
// 100 101 102 103 104
// 105 106 107 108 109
// 110 111 112 113 114
// 115 116 117 118 119
//--------------------
//=======================
//



你這是固定的,不符合題意

#12


#13


引用 11 樓 attop 的回復:
Quote: 引用 10 樓 zhao4zhong1 的回復:

//在堆中開辟一個4×5的二維int數組
#include <stdio.h>
#include <malloc.h>
int **p;
int i,j;
void main() {
    p=(int **)malloc(4*sizeof(int *));
    if (NULL==p) return;
    for (i=0;i<4;i++) {
        p[i]=(int *)malloc(5*sizeof(int));
        if (NULL==p[i]) return;
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            p[i][j]=i*5+j;
        }
    }
    for (i=0;i<4;i++) {
        for (j=0;j<5;j++) {
            printf(" %2d",p[i][j]);
        }
        printf("\n");
    }
    for (i=0;i<4;i++) {
        free(p[i]);
    }
    free(p);
}
//  0  1  2  3  4
//  5  6  7  8  9
// 10 11 12 13 14
// 15 16 17 18 19

//在堆中開辟一個3×4×5的3維int數組
#include <stdio.h>
#include <malloc.h>
int ***p;
int i,j,k;
void main() {
    p=(int ***)malloc(3*sizeof(int **));
    if (NULL==p) return;
    for (i=0;i<3;i++) {
        p[i]=(int **)malloc(4*sizeof(int *));
        if (NULL==p[i]) return;
        for (j=0;j<4;j++) {
            p[i][j]=(int *)malloc(5*sizeof(int));
            if (NULL==p[i][j]) return;
        }
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            for (k=0;k<5;k++) {
                p[i][j][k]=i*20+j*5+k;
            }
        }
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            for (k=0;k<5;k++) {
                printf(" %2d",p[i][j][k]);
            }
            printf("\n");
        }
        printf("---------------\n");
    }
    for (i=0;i<3;i++) {
        for (j=0;j<4;j++) {
            free(p[i][j]);
        }
        free(p[i]);
    }
    free(p);
}
//  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 59
//---------------

//在堆中開辟一個2×3×4×5的4維int數組
#include <stdio.h>
#include <malloc.h>
int ****p;
int h,i,j,k;
void main() {
    p=(int ****)malloc(2*sizeof(int ***));
    if (NULL==p) return;
    for (h=0;h<2;h++) {
        p[h]=(int ***)malloc(3*sizeof(int **));
        if (NULL==p[h]) return;
        for (i=0;i<3;i++) {
            p[h][i]=(int **)malloc(4*sizeof(int *));
            if (NULL==p[h][i]) return;
            for (j=0;j<4;j++) {
                p[h][i][j]=(int *)malloc(5*sizeof(int));
                if (NULL==p[h][i][j]) return;
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    p[h][i][j][k]=h*60+i*20+j*5+k;
                }
            }
        }
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                for (k=0;k<5;k++) {
                    printf(" %3d",p[h][i][j][k]);
                }
                printf("\n");
            }
            printf("--------------------\n");
        }
        printf("=======================\n");
    }
    for (h=0;h<2;h++) {
        for (i=0;i<3;i++) {
            for (j=0;j<4;j++) {
                free(p[h][i][j]);
            }
            free(p[h][i]);
        }
        free(p[h]);
    }
    free(p);
}
//   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  59
//--------------------
//=======================
//  60  61  62  63  64
//  65  66  67  68  69
//  70  71  72  73  74
//  75  76  77  78  79
//--------------------
//  80  81  82  83  84
//  85  86  87  88  89
//  90  91  92  93  94
//  95  96  97  98  99
//--------------------
// 100 101 102 103 104
// 105 106 107 108 109
// 110 111 112 113 114
// 115 116 117 118 119
//--------------------
//=======================
//



你這是固定的,不符合題意

就不會參考這個寫成遞歸版本嗎?

#14


引用 13 樓 zhao4zhong1 的回復:
Quote: 引用 11 樓 attop 的回復:

Quote: 引用 10 樓 zhao4zhong1 的回復:

//在堆中開辟一個4×5的二維int數組

//=======================
//



你這是固定的,不符合題意

就不會參考這個寫成遞歸版本嗎?



遞歸肯定不可行。比如100維數組,你遞歸100次試試,C/C++肯定產生溢出之類的錯誤

#15


引用 14 樓 attop 的回復:
Quote: 引用 13 樓 zhao4zhong1 的回復:

Quote: 引用 11 樓 attop 的回復:

Quote: 引用 10 樓 zhao4zhong1 的回復:

//在堆中開辟一個4×5的二維int數組

//=======================
//



你這是固定的,不符合題意

就不會參考這個寫成遞歸版本嗎?



遞歸肯定不可行。比如100維數組,你遞歸100次試試,C/C++肯定產生溢出之類的錯誤



別說100次,20次遞歸嵌套,C/C++都不行

#16


引用 14 樓 attop 的回復:
Quote: 引用 13 樓 zhao4zhong1 的回復:

Quote: 引用 11 樓 attop 的回復:

Quote: 引用 10 樓 zhao4zhong1 的回復:

//在堆中開辟一個4×5的二維int數組

//=======================
//



你這是固定的,不符合題意

就不會參考這個寫成遞歸版本嗎?



遞歸肯定不可行。比如100維數組,你遞歸100次試試,C/C++肯定產生溢出之類的錯誤


那你不會自己實現堆棧用循環模擬遞歸嗎?
http://www.codeproject.com/Articles/418776/How-to-replace-recursive-functions-using-stack-and

注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com