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函数
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）