从0开始的代码生活第11天（二维数组与压缩数组）（未改）

我有一个梦想，有一天，西游记能出ACT，打神弑佛，那绝对比《战神》带感。
我有一个梦想，有一天，上海滩能出沙盒游戏，而不是玩《GTA》感受美国梦，亦或是玩《热血无赖》体验国外公司强行塞给我们的「中国文化」。
我有一个梦想，有一天，不少3A大作不需汉化，因为是我们自己的游戏，配音是中国的，文化也是中国的。
我有一个梦想，将来的某一天，国产游戏能像中国的其他产业一样，以一个领跑者的姿态，面对全世界，面对全宇宙，器宇轩昂，扬眉吐气。
这会是由我们一起去完成的梦想。等着我们的好消息！

---逝者毛星云的梦想，与海子一样，他的梦想在现实引

力太大的中国没有容身之地，他的身躯与大地碰撞，

正如他的梦想折断翅膀

文章目录

前言
一、二维数组代码解析
二.压缩数组代码解析
总结

前言

数组是基础，在之前也有学习，可以说，数组是程序的基础，无论是做网页，还是做一个基础项目，都不能离开数组，今天，我们将对数组进行解析并结合例子。

一、解析，废话少说，先上代码

#include 
#include 

#define ROWS 4
#define COLUMNS 5


typedef struct twodArray{
    int rows;
    int columns;
    int** elements;
} twodArray, *twodArrayPtr;

typedef struct twodStaticarray{
    int row;
    int column;
    int elements[ROWS][COLUMNS];
} twodStaticarray, *TwoDStaticArrayPtr;

twodArrayPtr initTwoDArray(int paraRows, int paraColumns){
    int i;
    twodArrayPtr resultPtr = (twodArrayPtr)malloc(sizeof(struct twodArray));
    resultPtr->rows = paraRows;
    resultPtr->columns = paraColumns;
    resultPtr->elements = (int**)malloc( (paraRows *sizeof(int*)));
    for(i = 0; i < paraRows; i++){
        resultPtr -> elements[i] = (int*)malloc(paraColumns *sizeof(int));
    }
    return resultPtr;
}

void randomizeTwoDArray(twodArrayPtr paraPtr, int paraLowerBound, int paraUpperBound){
    int i, j;
    for (i = 0; i < paraPtr->rows; i ++){
        for (j = 0; j < paraPtr->columns; j ++) {
            paraPtr->elements[i][j] = rand() % (paraUpperBound - paraLowerBound) ;
        }//Of for j
    }//Of for i
}// Of randomizeTwoDArray


void printtwodarray(twodArrayPtr paraptr){
    int i,j;
    for(i = 0;i < paraptr->rows; i++){
        for(j = 0; j < paraptr->columns;j++){
            printf("%d, ",paraptr->elements[i][j]);
        }
        printf("rn");
    }
}

twodArrayPtr matrixMultiply(twodArrayPtr paraptr1,twodArrayPtr paraptr2){
    int i,j,k,sum;
    if(paraptr1->columns != paraptr2->rows){
        printf("matrices cannot multipled.rn");
        return  NULL;
    }

    twodArrayPtr resultptr = initTwoDArray(paraptr1->rows,paraptr2->columns);

    for(i = 0;i < paraptr1->rows;i++){
        for(j = 0; j columns;j++){
            sum = 0;
            for(k = 0; k < paraptr1->columns;k++){
                sum += paraptr1->elements[i][k] * paraptr2->elements[k][j];
            }
            resultptr->elements[i][j] = sum;
            printf("sum = %d",sum);
        }
    }
    return resultptr;
}

void twodArrayTest(){
    twodArrayPtr tempptr1,tempptr2,tempptr3;
    tempptr1 = initTwoDArray(3,2);
    randomizeTwoDArray(tempptr1,1,5);
    printf("the first matrix:rn");
    printtwodarray(tempptr1);

    tempptr2 = initTwoDArray(2,4);
    randomizeTwoDArray(tempptr2,4,9);
    printf("the second matrix:rn");
    printtwodarray(tempptr2);

    tempptr3 = matrixMultiply(tempptr1,tempptr2);
    printf("the result:rn");
    printtwodarray(tempptr3);
}

TwoDStaticArrayPtr initTwoDStaticArray(){
    int i, j;
    TwoDStaticArrayPtr resultPtr = (TwoDStaticArrayPtr)malloc(sizeof(struct twodStaticarray));
    resultPtr->row = ROWS;
    resultPtr->column = COLUMNS;
    for (i = 0; i < ROWS; i ++){
        for (j = 0; j < COLUMNS; j ++) {
            resultPtr->elements[i][j] = i * 10 + j;
            //Print their addresses.
            printf("(%d, %d): %d; ", resultPtr->elements[i][j], &(resultPtr->elements[i][j]));
        }//Of for j
    }//Of for i

    return resultPtr;
}// Of initTwoDStaticArray


