C语言实验

void displayTable(table t) {
int i;
for ( i = 0; i < t.length; i++){
printf(“%d “, t.head[i]);
}
printf(”\n”);
}
int main() {
int i, add;
table t1 = initTable();
for ( i = 1; i < Size; i++){
t1.head[i - 1] = i;
t1.length++;
}
printf(“原顺序表:\n”);
displayTable(t1);

printf("删除元素1:\n");
t1 = delTable(t1, 1);
displayTable(t1);

printf("在第2的位置插入元素5:\n");
t1 = addTable(t1, 5, 2);
displayTable(t1);

printf("查找元素3的位置:\n");
add = selectTable(t1, 3);
printf("%d\n", add);
printf("将元素3改为6:\n");
t1 = amendTable(t1, 3, 6);
displayTable(t1);
return 0;

}

实验二 单链表的操作
#include<stdio.h>
#include<stdlib.h>
typedef struct Link {
int elem;
struct Link* next;
}link;
link* initLink();

link* insertElem(link* p, int elem, int add);

link* delElem(link* p, int add);

int seletElem(link * p,int elem);

link * amendElem(link * p,int add, int newElem);
void display(linkp);
int main(){
link * p = NULL;
int address;
printf(“初始化链表为: \n”);
p = initLink();
display§;
printf(“在第4的位置插入元素5: \n”);
p = insertElem(p, 5, 4);
display§;
printf(“删除元素3: \n”);
p = delElem(p, 3);
display§;
printf(“查找元素2的位置为: \n”);
address = selectElem(p, 2);
if(address == -1){
printf(“没有该元素”);
}
else{
printf(“元素2的位置为: %d\n”,address);
}
printf(“更改第3的位置上的数据为7:\n”);
p = amendElem(p, 3, 7);
display§;
return 0;
}
linkinitLink(){
linkp = (link)malloc(sizeof(link));
linktemp=p;
int i=0;
for(i=1;i<5;i++){
linka=(link*)malloc(sizeof(link));
a->elem = i;
a->next = NULL;
temp->next = a;
temp = temp->next;
}
return p;
}
linkinsertElem(linkp,int elem,int add){
link * temp = p;
link * c= NULL;
int i = 0;
for(i=1;i<add;i++){
if(temp NULL){
printf(“插入的位置无效\n”);
return p;
}
temp = temp->next;
}
c=(link*)malloc(sizeof(link));
c->elem = elem;
c->next = temp->next;
temp->next = c;
return p ;
}
linkdelElem(linkp,int add){
linktemp=p;
link * del =NULL;
int i = 0;
for(i=1;i<add;i++){
temp=temp->next;
}
del=temp->next;
temp->next=temp->next->next;
free(del);
return p ;
}
int selectElem(linkp,int elem){
link *t=p;
int i = 1;
while(t->next){
t = t->next;
if(t->elemelem){
return i;
}
i++;
}
return -1;
}
link*amendElem(link * p,int add,int newElem){
int i=0;
link * temp = p;
temp = temp->next;
for(i=1;i<add;i++)
temp = temp->next;
temp->elem = newElem;

return p ;

}
void display(link*p){
link * temp = p;
while(temp->next){
temp = temp->next;
printf(“%d “,temp->elem);
}
printf(”\n”);
}

