#define _CRT_SECURE_NO_WARNINGS
#define OK 1
#define ERROR 1
#define OVERFLOW -1
#define TRUE 1
#define FALSE 0
#define MAXVEX 100
bool visited[MAXVEX];
#include<stdio.h>
#include<stdlib.h>
void ShowMainMenu() {
printf("\n");
printf("*******************算法与数据结构******************\n");
printf("*1 单链表的基本操作及应用 *\n");
printf("*2 栈的基本操作及应用 *\n");
printf("*3 数组的基本操作及应用 *\n");
printf("*4 树的基本操作及应用 *\n");
printf("*5 图的基本操作及应用 *\n");
printf("*6 退出 *\n");
printf("***************************************************\n");
}
typedef struct LNode {
intData;
structLNode *next;
}LNode, *LinkList;
void CreateList_L(LinkList&L, int n)
{
LinkListp;
L= (LinkList)malloc(sizeof(LNode));
L->next= NULL;
for(int i = 0; i <n; i++)
{
p= (LinkList)malloc(sizeof(LNode));
scanf("%d",&(p->Data));
p->next= L->next; L->next = p;
}
}
bool ListInsert_L(LinkList&L, int i,int e)
{
LinkListp, s;
p= L; int j = 0;
while(p&&j<i - 1)
{
p= p->next; ++j;
}
if(!p || j>i - 1)
{
returnfalse;
}
s= (LinkList)malloc(sizeof(LNode));
s->Data= e; s->next = p->next;
p->next= s;
returntrue;
}
bool ListDelete_L(LinkList&L, int i,int &e)
{
LinkListp, s;
p= L; int j = 0;
while(p->next&&j<i - 1)
{
p= p->next; ++j;
}
if(!(p->next) || j>i - 1)
{
returnfalse;
}
s= (LinkList)malloc(sizeof(LNode));
s= p->next; p->next = s->next;
e= s->Data; free(s);
returntrue;
}
LinkList ListFind_L(LinkList L, int X)
{
LinkListp = L; /* p指向L的第1个结点 */
while(p && p->Data != X)
p= p->next;
/*下列语句可以用 return p; 替换 */
if(p)
returnp;
else
returnfalse;
}
void ListDisplay_L(LinkList L)
{
L= L->next;
while(L != NULL)
{
printf("%d", L->Data);
L= L->next;
}
}
void LLinkList() {
LinkListL = 0;
intn;
do{
printf("\n");
printf("**************单链表的基本操作及应用***************\n");
printf("*1 创建 *\n");
printf("*2 插入 *\n");
printf("*3 删除 *\n");
printf("*4 查找 *\n");
printf("*5 显示 *\n");
printf("*6 通讯录（应用） *\n");
printf("*7 退出 *\n");
printf("***************************************************\n");
printf("请选择：");
scanf("%d",&n);
switch(n) {
case1:
printf("--------创建单链表---------\n");
printf("请输入要创建的链表的元素个数：");
inta1;
scanf("%d",&a1);
CreateList_L(L,a1);
break;
case2:
printf("--------插入元素-------");
printf("请输入要插入的元素及其插入的位置：");
inta2, b;
scanf("%d%d", &a2, &b);
ListInsert_L(L,b, a2);
break;
case3:
printf("--------删除元素-------");
printf("请输入要删除元素的位置：");
inta3;
scanf("%d",&a3);
inte;
ListDelete_L(L,a3, e);
printf("删除的元素为：%d", e);
break;
case4:
printf("--------查找元素-------");
printf("请输入要查找的元素：");
inta4;
scanf("%d",&a4);
if(ListFind_L(L, a4))
{
printf("查找到的元素为：");
printf("%d",ListFind_L(L, a4)->Data);
}
else
{
printf("查找失败！");
}
break;
case5:
printf("--------显示链表-------");
ListDisplay_L(L);
break;
case6:
printf("--------通讯录---------");
break;
case7: break;
default:
printf("ERROR!");break;
}
}while (n != 7);
}
typedef int Position;
struct SNode {
int*Data; /* 存储元素的数组 */
PositionTop; /* 栈顶指针*/
intMaxSize; /* 堆栈最大容量 */
};
typedef struct SNode *Stack;
Stack CreateStack(int MaxSize)
{
StackS = (Stack)malloc(sizeof(struct SNode));
S->Data= (int *)malloc(MaxSize * sizeof(int));
S->Top= -1;
S->MaxSize= MaxSize;
returnS;
}
bool IsFull(Stack S)
{
return(S->Top == S->MaxSize - 1);
}
bool Push(Stack S, int X)
{
if(IsFull(S)) {
printf("堆栈满");
returnfalse;
}
else{
S->Data[++(S->Top)]= X;
returntrue;
}
}
bool IsEmpty(Stack S)
{
return(S->Top == -1);
}
int Pop(Stack S)
{
if(IsEmpty(S)) {
printf("堆栈空");
returnfalse;
}
else
return(S->Data[(S->Top)--]);
}
void SStack() {
intnumber;
printf("请输入堆栈中最多元素个数：");
scanf("%d",&number);
StackS = CreateStack(number);
intn;
do{
printf("\n");
printf("****************栈的基本操作及应用*****************\n");
printf("*1 进栈 *\n");
printf("*2 出栈 *\n");
printf("*3 取栈顶元素 *\n");
printf("*4 表达式求解（应用） *\n");
printf("*5 退出 *\n");
printf("***************************************************\n");
printf("请选择：");
scanf("%d",&n);
switch(n) {
case1:
printf("--------进栈-------");
printf("请输入要进栈的元素：");
inta1;
scanf("%d",&a1);
Push(S,a1);
break;
case2:
printf("--------出栈-------");
printf("%d",Pop(S));
break;
case3:
printf("--------取栈顶元素-------");
printf("%d",Pop(S));
break;
case4:
{
intx1, x2, result = 0, n = 0;
printf("--------表达式求值-------\n");
printf("请输入x:");
scanf("%d",&x1);
for(int i = 0; i < number; i++)
{
x2= Pop(S);
n= x1*x2;
result+= n;
}
printf("计算的值为：");
printf("%d",result);
break;
}
case5:break;
default:
printf("ERROR!");break;
}
}while (n != 5);
}
typedef struct Array
{
int*pBase;
intlen;
intcnt;
}*PArr;
void init_arr(PArr &pArr, int len)
{
pArr= (Array*)malloc(sizeof(Array));
pArr->pBase= (int *)malloc(sizeof(int)*len);
if(pArr->pBase == NULL) {
printf("动态内存分配失败");
exit(-1);//终止整个程序
}
else{
pArr->len= len;
pArr->cnt= 0;
}
}
int is_full(PArr &pArr) {
if(pArr->cnt == pArr->len) {
return0; //0代表true，表示已满
}
else{
return1; //1代表false，表示未满
}
}
int append_arr(PArr &pArr, int val) {
if(is_full(pArr) == 0) {
return0;
}
else{
pArr->pBase[pArr->cnt]= val;
pArr->cnt++;
return1;
}
}
int is_empty(PArr &pArr) {
if(pArr->cnt == 0) {
return0; //0代表true
}
else{
return1; //1代表false
}
}
void show_arr(PArr &pArr) {
if(is_empty(pArr) == 0) {
printf("当前数组为空！");
}
else{
inti;
for(i = 0; i<pArr->cnt; ++i) {
printf("%d ", pArr->pBase[i]);
}
printf("\n");
}
}
void AArray() {
Array*pArr = 0;
Array*pBrr = 0;
printf("请输入数组的长度：");
inta;
scanf("%d",&a);
init_arr(pArr,a);
intn;
do{
printf("\n");
printf("*************稀疏矩阵的压缩存储及应用**************\n");
printf("*1 创建 *\n");
printf("*2 显示 *\n");
printf("*3 矩阵乘法（应用） *\n");
printf("*4 退出 *\n");
printf("***************************************************\n");
printf("请选择：");
scanf("%d",&n);
switch(n) {
case1:
printf("---------创建-------\n");
for(int i = 0; i < a; i++)
{
printf("请输入要加入数组的元素：");
intb;
scanf("%d",&b);
append_arr(pArr,b);
}
break;
case2:
printf("---------显示-------");
show_arr(pArr);
break;
case3:
{
printf("---------矩阵乘法-------\n");
getchar();
init_arr(pBrr,a);
for(int i = 0; i < a; i++)
{
printf("请输入要加入另一个数组的元素：");
intbb;
scanf("%d",&bb);
append_arr(pBrr,bb);
}
inta = 0, b = 0;
for(int i = 0; i < pArr->cnt; ++i) {
a= (pArr->pBase[i]) *(pBrr->pBase[i]);
b+= a;
}
printf("计算之后的值为：");
printf("%d",b);
break;
}
case4:break;
default:
printf("ERROR!");break;
}
}while (n != 4);
}
typedef struct BinNode
{
chardata;
BinNode*lchild, *rchild;
}*BinTree; //二叉树链式存储结构
void CreateBinTree(BinTree &T)//先序建立二叉树
{
charch;
printf("请输入数据：");
scanf("%c",&ch);
getchar();
if(ch == ' ')
T= NULL;
else
{
if(!(T = (BinNode*)malloc(sizeof(BinNode))))
{
exit(-1);
printf("1\n");
}
T->data= ch;//这是根节点
CreateBinTree(T->lchild);//创建左孩子
CreateBinTree(T->rchild);//创建右孩子
}
}
void PreOrder(BinTree T)//前序遍历二叉树
{
if(T != NULL)
{
printf("%c",T->data);
PreOrder(T->lchild);
PreOrder(T->rchild);
}
}
void InOrder(BinTree T)//中序遍历二叉树
{
if(T != NULL)
{
InOrder(T->lchild);
printf("%c",T->data);
InOrder(T->rchild);
}
}
void PostOrder(BinTree T)//后序遍历二叉树
{
if(T != NULL)
{
PostOrder(T->lchild);
PostOrder(T->rchild);
printf("%c",T->data);
}
}
char a[10]; char *p = a;
void cengxu(BinTree T, char *p)
{
BinTreetemp[100]; //关键中间变量存放每一层的数据
intin = 0, out = 0;
temp[in++]= T; //每次把这一层存入，然后输出的时候就把他的左右节点存入
while(in > out) //例如一颗完全二叉树abcdefg 输出a的时候把bc放入,输出b的时候把b
{ //的孩子放入也就是de，再输出c并且放入孩子fg，依次这样，达到层序的要求
if(temp[out])
{
//printf("%c",temp[out]->data);
*p= temp[out]->data; p++;
temp[in++]= temp[out]->lchild;
temp[in++]= temp[out]->rchild;
}
out++;
}
}
int cnt = 0;
int countNode(BinTree T)//求二叉树中节点的个数
{
if(T)
{
cnt++;
countNode(T->lchild);
countNode(T->rchild);
}
returncnt;
}
int leafCountOfBiTree(const BinTree &T)
{
if(T == NULL)
return0;
if(T->lchild == NULL && T->rchild == NULL)
return1;
returnleafCountOfBiTree(T->lchild) + leafCountOfBiTree(T->rchild);
}
int depthval = 0;
int dl = 0;
int dr = 0;
int Depth(BinTree T)//求二叉树的高度
{
if(!T)
return0;
else
{
dl= Depth(T->lchild);
dr= Depth(T->rchild);
depthval= 1 + (dl>dr ? dl : dr);
returndepthval;
}
}
char Parent(BinTree &T, char e)
{
cengxu(T,p);
for(int i = 0; i < 10; i++)
{
if(a[i] == e)
{
i-= 1;
returna[i / 2];
}
}
}
char brother(BinTree &T, char e)
{
cengxu(T,p);
if(T->data == e)
{
return'a';
}
for(int i = 0; i < 10; i++)
{
if(a[i] == e)
{
if(a[(i - 1) / 2] == a[i / 2])
{
returna[i + 1];
}
elseif (a[(i - 1) / 2] == a[(i - 2) / 2])
{
returna[i - 1];
}
}
}
}
void BiTree() {
BinTreeT = 0;
intn;
do{
printf("\n");
printf("**************二叉树的基本操作及应用***************\n");
printf("*1 创建二叉树 *\n");
printf("*2 遍历二叉树（先/中/后） *\n");
printf("*3 计算树的深度 *\n");
printf("*4 计算叶子结点个数 *\n");
printf("*5 查找双亲 *\n");
printf("*6 查找兄弟 *\n");
printf("*7 Huffman编码（应用） *\n");
printf("*8 退出\n");
printf("***************************************************\n");
printf("请选择：");
scanf("%d",&n);
switch(n) {
case1:
printf("---------创建二叉树--------\n");
getchar();
printf("先序创建二叉树，先顶点，再左孩子，再右孩子\n");
printf("(例如二叉树1 2 3，则输入为“12 3 ”，2，3后面两个空格，因为它们是叶子结点)\n");
CreateBinTree(T);
break;
case2:
printf("---------*遍历二叉树-------\n");
printf("先序遍历：");
PreOrder(T);
printf("\n");
printf("中序遍历：");
InOrder(T);
printf("\n");
printf("后序遍历：");
PostOrder(T);
break;
case3:
printf("---------计算树的深度------");
printf("树的深度为：");
printf("%d",Depth(T));
break;
case4:
printf("---------计算叶子结点个数-------");
printf("树的叶子结点个数为：");
printf("%d",leafCountOfBiTree(T));
break;
case5:
printf("---------查找双亲-------\n");
getchar();
printf("请输入要查找的结点：");
chare;
scanf("%c",&e);
printf("该节点的双亲为：");
printf("%c",Parent(T, e));
break;
case6:
printf("---------查找兄弟-------\n");
getchar();
printf("请输入要查找的结点：");
charee;
scanf("%c",&ee);
getchar();
printf("该节点的兄弟为：");
if(brother(T, ee) != 'a')
{
printf("%c\n",brother(T, ee));
}
else
{
printf("该节点无兄弟");
}
break;
case7:
printf("---------Huffman编码-------");
break;
case8:break;
default:
printf("ERROR!");break;
}
}while (n != 8);
}
typedef enum { DG, DN, UDG, UDN }Graphkind;
#define MAX_VERTEX_num 20
typedef struct Mgrap
{
charvwrs[MAX_VERTEX_num];
intarcs[MAX_VERTEX_num][MAX_VERTEX_num];
intvexnum, arcunm;
Graphkindkind;
}*mgrap;
void creatUDG(mgrap & G)
{
inti, j, k;
printf("请输入无向图的顶点数和边数\n");
scanf_s("%d%d", &G->vexnum, &G->arcunm);
getchar();
printf("请依次输入顶点的序号：\n");
for(i = 0; i < G->vexnum; i++)
{
scanf_s("%c",&G->vwrs[i]);
getchar();
}
for(i = 1; i <= G->vexnum; i++)
for(j = 1; j <= G->arcunm; j++)
G->arcs[i][j]= -1;
for(k = 1; k <= G->arcunm; k++)
{
printf("请输入边的两个点(例如顶点2到顶点3有边，则输入2 3，空格间隔)：");
scanf_s("%d%d", &i, &j);
G->arcs[j][i]= G->arcs[i][j] = 0;
}
}
void creatUDN(mgrap &G)
{
inti, j, k;
printf("请输入无向网的顶点数和边数\n");
scanf_s("%d%d", &G->vexnum, &G->arcunm);
getchar();
printf("请依次输入顶点的序号：\n");
for(i = 0; i < G->vexnum; i++)
{
scanf_s("%c",&G->vwrs[i]);
getchar();
}
for(i = 1; i <= G->vexnum; i++)
for(j = 1; j <= G->arcunm; j++)
G->arcs[i][j]= -1;
for(k = 1; k <= G->arcunm; k++)
{
printf("请输入边的两个点(例如顶点2到顶点3有边，则输入2 3，空格间隔)：");
scanf_s("%d%d", &i, &j);
printf("输入权值");
getchar();
scanf_s("%d",&G->arcs[i][j]);
G->arcs[j][i]= G->arcs[i][j];
}
}
void creatDG(mgrap &g)
{
inti, j, k;
printf("请输入有向图的顶点数和边数");
scanf_s("%d%d", &g->vexnum, &g->arcunm);
getchar();
printf("请依次输入顶点的序号：\n");
for(i = 0; i < g->vexnum; i++)
{
scanf_s("%c",&g->vwrs[i]);
getchar();
}
for(i = 1; i <= g->vexnum; i++)
for(j = 1; j <= g->arcunm; j++)
g->arcs[i][j]= -1;
for(k = 1; k <= g->arcunm; k++)
{
printf("请输入边的两个点(例如顶点2到顶点3有边，则输入2 3，空格间隔)：");
scanf_s("%d%d", &i, &j);
g->arcs[i][j]= 0;
}
}
void creatDN(mgrap &g)
{
inti, j, k;
printf("请输入有向网的顶点数和边数");
scanf_s("%d%d", &g->vexnum, &g->arcunm);
fflush(stdin);
printf("请依次输入顶点的序号：\n");
for(i = 0; i < g->vexnum; i++)
{
scanf_s("%c",&g->vwrs[i]);
fflush(stdin);
}
for(i = 1; i <= g->vexnum; i++)
for(j = 1; j <= g->arcunm; j++)
g->arcs[i][j]= -1;
for(k = 1; k <= g->arcunm; k++)
{
printf("请输入边的两个点(例如顶点2到顶点3有边，则输入2 3，空格间隔)：");
scanf_s("%d%d", &i, &j);
printf("输入权值");
fflush(stdin);
scanf_s("%d",&g->arcs[i][j]);
/*g->arcs[j][i]= g->arcs[i][j];*/
}
}
/*图的输出*/
void show(mgrap G)
{
inti, j;
for(i = 0; i <G->vexnum; i++)
{
printf("%5c",G->vwrs[i]);
}
printf("\n");
printf("按矩阵的方式输出:(0表示两点有边，-1表示两点无边，其他数值表示权值)\n");
for(i = 1; i <= G->vexnum; i++)
{
for(j = 1; j <= G->arcunm; j++)
printf("%5d",G->arcs[i][j]);
printf("\n");
}
}
void sort(mgrap g)
{
inti, j, k;
for(i = 1; i <= g->vexnum; i++)
{
intflag = 0;
for(j = 1; j <= g->arcunm; j++)
{
if(g->arcs[i][j] == 0)
{
if(g->arcs[j][i] != 0 && flag != 1)
{
printf("%5c",g->vwrs[i - 1]);
flag= 1;
}
}
}
}
printf("%5c",g->vwrs[g->vexnum - 1]);
}
void Graph() {
mgrapG, g;
G= (mgrap)malloc(sizeof(Mgrap));
g= (mgrap)malloc(sizeof(Mgrap));
intn;
do{
printf("\n");
printf("****************图的基本操作及应用*****************\n");
printf("*1 创建无向图 *\n");
printf("*2 创建无向网 *\n");
printf("*3 创建有向图 *\n");
printf("*4 创建有向网 *\n");
printf("*5 遍历 *\n");
printf("*6 拓扑排序 *\n");
printf("*7 最小生成树（应用） *\n");
printf("*8 最短路径（应用） *\n");
printf("*9 关键路径（应用） *\n");
printf("*10 退出 *\n");
printf("***************************************************\n");
printf("请选择：");
scanf_s("%d",&n);
switch(n) {
case1:
printf("---------创建无向图-------\n");
creatUDG(G);
break;
case2:
printf("---------创建无向网-------\n");
creatUDN(G);
break;
case3:
printf("---------创建有向图-------\n");
creatDG(g);
break;
case4:
printf("---------创建有向网-------\n");
creatDN(g);
break;
case5:
printf("---------遍历-------\n");
printf("请选择图的类型：1：无向图/网 2：有向图/网");
intz;
scanf_s("%d",&z);
switch(z)
{
case1: show(G); break;
case2: show(g); break;
default:printf("error");break;
}
break;
case6:
printf("---------拓扑排序-------\n");
sort(g);
break;
case7:
printf("---------最小生成树-------"); break;
case8:
printf("---------最短路径-------"); break;
case9:
printf("---------关键路径-------"); break;
case10:break;
default:
printf("ERROR!");break;
}
}while (n != 10);
}
void main() {
intn;
do{
ShowMainMenu();
printf("请选择：");
scanf("%d",&n);
switch(n) {
case1:LLinkList(); break;
case2:SStack(); break;
case3:AArray(); break;
case4:BiTree(); break;
case5:Graph(); break;
case6:break;
default:printf("ERROR!");break;
}
}while (n != 6);
}
应用要求实现两个，数组乘法和表达式求值
4977
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
