（1）编写算法，将二个升序链表在原表空间上合并成一个升序链表，须自行写出测试样例进行测试，截图为证。
解答：
（1）源代码
#include<stdio.h>
#include<stdlib.h>
//定义结构体
typedef struct node{
int data;//数据域
struct node* next;//指针域
}ElemSN;
//头插法创建单向链表
ElemSN *PreCreatLink(int a[],int n)
{
ElemSN *head=NULL,*p;
for(int i=n-1;i>-1;i--)
{
p=(ElemSN*)malloc(sizeof(ElemSN));
p->data=a[i];
p->next=head;
head=p;
}
return head;
}
ElemSN* Combine(ElemSN *head1,ElemSN *head2)
{
ElemSN *head,*p,*tail;
head=NULL;
while(head1&&head2)
{
if(head1->data<head2->data)
{
p=head1;
head1=head1->next;
}
else
{
p=head2;
head2=head2->next;
}
p->next=NULL;
if(!head)
head=tail=p;
else
{
tail=tail->next=p;
}
}
if(head1)
p=head1;
else
p=head2;
tail->next=p;
return head;
}
//打印链表所有结点的值
void PrintLink(ElemSN* head)
{
ElemSN *p=head;
for(;p;p=p->next)
printf("%5d",p->data);
printf("\n");
}
int main(void)
{
ElemSN *head1,*head2,*head;
int a[7]={2,3,4,6,7,9,11};
int b[5]={2,4,5,7,9};
head1=PreCreatLink(a,7); //创建链表head1
printf("链表1：");
PrintLink(head1);
head2=PreCreatLink(b,5); //创建链表head2
printf("链表2：");
PrintLink(head2);
head=Combine(head1,head2); //将两个有序链表合并成一个有序链表
printf("合并以后：");
PrintLink(head); //输出链表
}
（2）程序运行结果截图与说明
（2）利用顺序存储结构存储如下二叉树，并在顺序结构的基础上（利用链式结构完成给予零分）完成如下功能：
1）完成后序遍历，输出后序序列；
2）编写算法输出所有度为1的结点及数量；
二叉树结构
解答：
（1）源代码
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
typedef struct node {
char data;
struct node *lchild, *rchild;
} BinTreeNode;
BinTreeNode * createBinTreeByArray(char *array, int size);
void preOrderTraverse(BinTreeNode *node);
void postOrderTraverse(BinTreeNode *node);
int count=0; //所有度为1的结点数量
int main(int argc, const char * argv[]) {
char array[] = {'A', 'B', 'G', 'C', 'E', 'H', 'I','#','D','#','F'};
BinTreeNode *rootNode = createBinTreeByArray(array, sizeof(array));
printf("后续遍历:");
postOrderTraverse(rootNode);
printf("\n");
printf("所有度为1的结点数量 :%d\n",count);
printf("所有度为1的结点: ");
preOrderTraverse(rootNode);
printf("\n");
return 0;
}
//根据顺序存储序列创建二叉树
BinTreeNode * createBinTreeByArray(char *array, int size) {
int currLevel = 1;
int currLevelBegin = 0;
int parentLevelBegin = 0;
BinTreeNode **nodeArray = (BinTreeNode **) malloc(sizeof(BinTreeNode *) * size);
while (currLevelBegin < size) {
int levelNumber = pow(2, currLevel - 1);
int parentStep = 0;
for (int step = 0; step < levelNumber; step++) {
int index = currLevelBegin + step;
if (index >= size) break;
BinTreeNode *node = NULL;
if (array[index] != '#') {
node = (BinTreeNode *) malloc(sizeof(BinTreeNode));
node->data = array[index];
node->lchild = NULL;
node->rchild = NULL;
nodeArray[index] = node;
}else{
count++;
}
if (currLevelBegin > 0) {
BinTreeNode *parentNode = nodeArray[parentLevelBegin + parentStep];
if (step % 2 == 0) {
parentNode->lchild = node;
} else {
parentNode->rchild = node;
parentStep++;
}
}
}
parentLevelBegin = currLevelBegin;
currLevelBegin += levelNumber;
currLevel++;
}
BinTreeNode *rootNode = nodeArray[0];
free(nodeArray);
return rootNode;
}
//前序遍历
void preOrderTraverse(BinTreeNode *node) {
if (node != NULL) {
if((node->lchild==NULL && node->rchild!=NULL) || (node->lchild!=NULL && node->rchild==NULL))
printf("%c", node->data);
preOrderTraverse(node->lchild);
preOrderTraverse(node->rchild);
}
}
//后序遍历
void postOrderTraverse(BinTreeNode *node) {
if (node != NULL) {
postOrderTraverse(node->lchild);
postOrderTraverse(node->rchild);
printf("%c", node->data);
}
}
（2）程序运行结果截图与说明
（3）接上一题（此题单独评分）：
1）求出该二叉树的深度
2）输出图中所有叶子结点到根节点的路径
3）输出最长路径及长度
解答：
（1）源代码
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
typedef struct node {
char data;
struct node *lchild, *rchild;
} BinTreeNode;
BinTreeNode * createBinTreeByArray(char *array, int size);
void preOrderTraverse(BinTreeNode *node);
void postOrderTraverse(BinTreeNode *node);
void LongestPath(BinTreeNode *node,char path[],int &pathLength,char longestPath[],int &longestLength);
void AllPath(BinTreeNode *node,char path[],int &pathLength);
int count=0; //所有度为1的结点数量
int max=0,a=0;//统计二叉树深度
int main(int argc, const char * argv[]) {
char array[] = {'A', 'B', 'G', 'C', 'E', 'H', 'I','#','D','#','F'};
char path[100],longestPath[100];
int pathLength=0,longestLength=0;
BinTreeNode *rootNode = createBinTreeByArray(array, sizeof(array));
printf("后续遍历:");
postOrderTraverse(rootNode);
printf("\n");
printf("所有度为1的结点数量 :%d\n",count);
printf("所有度为1的结点: ");
preOrderTraverse(rootNode);
printf("\n");
printf("二叉树深度：%d",max-1);
printf("\n");
AllPath(rootNode,path,pathLength);
LongestPath(rootNode,path,pathLength,longestPath,longestLength);
printf("最长的路径是:");
for(int i=longestLength;i>=0;i--)
{
printf("%c ",longestPath[i]);
}
printf("\n");
return 0;
}
//根据顺序存储序列创建二叉树
BinTreeNode * createBinTreeByArray(char *array, int size) {
int currLevel = 1;
int currLevelBegin = 0;
int parentLevelBegin = 0;
BinTreeNode **nodeArray = (BinTreeNode **) malloc(sizeof(BinTreeNode *) * size);
while (currLevelBegin < size) {
int levelNumber = pow(2, currLevel - 1);
int parentStep = 0;
for (int step = 0; step < levelNumber; step++) {
int index = currLevelBegin + step;
if (index >= size) break;
BinTreeNode *node = NULL;
if (array[index] != '#') {
node = (BinTreeNode *) malloc(sizeof(BinTreeNode));
node->data = array[index];
node->lchild = NULL;
node->rchild = NULL;
nodeArray[index] = node;
}else{
count++;
}
if (currLevelBegin > 0) {
BinTreeNode *parentNode = nodeArray[parentLevelBegin + parentStep];
if (step % 2 == 0) {
parentNode->lchild = node;
} else {
parentNode->rchild = node;
parentStep++;
}
}
}
parentLevelBegin = currLevelBegin;
currLevelBegin += levelNumber;
currLevel++;
}
BinTreeNode *rootNode = nodeArray[0];
free(nodeArray);
return rootNode;
}
//前序遍历
void preOrderTraverse(BinTreeNode *node) {
if (node != NULL) {
a++;
if((node->lchild==NULL && node->rchild!=NULL) || (node->lchild!=NULL && node->rchild==NULL))
printf("%c", node->data);
preOrderTraverse(node->lchild);
preOrderTraverse(node->rchild);
if(a>max)
max=a;
a =0;
}
}
//后序遍历
void postOrderTraverse(BinTreeNode *node) {
if (node != NULL) {
postOrderTraverse(node->lchild);
postOrderTraverse(node->rchild);
printf("%c", node->data);
}
}
void AllPath(BinTreeNode *node,char path[],int &pathLength)
{
if(node!=NULL)
{
if(node->lchild==NULL&&node->rchild==NULL)
{
path[pathLength]=node->data;
printf("%c叶子节点到根节点的路径为: ",node->data);
for(int i=pathLength;i>=0;i--)
printf("%c ",path[i]);
printf("\n");
}
else
{
path[pathLength++]=node->data;
AllPath(node->lchild,path,pathLength);
AllPath(node->rchild,path,pathLength);
pathLength--;
}
}
}
//输出最长路径，算法和输出所有路径相似
//不同的是，遇到叶子节点时，比较当前路径和是否比目前记录的最长路径
//还长，如果是，则更新最长路径。
void LongestPath(BinTreeNode *node,char path[],int &pathLength,char longestPath[],int &longestLength)
{
if(node!=NULL)
{
if(node->lchild==NULL&&node->rchild==NULL)
{
path[pathLength]=node->data;
if(pathLength>longestLength)
{
for(int i=pathLength;i>=0;i--)
{
longestPath[i]=path[i];
}
longestLength=pathLength;
}
}
else
{
path[pathLength++]=node->data;
LongestPath(node->lchild,path,pathLength,longestPath,longestLength);
LongestPath(node->rchild,path,pathLength,longestPath,longestLength);
pathLength--;
}
}
}
（2）程序运行结果截图与说明
（4）利用邻接矩阵存储如下图结构，并完成如下功能：
1）读取邻接矩阵中存储的数据，将其转化为邻接表存储，并将邻接表输出；
2）利用邻接表统计每个顶点的出度、入度；
解答：
（1）源代码
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdlib.h>
#include <iostream>
#include <iomanip>
typedef char VertexType[4];
typedef char InfoPtr;
typedef int VRType;
using namespace std;
#define MAXSIZE 50
typedef enum{DG,DN,UG,UN} GraphKind;//有向图，有向网，无向图，无向网
//定义邻接矩阵类型
typedef struct
{
VRType adj;
InfoPtr *info;
}AdjMatrix[MAXSIZE][MAXSIZE];
typedef struct
{
VertexType vex[MAXSIZE];
AdjMatrix arc;
int vexnum, arcnum;
GraphKind kind;
}MGraph;
typedef struct ArcNode
{
int adjvex;
InfoPtr *info;
struct ArcNode *nextarc;
}ArcNode;
typedef struct VNode
{
VertexType data;
ArcNode *firstarc;
}VNode,AdjList[MAXSIZE];
typedef struct
{
AdjList vertex;
int vexnum, arcnum;
GraphKind kind;
}AdjGraph;
void CreateGraph(MGraph *G);
int LocateVertex(MGraph G, VertexType v);
void DestroyGraph(MGraph *G);
void DisplayGraph(MGraph G);
void DisplayAdjGraph(AdjGraph G);
void ConvertGraph(AdjGraph *A, MGraph M);
void main()
{
MGraph M;
AdjGraph A;
cout << "创建一个有向图：" << endl;
CreateGraph(&M);
cout << "输出顶点和弧：" << endl;
DisplayGraph(M);
ConvertGraph(&A, M);
DisplayAdjGraph(A);
DestroyGraph(&M);
system("pause");
}
void CreateGraph(MGraph *G)
{
int i, j, k;
VertexType v1, v2;
cout << "请输入有向图的顶点数和弧数：" << endl;
cin >> (*G).vexnum >> (*G).arcnum;
cout << "请输入"<<G->vexnum<<"个顶点的值：" << endl;
for (i = 0; i < G->vexnum;i++)
{
cin >> G->vex[i];
}
for (i = 0; i < G->vexnum;i++)
{
for (j = 0; j < G->vexnum;j++)
{
G->arc[i][j].adj = 0;
G->arc[i][j].info = NULL;
}
}
cout << "请输入" << G->arcnum << "条弧的弧尾 弧头（以空格分隔）" << endl;
for (k = 0; k < G->arcnum;k++)
{
cin >> v1 >> v2;
i = LocateVertex(*G, v1);
j = LocateVertex(*G, v2);
G->arc[i][j].adj = 1;
}
G->kind = DG;
}
int LocateVertex(MGraph G, VertexType v)
{
int i;
for (i = 0; i < G.vexnum;++i)
{
if (strcmp(G.vex[i],v)==0)
{
return i;
}
}
return -1;
}
void DestroyGraph(MGraph *G)
{
int i, j;
for (i = 0; i < G->vexnum;i++)
{
for (j = 0; j < G->vexnum;j++)
{
if (G->arc[i][j].adj!=0)
{
if (G->arc[i][j].info!=NULL)
{
free(G->arc[i][j].info);
G->arc[i][j].info = NULL;
}
G->vexnum = 0;
G->arcnum = 0;
}
}
}
}
void DisplayGraph(MGraph G)
{
int i, j;
cout << "有向图具有" << G.vexnum << "个顶点 " << G.arcnum << "条弧，顶点顶点依次是：" ;
for (i = 0; i < G.vexnum;++i)
{
cout << " " << G.vex[i];
}
cout << endl << "有向图G： " << endl;
cout << "顶点：";
for (i = 0; i < G.vexnum;i++)
{
cout << setw(4) << G.vex[i];
}
cout << endl;
for (i = 0; i < G.vexnum;i++)
{
cout << setw(6) << G.vex[i];
for (j = 0; j < G.vexnum;j++)
{
cout << setw(4) << G.arc[i][j].adj;
}
cout << endl;
}
}
void ConvertGraph(AdjGraph *A, MGraph M)
{
int i, j;
ArcNode *p;
A->vexnum = M.vexnum;
A->arcnum = M.arcnum;
A->kind = M.kind;
for (i = 0; i < A->vexnum;i++)
{
strcpy(A->vertex[i].data, M.vex[i]);
A->vertex[i].firstarc = NULL;
}
printf("请输入弧尾和弧头（以空格作为间隔）：\n");
for (i = 0; i < M.arcnum;i++)
{
for (j = 0; j < M.arcnum;j++)
{
if (M.arc[i][j].adj==1)
{
p = (ArcNode*)malloc(sizeof(ArcNode));
p->adjvex = j;
p->info = NULL;
p->nextarc = A->vertex[i].firstarc;
A->vertex[i].firstarc = p;
}
(*A).kind = DG;
}
}
}
void DisplayAdjGraph(AdjGraph G)
{
int i;
ArcNode *p;
cout << G.vexnum << "个顶点：" << endl;
for (i = 0; i < G.vexnum;i++)
{
cout << G.vertex[i].data << " ";
}
cout << endl << G.arcnum << "条边：" << endl;
for (i = 0; i < G.vexnum;i++)
{
p = G.vertex[i].firstarc;
while (p)
{
cout << G.vertex[i].data << "->"<<G.vertex[p->adjvex].data<<" ";
p = p->nextarc;
}
cout << endl;
}
}
（2）程序运行结果截图与说明
7005
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
