数据结构上机——数组、矩阵转置

#include<iostream>
#include<stdarg.h>
#include<cstdio>
#include<cstdlib> 
using namespace std;

#define MAX_ARRAY_DIM 8
typedef int ElemType;
typedef struct _ARRAY_
{
    ElemType *pBase;//数组元素基址
    int dim;//维数
    int *pBounds;//维边界
    int *pContants;//数组映像函数常量
}Array,*pArray;

bool InitArray(pArray pArrayTemp,int iDim,...)
{
    if(iDim<1 || iDim>MAX_ARRAY_DIM)
    {
        return false;
    }
    pArrayTemp->dim = iDim;
    int i = 0;

    pArrayTemp->pBounds = (int*)malloc(sizeof(int)*iDim);//为维边界申请内存
    if(pArrayTemp->pBounds == NULL)
    {
        return false;
    }

    va_list temp = {0};
    va_start(temp,iDim);
    int elemTotal = 1;
    for(i = 0; i < iDim; i++)
    {
        pArrayTemp->pBounds[i] = va_arg(temp,int);//给维边界赋值
        if(pArrayTemp->pBounds[i] < 0)
        {
            free(pArrayTemp->pBounds);
            return false;
        }
        elemTotal *= pArrayTemp->pBounds[i];//获取总的元素个数，即每一维的长度相乘
    }
    va_end(temp);
    pArrayTemp->pBase = (ElemType *)malloc(sizeof(ElemType)*elemTotal);//为每一个元素申请内存
    if(pArrayTemp->pBase == NULL)
    {
        free(pArrayTemp->pBounds);
        return false;
    }

    pArrayTemp->pContants = (int *)malloc(sizeof(int) * iDim);//为映射函数常量值申请内存
    if(pArrayTemp->pContants == NULL)
    {
        free(pArrayTemp->pBounds);
        free(pArrayTemp->pBase);
        return false;
    }
    pArrayTemp->pContants[iDim-1] = 1;
    for(i=iDim-2; i>=0; i--)
    {
        pArrayTemp->pContants[i] = pArrayTemp->pContants[i+1]*pArrayTemp->pBounds[i+1];//给映射函数常量赋值
    }
    return true;
}

bool DestroyArray(pArray pArrayTemp)
{
    if(pArrayTemp->pBase != NULL)
    {
        free(pArrayTemp->pBase);
        pArrayTemp->pBase = NULL;
    }
    if(pArrayTemp->pBounds != NULL)
    {
        free(pArrayTemp->pBounds);
        pArrayTemp->pBounds = NULL;
    }
    if(pArrayTemp->pContants != NULL)
    {
        free(pArrayTemp->pContants);
        pArrayTemp->pContants = NULL;
    }
    return true;
}

void TravelArray(pArray pArrayTemp)
{
    int i;
    cout<<"dim:"<<pArrayTemp->dim<<endl;
    cout<<"bounds:";
    for(i = 0; i < pArrayTemp->dim; i++)
    {
        cout<<pArrayTemp->pBounds[i]<<" ";
    }
    cout<<endl;
    cout<<"pConstants:";
    for(i = 0; i<pArrayTemp->dim; i++)
    {
        cout<<pArrayTemp->pContants[i]<<" ";
    }
    cout<<endl;
    cout<<"data:";
    int count = 1;
    for(i = 0; i < pArrayTemp->dim; i++)
    {
        count *= pArrayTemp->pBounds[i];
    }
    for(i = 0; i < count; i++)
    {
        cout<<pArrayTemp->pBase[i]<<" ";
    }
    cout<<endl;
}
bool Locate(pArray pArrayTemp,va_list temp,int *offset)
{
    int iTemp = 0;
    int i = 0;
    *offset = 0;
    for(i = 0; i < pArrayTemp->dim; i++)
    {
        iTemp = va_arg(temp,int);
        *offset += iTemp*(pArrayTemp->pContants[i]);
    }
    return true;
}
bool Assign(pArray pArrayTemp,ElemType e,...)
{
    va_list temp = {0};
    int offset = 0;
    va_start(temp,e);
    bool result = Locate(pArrayTemp,temp,&offset);
    *(pArrayTemp->pBase + offset) = e;
    va_end(temp);
    return result;
}

bool Value(pArray pArrayTemp,ElemType *e,...)
{
    va_list temp;
    va_start(temp,e);
    bool result = false;
    int offset;
    result = Locate(pArrayTemp,temp,&offset);
    *e = pArrayTemp->pBase[offset];
    va_end(temp);
    return result;
}
int main()
{
    Array ArrayTemp = {0};
    InitArray(&ArrayTemp,3,3,2,2);
    int i = 0,j = 0,k = 0;
    for(i = 0; i<ArrayTemp.pBounds[0];i++)
    {
        for(j = 0; j < ArrayTemp.pBounds[1];j++)
        {
            for(k = 0; k <ArrayTemp.pBounds[2];k++)
            {
                Assign(&ArrayTemp,i*100+j*10+k,i,j,k);
            }
        }
    }
    ElemType e;
    Value(&ArrayTemp,&e,1,1,1);
    TravelArray(&ArrayTemp);
    cout<<"e = "<<e<<endl;
    DestroyArray(&ArrayTemp);
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<string>
using namespace std; 

#define MAXSIZE 12500
typedef struct{
    int i,j;
    int e;
}Triple;
typedef struct{
    Triple data[MAXSIZE+1];
    int mu,nu,tu;
}TSMatrix;

TSMatrix T;
TSMatrix M;

int TransposeSMatrix(TSMatrix M, TSMatrix &T){
    T.mu=M.nu; T.nu=M.mu; T.tu=M.tu;
    //转置矩阵的列数,行数和非零元素个数
    if (T.tu){
        int q=1; //矩阵T的指针
        for(int col=1;col<=M.nu;++col)
            for(int p=1;p<=M.tu;++p)//矩阵M的指针
                if(M.data[p].j==col){
                    T.data[q].i=M.data[p].j;
                    T.data[q].j=M.data[p].i;
                    T.data[q].e=M.data[p].e;
                    ++q;
                }
    }
    return 1;
}//TransposeSMatrix

int main(){
    int i;
    cout<<"请输入三元组行数、列数、非零元个数"<<endl; 
    cin>>M.mu>>M.nu>>M.tu;
    cout<<"请输入三元组"<<endl; 

    for(i=1;i<=M.tu;i++){
        cin>>M.data[i].i>>M.data[i].j>>M.data[i].e;
    }
    TransposeSMatrix(M,T);
    for(i=1;i<=T.tu;i++){
        cout<<T.data[i].i<<" "<<T.data[i].j<<" "<<T.data[i].e<<endl;

    }
return 0;
}