怎么编写一个适用于变长二维数组的行列的和的函数

void Trans(int matrix[][])

{

for(int i=0;i<3;i++)

for(int j=0;j<i;j++)

{

int t=matrix[i][j];

matrix[i][j]=matrix[j][i];

matrix[j][i]=t;

}

}

#include <stdlibh>

#include <malloch>

#include <memoryh>

#include <asserth>

#include "DynaSeqListh"

const int LIST_INIT_SIZE = 100; // 表初始分配的最大长度

const int LISTINCREMENT = 10; // 分配内存的增量

/------------------------------------------------------------

*** 作目的： 初始化顺序表

初始条件： 无

*** 作结果： 构造一个空的线性表

函数参数：

SqList L 待初始化的线性表

返回值：

bool *** 作是否成功

------------------------------------------------------------/

bool InitList(SqList L)

{

assert(L != NULL);

L->elem = (ElemType)malloc(sizeof(ElemType) LIST_INIT_SIZE);

if(L->elem == NULL) return false;

L->length = 0;

L->listsize = LIST_INIT_SIZE;

return true;

}

/------------------------------------------------------------

*** 作目的： 销毁顺序表

初始条件： 线性表L已存在

*** 作结果： 销毁线性表L

函数参数：

SqList L 待销毁的线性表

返回值：

无

------------------------------------------------------------/

void DestroyList(SqList L)

{

assert(L != NULL);

free(L->elem);

L->elem = NULL;

}

/------------------------------------------------------------

*** 作目的： 判断顺序表是否为空

初始条件： 线性表L已存在

*** 作结果： 若L为空表，则返回true，否则返回false

函数参数：

SqList L 待判断的线性表

返回值：

bool 是否为空

------------------------------------------------------------/

bool ListEmpty(SqList L)

{

assert(Lelem != NULL);

return(Llength == 0);

}

/------------------------------------------------------------

*** 作目的： 得到顺序表的长度

初始条件： 线性表L已存在

*** 作结果： 返回L中数据元素的个数

函数参数：

SqList L 线性表L

返回值：

int 数据元素的个数

------------------------------------------------------------/

int ListLength(SqList L)

{

assert(Lelem != NULL);

return Llength;

}

/------------------------------------------------------------

*** 作目的： 得到顺序表的第i个元素

初始条件： 线性表L已存在，1<=i<=ListLength(L)

*** 作结果： 用e返回L中第i个数据元素的值

函数参数：

SqList L 线性表L

int i 数据元素的位置

ElemType e 第i个数据元素的值

返回值：

bool *** 作是否成功

------------------------------------------------------------/

bool GetElem(SqList L, int i, ElemType e)

{

assert(Lelem != NULL);

if(i<1 || i>Llength) return false;

e = Lelem[i-1];

return true;

}

/------------------------------------------------------------

*** 作目的： 得到顺序表指定元素的位置

初始条件： 线性表L已存在

*** 作结果： 返回L中第一个与e满足关系compare()的数据元素的位序。

若这样的元素不存在则返回0。

函数参数：

SqList L 线性表L

ElemType e 数据元素e

int (fp)() 用于比较相等的函数指针

返回值：

int 与e满足关系compare()的数据元素的位序

------------------------------------------------------------/

int LocateElem(SqList L, ElemType e, int (fp)(ElemType, ElemType))

{

assert(Lelem != NULL);

int i = 0;

for(i=0; i<Llength && ((fp)(e, Lelem[i]) != 0); i++) ;

return (i+1)%(Llength+1);

}

/------------------------------------------------------------

*** 作目的： 得到顺序表指定元素的前驱

初始条件： 线性表L已存在

*** 作结果： 若cur_e是L的数据元素，且不是第一个，则用pre_e返回

它的前驱，否则 *** 作失败，pre_e无定义

函数参数：

SqList L 线性表L

ElemType cur_e 数据元素cur_e

ElemType pre_e 前驱数据元素

返回值：

bool *** 作是否成功

------------------------------------------------------------/

bool PriorElem(SqList L, ElemType cur_e, ElemType pre_e)

{

assert(Lelem != NULL);

int pos = LocateElem(L, cur_e, compare);

if(pos<2) return false;

pre_e = Lelem[pos-2];

return true;

}

/------------------------------------------------------------

*** 作目的： 得到顺序表指定元素的后继

初始条件： 线性表L已存在

*** 作结果： 若cur_e是L的数据元素，且不是最后一个，则用nxt_e返

回它的后继，否则 *** 作失败，nxt_e无定义

函数参数：

SqList L 线性表L

ElemType cur_e 数据元素cur_e

ElemType nxt_e 后继数据元素

返回值：

bool *** 作是否成功

------------------------------------------------------------/

bool NextElem(SqList L, ElemType cur_e, ElemType nxt_e)

{

assert(Lelem != NULL);

int pos = LocateElem(L, cur_e, compare);

if(pos>Llength-1) return false;

nxt_e = Lelem[pos];

return true;

}

/------------------------------------------------------------

*** 作目的： 遍历顺序表

初始条件： 线性表L已存在

*** 作结果： 依次对L的每个元素调用函数fp

函数参数：

SqList L 线性表L

void (fp)() 访问每个数据元素的函数指针

返回值：

无

------------------------------------------------------------/