int main(){
    twodArrayTest();
    TwoDStaticArrayPtr tempPtr = initTwoDStaticArray();

    return 1;
}// Of main

开始malloc与struct不解释

void randomizeTwoDArray(twodArrayPtr paraPtr, int paraLowerBound, int paraUpperBound){
    int i, j;
    for (i = 0; i < paraPtr->rows; i ++){
        for (j = 0; j < paraPtr->columns; j ++) {
            paraPtr->elements[i][j] = rand() % (paraUpperBound - paraLowerBound) ;
        }//Of for j
    }//Of for i
}// Of randomizeTwoDArray

注意在开始输入时，因为没有srand给予种子，开始rand其实已被固定

print函数不解释

twodArrayPtr matrixMultiply(twodArrayPtr paraptr1,twodArrayPtr paraptr2){
    int i,j,k,sum;
    if(paraptr1->columns != paraptr2->rows){
        printf("matrices cannot multipled.rn");
        return  NULL;
    }

    twodArrayPtr resultptr = initTwoDArray(paraptr1->rows,paraptr2->columns);

    for(i = 0;i < paraptr1->rows;i++){
        for(j = 0; j columns;j++){
            sum = 0;
            for(k = 0; k < paraptr1->columns;k++){
                sum += paraptr1->elements[i][k] * paraptr2->elements[k][j];
            }
            resultptr->elements[i][j] = sum;
            printf("sum = %d",sum);
        }
    }
    return resultptr;
}

