1 "&"区别(c++)
#include<stdio.h>
void test(int x)
{
x=2024;
printf("in test x=%d\n",x);
}
int main()
{
int x=1;
printf("before test x=%d\n",x);
test(x);
printf("after test x=%d\n",x);
return 0;
}
before test x=1
in test x=2024
after test x=1
(没有带回参数的结果)
#include<stdio.h>
void test(int &x)
{
x=2024;
printf("in test x=%d\n",x);
}
int main()
{
int x=1;
printf("before test x=%d\n",x);
test(x);
printf("after test x=%d\n",x);
return 0;
}
before test x=1
in test x=2024
after test x=2024
(带回了参数的修改结果)
2 初始化顺序表(静态分配)(c++)
#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct
{
int data[MaxSize];//用静态数组存放数据元素
int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
for(int i=0;i<MaxSize;i++)
L.data[i]=0;//将所有数据元素设置为0
L.length=0;//顺序表初始长度为0
}
int main()
{
SqList L;//声明一个顺序表
InitList(L);//初始化顺序表
for(int i=0;i<MaxSize;i++)
printf("data[%d]为%d\n",i,L.data[i]);//打印顺序表每个元素
return 0;
}
data[0]为0
data[1]为0
data[2]为0
data[3]为0
data[4]为0
data[5]为0
data[6]为0
data[7]为0
data[8]为0
data[9]为0
3 动态分配顺序表
#include<stdlib.h>//malloc,free函数的头文件
#define InitSize 10//定义最大长度
typedef struct
{
int *data;//指示动态分配数组的指针
int MaxSize;//顺序表的最大容量
int length;//顺序表的当前长度
}SeqList;//顺序表的类型定义
void InitList(SeqList (&L))//初始化一个顺序表
{
L.data=(int *)malloc(InitSize*sizeof(int));//用malloc函数申请一片连续的存储空间
L.length=0;//顺序表初始长度为0
L.MaxSize=InitSize;//最大长度设置为宏定义的值
}
void IncreaseSize(SeqList (&L),int len)//增加动态数组的长度,给L增加len长度
{
int *p=L.data;
L.data=(int *)malloc((InitSize+len)*sizeof(int));//扩大空间
for(int i=0;i<L.length;i++)
L.data[i]=p[i];//将数据复制到新区域
L.MaxSize=L.MaxSize+len;//顺序表最大长度增加
free(p);//释放原来内存空间
}
int main()
{
SeqList L;//声明一个顺序表
InitList(L);//初始化顺序表
// 往顺序表中插入元素
IncreaseSize(L,5);//增加长度
return 0;
}
举例 :
#include<stdio.h>
#include<stdlib.h>//malloc,free函数的头文件
#define InitSize 5//定义最大长度
typedef struct
{
int *data;//指示动态分配数组的指针
int MaxSize;//顺序表的最大容量
int length;//顺序表的当前长度
}SeqList;//顺序表的类型定义
void InitList(SeqList (&L))//初始化一个顺序表
{
L.data=(int *)malloc(InitSize*sizeof(int));//用malloc函数申请一片连续的存储空间
L.length=0;//顺序表初始长度为0
L.MaxSize=InitSize;//最大长度设置为宏定义的值
}
void IncreaseSize(SeqList (&L),int len)//增加动态数组的长度,给L增加len长度
{
int *p=L.data;
L.data=(int *)malloc((InitSize+len)*sizeof(int));//扩大空间
for(int i=0;i<L.length;i++)
L.data[i]=p[i];//将数据复制到新区域
L.MaxSize=L.MaxSize+len;//顺序表最大长度增加
free(p);//释放原来内存空间
}
int main()
{
SeqList L;//声明一个顺序表
InitList(L);//初始化顺序表
printf("增加长度前的顺序表\n");
for(int i=0;i<InitSize;i++)
{
L.data[i]=i;
printf("data[%d]为%d\n",i,L.data[i]);//打印顺序表每个元素
L.length++;
}
IncreaseSize(L,5);//增加长度
printf("增加长度后的顺序表\n");
for(int t=0;t<L.MaxSize;t++)
{
L.data[t]=t;
printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
L.length++;
}
return 0;
}
增加长度前的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为4
增加长度后的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为4
data[5]为5
data[6]为6
data[7]为7
data[8]为8
data[9]为9
4 顺序表的插入
#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct{
int data[MaxSize];//用静态数组存放数据元素
int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
for(int i=0;i<MaxSize;i++)
L.data[i]=0;//将所有数据元素设置初始值
L.length=0;//顺序表初始长度为0
}
bool ListInsert(SqList &L,int i,int e)//在L的位置i插入元素e
{
if(i<1||i>L.length+1)
return false;//判断i的范围是否有效
if(L.length>=MaxSize)
return false;//当前存储空间已满,不能插入
for(int j=L.length;j>=i;j--)
L.data[j]=L.data[j-1];//将第i个元素及之后的元素后移
L.data[i-1]=e;//位置i放入e
L.length++;//长度+1
return true;
}
int main()
{
SqList L;//声明
InitList(L);//初始化
//...插入元素
ListInsert(L,3,9);//插入
return 0;
}
举例:
#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct
{
int data[MaxSize];//用静态数组存放数据元素
int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
for(int i=0;i<MaxSize;i++)
L.data[i]=0;//将所有数据元素设置为0
L.length=0;//顺序表初始长度为0
}
bool ListInsert(SqList &L,int i,int e)//在L的位置i插入元素e
{
if(i<1||i>L.length+1)
return false;//判断i的范围是否有效
if(L.length>=MaxSize)
return false;//当前存储空间已满,不能插入
for(int j=L.length;j>=i;j--)
L.data[j]=L.data[j-1];//将第i个元素及之后的元素后移
L.data[i-1]=e;//位置i放入e
L.length++;//长度+1
return true;
}
int main()
{
SqList L;//声明一个顺序表
InitList(L);//初始化顺序表
printf("插入元素前的顺序表\n");
for(int t=0;t<6;t++)
{
L.data[t]=t;
printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
L.length++;
}
ListInsert(L,3,9);//插入
printf("插入元素后的顺序表\n");
for(int i=0;i<L.length;i++)
{
printf("data[%d]为%d\n",i,L.data[i]);//打印顺序表每个元素
}
return 0;
}
插入元素前的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为4
data[5]为5
插入元素后的顺序表
data[0]为0
data[1]为1
data[2]为9
data[3]为2
data[4]为3
data[5]为4
data[6]为5
5 顺序表的删除
bool ListDelete(SqList &L,int i,int &e)//删除i并且返回e的值
{
if(i<1||i>L.length)
return false;//判断i的范围是否有效
e=L.data[i-1];//将被删除的元素赋值给e
for(int j=i;j<L.length;j++)
L.data[j-1]=L.data[j];//将第i个元素之后的元素前移
L.length--;//长度-1
return true;
}
举例:
#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct
{
int data[MaxSize];//用静态数组存放数据元素
int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
for(int i=0;i<MaxSize;i++)
L.data[i]=0;//将所有数据元素设置为0
L.length=0;//顺序表初始长度为0
}
bool ListDelete(SqList &L,int i,int &e)//删除i并且返回e的值
{
if(i<1||i>L.length)
return false;//判断i的范围是否有效
e=L.data[i-1];//将被删除的元素赋值给e
for(int j=i;j<L.length;j++)
L.data[j-1]=L.data[j];//将第i个元素之后的元素前移
L.length--;//长度-1
return true;
}
int main()
{
int e;
SqList L;//声明一个顺序表
InitList(L);//初始化顺序表
printf("开始的顺序表\n");
for(int t=0;t<MaxSize;t++)
{
L.data[t]=t;
printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
L.length++;
}
if(ListDelete(L,5,e))//删除
{
printf("删除了第5个元素,为%d\n",e);
printf("删除后的顺序表\n");
for(int i=0;i<L.length;i++)
{
printf("data[%d]为%d\n",i,L.data[i]);
}
}
return 0;
}
开始的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为4
data[5]为5
data[6]为6
data[7]为7
data[8]为8
data[9]为9
删除了第5个元素,为4
删除后的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为5
data[5]为6
data[6]为7
data[7]为8
data[8]为9
6 顺序表的按位查找
int GetElem(SqList &L,int i)
{
return L.data[i-1];
}
注意数据类型一致,如果GetElem前的类型变为ElemType,结构体指针的类型也要一起变为ElemType。
举例:
#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct
{
int data[MaxSize];//用静态数组存放数据元素
int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
for(int i=0;i<MaxSize;i++)
L.data[i]=0;//将所有数据元素设置为0
L.length=0;//顺序表初始长度为0
}
int GetElem(SqList &L,int i)
{
return L.data[i-1];
}
int main()
{
int e;
SqList L;//声明一个顺序表
InitList(L);//初始化顺序表
printf("顺序表\n");
for(int t=0;t<MaxSize;t++)
{
L.data[t]=t*t;
printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
L.length++;
}
e=GetElem(L,8);
printf("L中第8个值为%d\n",e);
return 0;
}
顺序表
data[0]为0
data[1]为1
data[2]为4
data[3]为9
data[4]为16
data[5]为25
data[6]为36
data[7]为49
data[8]为64
data[9]为81
L中第8个值为49
6 顺序表的按值查找
int LocateElem(SqList L,int e)
{
for(int i=0;i<L.length;i++)
if(L.data[i]==e)
return i+1;
return 0;
}
举例:
#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct
{
int data[MaxSize];//用静态数组存放数据元素
int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
for(int i=0;i<MaxSize;i++)
L.data[i]=0;//将所有数据元素设置为0
L.length=0;//顺序表初始长度为0
}
int LocateElem(SqList L,int e)
{
for(int i=0;i<L.length;i++)
if(L.data[i]==e)
return i+1;
return 0;
}
int main()
{
SqList L;//声明一个顺序表
InitList(L);//初始化顺序表
printf("顺序表\n");
for(int t=0;t<MaxSize;t++)
{
L.data[t]=2*t;
printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
L.length++;
}
printf("L中值为10的元素在第%d个位置\n",LocateElem(L,10));
return 0;
}
顺序表
data[0]为0
data[1]为2
data[2]为4
data[3]为6
data[4]为8
data[5]为10
data[6]为12
data[7]为14
data[8]为16
data[9]为18
L中值为10的元素在第6个位置
7 结构类型的比较
#include<stdio.h>
typedef struct
{
int n;
int a;
}p;
void pp()
{
p i;
i.n=1;
i.a=2;
p t;
t.n=1;
t.a=2;
if(i.n==t.n&&i.a==t.a)
printf("相等\n");
else
printf("不相等\n");
}
int main()
{
pp();
return 0;
}
相等