实验三 顺序栈
#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int SElemType;
typedef int Status;
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
} SqStack;
Status InitStack(SqStack &S){
S.base=(SElemType )malloc(STACK_INIT_SIZE * sizeof(SElemType));
if(!S.base) exit(OVERFLOW);
S.top =S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}
Status StackEmpty(SqStack S){
if(S.top==S.base) return OK;
else return ERROR;
}
Status Push(SqStack &S, SElemType e){
if(S.top-S.base>=S.stacksize){
S.base=(SElemType)realloc(S.base,
(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;

}
*S.top++=e;
return OK;

}
Status Pop (SqStack &S,SElemType &e){
if(S.top == S.base) return ERROR;
e=*–S.top;
return OK;

}
void OutStack(SqStack S)
{ int *p;
if(S.top == S.base){
printf(“这是一个空栈！”);
}
else
for(p = S.top-1;p>=S.base;p–)
printf(“%6d”, *p);
printf(“\n”);
}

int main()
{ SqStack s;
int cord; SElemType a;
printf(“第一次使用必须初始化!\n”);
do{
printf(“\n 主菜单 \n”);
printf(" 1 初始化顺序栈 “);
printf(” 2 插入一个元素 “);
printf(” 3 删除栈顶元素 “);
printf(” 4 结束程序运行 “);
printf(”\n------------------------------------“);
printf(“请输入您的选择( 1, 2, 3, 4)”);
scanf(”%d",&cord);
printf(“\n”);
switch(cord)
{ case 1:
InitStack(s);
OutStack(s);
break;
case 2:
printf(“请输入要插入的数据元素： a=”);
scanf(“%d”,&a);
Push(s,a);
printf("%d 进栈之后的栈: ",a);
OutStack(s);
break;
case 3:
Pop(s,a);
printf("栈顶元素 %d 出栈之后的栈： ",a);
OutStack(s);
break;
case 4:
exit(0);
}
}while (cord<=4);
}

实验四 链栈
#include <stdio.h>
#include <stdlib.h>
typedef struct LinkNode{
int data;
struct LinkNode *next;

}*LiStack;

void printStack(LiStack p){

printf(“LinkStack:\n”);
if(p==NULL)
printf(“空栈\n”);

int i=1;
while (p!=NULL){
printf(“%d”,p->data);

p=p->next;
i++;
}
printf(“\n”);
free§;
}
bool InitStack_l(LiStack &S){
//不带头节点
S=NULL;
return true;
}

bool InitStack_2(LiStack &S){

S=(LinkNode*)malloc(sizeof(LinkNode));
if(S==NULL)
    return false;
    S->next=NULL;
    return true;

}
bool push_l(LiStack &S,int x){
LinkNode L=(LinkNode)malloc(sizeof(LinkNode));
L->data=x;
L->next=NULL;
if(SNULL){
S=L;
return true;
}
L->next=S;
S=L;
return true;
}
bool Pop_l(LiStack &S){
if(SNULL){
return false;
}
int x;
x=S->data;
S=S->next;
return true;
}
bool GetElem(LiStack &S){
if(SNULL){
return false;
}
printf(“栈顶元素是%d”,S->data);
return true;
}
bool Stack_Empty(LiStack S){
if(SNULL)
return true;
return false;
}
int main(void){
LiStack S;
InitStack_l(S);
printStack(S);
push_l(S,2);
push_l(S,2);
push_l(S,1);
push_l(S,4);
push_l(S,6);
push_l(S,9);
printStack(S);
Pop_l(S);
GetElem(S);
free(S);
return(0);
}

实验5 链的队列
#include
#include
#include
#include
#include
#define Status int
#define QElemType int
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
struct QNode *front,*rear;
}LinkQueue;
Status InitQueue(LinkQueue &Q)
{
Q.front=Q.rear=new QNode;
Q.front=Q.rear=new QNode;
Q.front->next=NULL;
return 1;
}
Status EnQueue(LinkQueue &Q,QElemType e)
{
QNode *p;
p=new QNode;
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return 1;
}
bool DeQueue(LinkQueue &Q,QElemType &e)
{
QueuePtr p;
if(Q.frontQ.rear)return false;
e=Q.front->next->data;
p=Q.front->next;
Q.front->next=p->next;
if(Q.rearp)Q.rear=Q.front;
free§;
if(Q.rearp)Q.rear=Q.front;
free§;
return true;
}
bool GetHead(LinkQueue &Q,QElemType &e)
{
if(Q.frontQ.rear) return false;
e=Q.front->next->data;
return true;
}
void menu()
{
printf(“1.入队 2.出队\n”);
printf(“3.取队顶元素 4.退出\n”);

}
void EnterToQueue(LinkQueue &Q)
{
int n;QElemType e;int flag;
printf(“请输入入队元素个数(>=1):\n”);
scanf(“%d”,&n);
for(int i=0;i<n;i++)
{
printf(“请输入第%d个元素的值:”,i+1);
scanf(“%d”,&e);
flag=EnQueue(Q,e);
if(flag)printf(“%d已入列\n”,e);
}
}
void DeleteFromQueue(LinkQueue &Q)
{
int n;
QElemType e;
int flag;
printf(“请输入出队元素个数(>=1);\n”);
scanf(“%d”,&n);
for(int i=0;i<n;i++)
{
flag=DeQueue(Q,e);
if(flag)printf(“%d已出列\n”,e);
else {
printf(“队已空！！！！！\n”);
break;
}
}
}
void GetHeadOfStack(LinkQueue Q)
{
QElemType e;
bool flag;
if(flag)printf(“队头元素:%d\n”,e);
else printf(“队已空！！！\n”);
}
//主函数
int main ()
{
LinkQueue Q;
int choice;
InitQueue ( Q);
while(1)
{
menu();
printf(“请输入菜单序号:\n”);
scanf(“%d”,&choice);
if(4==choice) break;
switch(choice)
{
case 1:EnterToQueue(Q);break;
case 2:DeleteFromQueue(Q);break;
case 3:GetHeadOfStack(Q);break;
default:printf(“输入错误！！！！！\n”);
}
}
return 0;
}

实验6 树的中序遍历
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TElemType int
//构造结点的结构体
typedef struct BiTNode{
TElemType data;//数据域
struct BiTNode *lchild,*rchild;//左右孩子指针
}BiTNode,*BiTree;
//初始化树的函数
void CreateBiTree(BiTree *T){
T=(BiTNode)malloc(sizeof(BiTNode));
(*T)->data=1;
(T)->lchild=(BiTNode)malloc(sizeof(BiTNode));
(T)->rchild=(BiTNode)malloc(sizeof(BiTNode));
(*T)->lchild->data=2;
(T)->lchild->lchild=(BiTNode)malloc(sizeof(BiTNode));
(T)->lchild->rchild=(BiTNode)malloc(sizeof(BiTNode));
(*T)->lchild->rchild->data=5;
(*T)->lchild->rchild->lchild=NULL;
(*T)->lchild->rchild->rchild=NULL;
(*T)->rchild->data=3;
(T)->rchild->lchild=(BiTNode)malloc(sizeof(BiTNode));
(*T)->rchild->lchild->data=6;
(*T)->rchild->lchild->lchild=NULL;
(*T)->rchild->lchild->rchild=NULL;
(T)->rchild->rchild=(BiTNode)malloc(sizeof(BiTNode));
(*T)->rchild->rchild->data=7;
(*T)->rchild->rchild->lchild=NULL;
(*T)->rchild->rchild->rchild=NULL;
(*T)->lchild->lchild->data=4;
(*T)->lchild->lchild->lchild=NULL;
(T)->lchild->lchild->rchild=NULL;
}
//模拟操作节点元素的函数，输出结点本身的数值
void displayElem (BiTNodeelem){
printf(“%d”,elem->data);
}
//中序遍历
void INOrderTraverse(BiTree T){
if(T){
INOrderTraverse(T->lchild);
displayElem(T);
INOrderTraverse(T->rchild);
}
return;
}
int main(){
BiTree Tree;
CreateBiTree(&Tree);
printf(“中序遍历里算法: \n”);
INOrderTraverse(Tree);
}

实验7 树的前序遍历
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TElemType int

typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void CreateBiTree(BiTree *T){
T=(BiTNode)malloc(sizeof(BiTNode));
(*T)->data=1;
(T)->lchild=(BiTNode)malloc(sizeof(BiTNode));
(T)->rchild=(BiTNode)malloc(sizeof(BiTNode));
(*T)->lchild->data=2;
(T)->lchild->lchild=(BiTNode)malloc(sizeof(BiTNode));
(T)->lchild->rchild=(BiTNode)malloc(sizeof(BiTNode));
(*T)->lchild->rchild->data=5;
(*T)->lchild->rchild->lchild=NULL;
(*T)->lchild->rchild->rchild=NULL;
(*T)->rchild->data=3;
(T)->rchild->lchild=(BiTNode)malloc(sizeof(BiTNode));
(*T)->rchild->lchild->data=6;
(*T)->rchild->lchild->lchild=NULL;
(*T)->rchild->lchild->rchild=NULL;
(T)->rchild->rchild=(BiTNode)malloc(sizeof(BiTNode));
(*T)->rchild->rchild->data=7;
(*T)->rchild->rchild->lchild=NULL;
(*T)->rchild->rchild->rchild=NULL;
(*T)->lchild->lchild->data=4;
(*T)->lchild->lchild->lchild=NULL;
(*T)->lchild->lchild->rchild=NULL;
}

void displayElem (BiTNode*elem){
printf("%d ",elem->data);
}
//前序遍历
void INOrderTraverse(BiTree T){
if(T){
displayElem(T);
INOrderTraverse(T->lchild);
INOrderTraverse(T->rchild);
}
return;
}
int main(){
BiTree Tree;
CreateBiTree(&Tree);
printf(“前序遍历里算法: \n”);
INOrderTraverse(Tree);
}

#include <stdio.h>
#define MAX_VERtEX_NUM 20 //顶点的最大个数
#define VRType int //表示顶点之间的关系的变量类型
#define InfoType char //存储弧或者边额外信息的指针变量类型
#define VertexType int //图中顶点的数据类型
typedef enum{DG,DN,UDG,UDN}GraphKind; //枚举图的 4 种类型
typedef struct {
VRType adj; //对于无权图，用 1 或 0 表示是否相邻；对于带权图，直接为权值。
InfoType * info; //弧或边额外含有的信息指针
}ArcCell,AdjMatrix[MAX_VERtEX_NUM][MAX_VERtEX_NUM];

typedef struct {
VertexType vexs[MAX_VERtEX_NUM]; //存储图中顶点数据
AdjMatrix arcs; //二维数组，记录顶点之间的关系
int vexnum,arcnum; //记录图的顶点数和弧（边）数
GraphKind kind; //记录图的种类
}MGraph;
//根据顶点本身数据，判断出顶点在数组中的位置
int LocateVex(MGraph * G,VertexType v){
int i=0;
//遍历一维数组，找到变量v
for (; ivexnum; i++) {
if (G->vexs[i]v) {
break;
}
}
//如果找不到，输出提示语句，返回-1
if (i>G->vexnum) {
printf(“no such vertex.\n”);
return -1;
}
return i;
}
//构造有向图
void CreateDG(MGraph *G){
//输入图含有的顶点数和弧的个数
scanf(“%d,%d”,&(G->vexnum),&(G->arcnum));
//依次输入顶点本身的数据
for (int i=0; ivexnum; i++) {
scanf(“%d”,&(G->vexs[i]));
}
//初始化二维矩阵，全部归0，指针指向NULL
for (int i=0; ivexnum; i++) {
for (int j=0; jvexnum; j++) {
G->arcs[i][j].adj=0;
G->arcs[i][j].info=NULL;
}
}
//在二维数组中添加弧的数据
for (int i=0; iarcnum; i++) {
int v1,v2;
//输入弧头和弧尾
scanf(“%d,%d”,&v1,&v2);
//确定顶点位置
int n=LocateVex(G, v1);
int m=LocateVex(G, v2);
//排除错误数据
if (m-1 ||n==-1) {
printf(“no this vertex\n”);
return;
}
//将正确的弧的数据加入二维数组
G->arcs[n][m].adj=1;
}
}
//构造无向图
void CreateDN(MGraph *G){
scanf(“%d,%d”,&(G->vexnum),&(G->arcnum));
for (int i=0; ivexnum; i++) {
scanf(“%d”,&(G->vexs[i]));
}
for (int i=0; ivexnum; i++) {
for (int j=0; jvexnum; j++) {
G->arcs[i][j].adj=0;
G->arcs[i][j].info=NULL;
}
}
for (int i=0; iarcnum; i++) {
int v1,v2;
scanf(“%d,%d”,&v1,&v2);
int n=LocateVex(G, v1);
int m=LocateVex(G, v2);
if (m==-1 ||n==-1) {
printf(“no this vertex\n”);
return;
}
G->arcs[n][m].adj=1;
G->arcs[m][n].adj=1;//无向图的二阶矩阵沿主对角线对称
}
}
//构造有向网，和有向图不同的是二阶矩阵中存储的是权值。
void CreateUDG(MGraph G){
scanf(“%d,%d”,&(G->vexnum),&(G->arcnum));
for (int i=0; ivexnum; i++) {
scanf(“%d”,&(G->vexs[i]));
}
for (int i=0; ivexnum; i++) {
for (int j=0; jvexnum; j++) {
G->arcs[i][j].adj=0;
G->arcs[i][j].info=NULL;
}
}
for (int i=0; iarcnum; i++) {
int v1,v2,w;
scanf(“%d,%d,%d”,&v1,&v2,&w);
int n=LocateVex(G, v1);
int m=LocateVex(G, v2);
if (m==-1 ||n==-1) {
printf(“no this vertex\n”);
return;
}
G->arcs[n][m].adj=w;
}
}
//构造无向网。和无向图唯一的区别就是二阶矩阵中存储的是权值
void CreateUDN(MGraph G){
scanf(“%d,%d”,&(G->vexnum),&(G->arcnum));
for (int i=0; ivexnum; i++) {
scanf(“%d”,&(G->vexs[i]));
}
for (int i=0; ivexnum; i++) {
for (int j=0; jvexnum; j++) {
G->arcs[i][j].adj=0;
G->arcs[i][j].info=NULL;
}
}
for (int i=0; iarcnum; i++) {
int v1,v2,w;
scanf(“%d,%d,%d”,&v1,&v2,&w);
int m=LocateVex(G, v1);
int n=LocateVex(G, v2);
if (m==-1 ||n==-1) {
printf(“no this vertex\n”);
return;
}
G->arcs[n][m].adj=w;
G->arcs[m][n].adj=w;//矩阵对称
}
}
void CreateGraph(MGraph *G){
//选择图的类型
scanf(“%d”,&(G->kind));
//根据所选类型，调用不同的函数实现构造图的功能
switch (G->kind) {
case DG:
return CreateDG(G);
break;
case DN:
return CreateDN(G);
break;
case UDG:
return CreateUDG(G);
break;
case UDN:
return CreateUDN(G);
break;
default:
break;
}
}
//输出函数
void PrintGrapth(MGraph G)
{
for (int i = 0; i < G.vexnum; i++)
{
for (int j = 0; j < G.vexnum; j++)
{
printf(“%d “, G.arcs[i][j].adj);
}
printf(”\n”);
}
}
int main() {
MGraph G;//建立一个图的变量
CreateGraph(&G);//调用创建函数，传入地址参数
PrintGrapth(G);//输出图的二阶矩阵
return 0;
}