void ListTraverse(SqList L, void (fp)(ElemType))

{

assert((Lelem != NULL) && (fp != NULL));

for(int i=0; i<Llength; i++) (fp)(Lelem[i]);

}

/------------------------------------------------------------

*** 作目的： 清空顺序表

初始条件： 线性表L已存在

*** 作结果： 将L置为空表

函数参数：

SqList L 线性表L

返回值：

无

------------------------------------------------------------/

void ClearList(SqList L)

{

if(L == NULL) return;

assert(L->elem != NULL);

L->length = 0;

}

/------------------------------------------------------------

*** 作目的： 在顺序表的指定位置插入结点，插入位置i表示在第i个

元素之前插入

初始条件： 线性表L已存在，1<=i<=ListLength(L) + 1

*** 作结果： 在L中第i个位置之前插入新的数据元素e，L的长度加1

函数参数：

SqList L 线性表L

int i 插入位置

ElemType e 待插入的数据元素

返回值：

bool *** 作是否成功

------------------------------------------------------------/

bool ListInsert(SqList L, int i, ElemType e)

{

if(L == NULL) return false;

assert(L->elem != NULL);

if(i<1 || i>L->length+1) return false;

if(L->length == L->listsize)

{

int newsize = L->listsize + LISTINCREMENT;

ElemType newbase = (ElemType)malloc(sizeof(ElemType) newsize);

if(newbase == NULL) return false;

memcpy(newbase, L->elem, _msize(L->elem));

free(L->elem);

L->elem = newbase;

L->listsize = newsize;

}

int j = 0;

for(j=L->length; j>=i; j--) L->elem[j] = L->elem[j-1];

L->elem[j] = e;

L->length++;

return true;

}

/------------------------------------------------------------

*** 作目的： 删除顺序表的第i个结点

初始条件： 线性表L已存在且非空，1<=i<=ListLength(L)

*** 作结果： 删除L的第i个数据元素，并用e返回其值，L的长度减1

函数参数：

SqList L 线性表L

int i 删除位置

ElemType e 被删除的数据元素值

返回值：

bool *** 作是否成功

------------------------------------------------------------/

bool ListDelete(SqList L, int i, ElemType e)

{

if(L == NULL) return false;

assert(L->elem != NULL);

if(i<1 || i>L->length) return false;

e = L->elem[i-1];

for(int j=i-1; j<L->length-1; j++) L->elem[j] = L->elem[j+1];

L->length--;

return true;

}

-------------------------------------Labcpp---------------------------------------------

/------------------------------------------------

测试数据

-------------------------------------------------/

#include <stdioh>

#include "DynaSeqListh"

int main()

{

printf("this is ok!");

SqList l;

InitList(&l);

int i=0;

int a=0;

while(i<5){

printf("请输入第%d个元素\n",i+1);

scanf("%d",&a);

if(ListInsert(&l,i+1,a))

printf("插入成功！\n");

i++;

}

ElemType e;

PriorElem(l,lelem[1],&e);

printf("第二个元素的前驱为：%d\n",e);

NextElem(l,lelem[1],&e);

printf("第二个元素的后继为：%d\n",e);

ListDelete(&l,3,&e);

printf("删除的元素为:%d\n\n",e);

printf("现在开始遍历！\n");

ListTraverse(l,visit);

return 0;

}

strlen为C语言库函数，包含于stringh中，作用为计算一个字符串(字符数组)中元素的个数，即从数组头部计数，直到遇到字符串结束符\0为止，计数结果不包括\0

其声明为：

unsigned int strlen(char s）;

比如定义字符串:

char p = "this is for testing";

调用

strlen(p);

返回的结果就是p中元素的个数，即19。

需要注意的是，strlen并不是绝对安全的，如果在传入的字符数组的合法范围内，不存在结束符\0,那么strlen函数会一直访问下去，超出数组范围，即出现越界访问。

所以使用strlen时，程序员必须确认参数字符数组中包含\0值，否则会出现不可预知后果。

#include <stdioh>

#include <stdlibh>

char read(int m) {  // 第一维的长度作为形参输入

int i = 0,n;

char a = (char )malloc(sizeof(char )  m);// 分配第一维的内存

for(i = 0;i < m;++i) {

printf("input the length of the %d province!\n",i + 1);

scanf("%d",&n); // 读取第二维的长度

getchar();

a[i] = (char )malloc(sizeof(char)  (n + 1));  // 分配第二维的内存

if(a[i]) {

printf("please input the name of the province\n");

gets(a[i]); // 输入字符串

}

else exit(-1);

}

return a;

}

int main() {

int i,n = 3;

char s = read(n);

for(i = 0; i < n; ++i)

printf("%s\n",s[i]);

return 0;

}

可变长度指的是在调用函数时，传入值（实参）的个数不固定。

实参是用来为形参赋值的，所以针对溢出的实参，必须有对应的形参来接收。

（1）可变长度的位置参数

形参名：用来接收溢出的位置实参，溢出的位置实参会被保存成元组的格式，然后赋值给紧跟其后的形参名。

（2）可变长度的关键字参数

形参名：用来接收溢出的关键字实参，会把溢出的关键字实参保存成字典格式，然后赋值给紧跟其后的形参名。

（3）可变和不可变长度的参数混用

注：混用时， args在 kwargs的前面。

（4）wrapper函数