我们将图与指针方式解析该过程(在columns等于rows时）

在resulrptr时paraptr1下一列，paraptr2下一行（矩阵算法）

TwoDStaticArrayPtr initTwoDStaticArray(){
    int i, j;
    TwoDStaticArrayPtr resultPtr = (TwoDStaticArrayPtr)malloc(sizeof(struct twodStaticarray));
    resultPtr->row = ROWS;
    resultPtr->column = COLUMNS;
    for (i = 0; i < ROWS; i ++){
        for (j = 0; j < COLUMNS; j ++) {
            resultPtr->elements[i][j] = i * 10 + j;
            //Print their addresses.
            printf("(%d, %d): %dn ", i,j, &(resultPtr->elements[i][j]));
        }//Of for j
    }//Of for i

开始打出时，注意地址相差4（int储存）

二.压缩数组代码解析

代码

#include 
#include

typedef  int elem;

typedef struct triple{
    int i;
    int j;
    elem e;
}triple,*tripleptr;

typedef struct compressedmatrix{
    int rows,columns,numelements;
    triple *elements;
}compressedmatrix,*compressedmatrixptr;

compressedmatrixptr initcompressedmatrix(int pararows,int paracolumns,int paraelements,int **paradata){
    int i;
    compressedmatrixptr resultptr = (compressedmatrixptr)malloc(sizeof(struct compressedmatrix));
    resultptr->elements = (tripleptr)malloc(paraelements * sizeof(struct triple));
    resultptr->rows = pararows;
    resultptr->columns = paracolumns;
    resultptr->numelements = paraelements;

    for(i = 0;i < paraelements; i++){
       resultptr->elements[i].i = paradata[i][0];
       resultptr->elements[i].j = paradata[i][1];
       resultptr->elements[i].e = paradata[i][2];
    }
 return resultptr;
}

void printcompressedmatrix(compressedmatrixptr paraptr){
    int i;
    for(i = 0; i < paraptr->numelements;i++){
        printf("(%d %d): %drn",paraptr->elements[i].i ,paraptr->elements[i].j,paraptr->elements[i].e);
    }
}

compressedmatrixptr transposecompressmatrix(compressedmatrixptr paraptr) {
    int i, tempcolumn, tempposition;
    int *tempcolumncounts = (int *) malloc(paraptr->columns * sizeof(int));
    int *tempoffsets = (int *) malloc(paraptr->columns * sizeof(int));
    for (i = 0; i < paraptr->columns; i++) {
        tempcolumncounts[i] = 0;
    }


    compressedmatrixptr resultptr = (compressedmatrixptr) malloc(sizeof(struct compressedmatrix));
    resultptr->elements = (tripleptr) malloc(paraptr->numelements * sizeof(struct triple));
    resultptr->rows = paraptr->columns;
    resultptr->columns = paraptr->rows;
    resultptr->numelements = paraptr->numelements;

    for (i = 0; i < paraptr->numelements; i++) {
        tempcolumncounts[paraptr->elements[i].j]++;
    }

    tempoffsets[0] = 0;

    for (i = 1; i < paraptr->columns; i++) {
        tempoffsets[i] = tempoffsets[i - 1] + tempcolumncounts[i - 1];
        printf("tempoffsets[%d] = %drn", i, tempoffsets[i]);
    }

    for (i = 0; i < paraptr->numelements; i++) {
        tempcolumn = paraptr->elements[i].j;
        tempposition = tempoffsets[tempcolumn];
        resultptr->elements[tempposition].i = paraptr->elements[i].j;
        resultptr->elements[tempposition].j = paraptr->elements[i].i;
        resultptr->elements[tempposition].e = paraptr->elements[i].e;

        tempoffsets[tempcolumn]++;

    }

    return resultptr;
}

void compressedmatrixtest(){
    compressedmatrixptr tempptr1,tempptr2;
    int i, j,tempelements;

    tempelements = 4;
    int** tempmatrix1 = (int**)malloc(tempelements * sizeof(int*));
    for(i = 0; i < tempelements;i++){
        tempmatrix1[i] = (int*)malloc(3*sizeof(int));
    }

    int tempmatrix2[4][3] = {{0,0,2},{0,2,3},{2,0,5},{2,1,6}};
    for(i = 0; i < tempelements;i++){
        for(j = 0;j < 3; j++){
            tempmatrix1[i][j] = tempmatrix2[i][j];
        }
    }

    tempptr1 = initcompressedmatrix(2,3,4,tempmatrix1);

    printf("after initlization.rn");
    printcompressedmatrix(tempptr1);

    tempptr2 = transposecompressmatrix(tempptr1);
    printf("after transpose.rn");
    printcompressedmatrix(tempptr2);
}

int main(){
    compressedmatrixtest();
    return 0;
}

开始struct不解释

稀疏数列

概念引入：有大多0的数列，而该程序录入的只是压缩后的数列

如题中录入的{0, 0, 2}, {0, 2, 3}, {2, 0, 5}, {2, 1, 6}

实际为【0，0】位置2，【0，2】位置3，【2，0】位置5，【2，1】位置6

那实际数组为

（其他数组元素都为0）

我们主要对核心代码讲解

CompressedMatrixPtr transposeCompressedMatrix(CompressedMatrixPtr paraPtr){
    //Step 1. Allocate space.
    int i, tempColumn, tempPosition;
    int *tempColumnCounts = (int*)malloc(paraPtr->columns * sizeof(int));
    int *tempOffsets = (int*)malloc(paraPtr->columns * sizeof(int));
    for(i = 0; i < paraPtr->columns; i ++){
        tempColumnCounts[i] = 0;
    }//Of for i

    CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
    resultPtr->rows = paraPtr->columns;
    resultPtr->columns = paraPtr->rows;
    resultPtr->numElements = paraPtr->numElements;

    resultPtr->elements = (TriplePtr)malloc(paraPtr->numElements * sizeof(struct Triple));

    //Step 2. One scan to calculate offsets.
    for(i = 0; i < paraPtr->numElements; i ++) {
        tempColumnCounts[paraPtr->elements[i].j] ++;
    }//Of for i
    tempOffsets[0] = 0;
    for(i = 1; i < paraPtr->columns; i ++){
        tempOffsets[i] = tempOffsets[i - 1] + tempColumnCounts[i - 1];
        printf("tempOffsets[%d] = %d rn", i, tempOffsets[i]);
    }//Of for i

    //Step 3. Another scan to fill data.
    for(i = 0; i < paraPtr->numElements; i ++) {
        tempColumn = paraPtr->elements[i].j;
        tempPosition = tempOffsets[tempColumn];
        resultPtr->elements[tempPosition].i = paraPtr->elements[i].j;
        resultPtr->elements[tempPosition].j = paraPtr->elements[i].i;
        resultPtr->elements[tempPosition].e = paraPtr->elements[i].e;

        tempOffsets[tempColumn]++;
    }//Of for i

    return resultPtr;
}//Of transposeCompressedMatrix

第一步分配空间注意一下i和j的倒置

第二步计数分配

 //Step 2. One scan to calculate offsets.
    for(i = 0; i < paraPtr->numElements; i ++) {
        tempColumnCounts[paraPtr->elements[i].j] ++;
    }//Of for i
    tempOffsets[0] = 0;
    for(i = 1; i < paraPtr->columns; i ++){
        tempOffsets[i] = tempOffsets[i - 1] + tempColumnCounts[i - 1];
        printf("tempOffsets[%d] = %d rn", i, tempOffsets[i]);
    }//Of for i

通过指针实现计数，实际上是计数

 for(i = 0; i < paraPtr->numElements; i ++) {
        tempColumn = paraPtr->elements[i].j;
        tempPosition = tempOffsets[tempColumn];
        resultPtr->elements[tempPosition].i = paraPtr->elements[i].j;
        resultPtr->elements[tempPosition].j = paraPtr->elements[i].i;
        resultPtr->elements[tempPosition].e = paraPtr->elements[i].e;

        tempOffsets[tempColumn]++;
    }//Of for i

将i和j逆置打出

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

从0开始的代码生活第11天（二维数组与压缩数组）（未改）

C/C++/C#相关栏目本月热门文章