DS二叉树—二叉树构建与遍历（不含框架）
给定一颗二叉树的逻辑结构如下图，（先序遍历的结果，空树用字符‘#’表示，例如AB#C##D##），建立该二叉树的二叉链式存储结构，并输出该二叉树的先序遍历、中序遍历和后序遍历结果。
输入：
第一行输入一个整数t，表示有t个二叉树
第二行起输入每个二叉树的先序遍历结果，空树用字符‘#’表示，连续输入t行。
输出：
输出每个二叉树的先序遍历、中序遍历和后序遍历结果。
#include <iostream>
using namespace std;
class bitnode
{
public:
char data;
bitnode* left; //左孩子
bitnode* right; //右孩子
};
class tree
{
public:
bitnode* root;
void create(bitnode*& p) //创建树
{
char a;
cin >> a;
if (a != '#')
{
p = new bitnode;
p->data = a;
create(p->left);
create(p->right);
}
else
{
p = NULL;
}
}
void show(bitnode* p)
{
if (p)
{
cout << p->data;
show(p->left);
show(p->right);
}
}
void show2(bitnode* p)
{
if (p)
{
show2(p->left);
cout << p->data;
show2(p->right);
}
}
void show3(bitnode* p)
{
if (p)
{
show3(p->left);
show3(p->right);
cout << p->data;
}
}
};
int main()
{
int t;
cin >> t;
while (t--)
{
tree mytree;
mytree.create(mytree.root);
mytree.show(mytree.root);
cout << endl;
mytree.show2(mytree.root);
cout << endl;
mytree.show3(mytree.root);
cout << endl;
}
}DS二叉树—二叉树结点的最大距离
二叉树两个结点的距离是一个结点经过双亲结点，祖先结点等中间结点到达另一个结点经过的分支数。二叉树结点的最大距离是所有结点间距离的最大值。例如，下图所示二叉树结点最大距离是3，C和D的距离。
二叉树用先序遍历顺序创建，#表示空树。计算二叉树结点最大距离和最大距离的两个结点(假设二叉树中取最大距离的两个结点唯一）。
输入：
测试次数T
第2行之后的T行，每行为一棵二叉树先序遍历结果（#表示空树）
输出：
对每棵二叉树，输出树的结点最大距离和最大距离的结点，输出格式见样例。
#include <iostream>
#include<math.h>
using namespace std;
class bitnode
{
public:
char data;
char a,b;
bitnode* left;
bitnode* right;
int leftd=0,rightd=0;
};
class bittree
{
private:
int maxs=-999;
char a,b;
public:
bitnode* root;
void create()
{
create(root);
}
void create(bitnode*&p)
{
char w;
cin >> w;
if (w!='#')
{
p = new bitnode;
p->data=p->a=p->b=w;
create(p->left);
create(p->right);
}
else
{
p = NULL;
}
}
int geth(bitnode*p)
{
if(p==NULL)
{
return 0;
}
return max(geth(p->left),geth(p->right))+1;
}
void show()
{
find(root);
cout<<maxs<<":";
if(maxs)
{
cout<<a<<" "<<b<<endl;
}
else
{
cout<<endl;
}
}
void find(bitnode* p)
{
if (p == NULL)
{
return ;
}
if(p->left==NULL)
{
p->leftd=0;
}
if(p->right==NULL)
{
p->rightd=0;
}
if(p->left)
{
find(p->left);
p->leftd=max(p->left->leftd,p->left->rightd)+1;
}
if(p->right)
{
find(p->right);
p->rightd=max(p->right->leftd,p->right->rightd)+1;
}
if(maxs<(p->leftd+p->rightd))
{
if(p->left)
a=getl(p->left);
else a=p->data;
if(p->right)
b=getl(p->right);
else b=p->data;
}
maxs=max(maxs,p->leftd+p->rightd);
}
char getl(bitnode*p)
{
if(p->left==NULL&&p->right==NULL)
{
return p->data;
}
if(p->left==NULL)
{
return getl(p->right);
}
if(p->right==NULL)
{
return getl(p->left);
}
if(geth(p->left)>geth(p->right))
{
return getl(p->left);
}
return getl(p->right);
}
};
int main()
{
int t;
cin >> t;
while (t--)
{
bittree mytree;
mytree.create();
mytree.show();
}
}DS图—图的邻接矩阵存储及度计算
假设图用邻接矩阵存储。输入图的顶点信息和边信息，完成邻接矩阵的设置，并计算各顶点的入度、出度和度，并输出图中的孤立点（度为0的顶点）
--程序要求--
若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio
程序中若include多过一个头文件，不看代码，作0分处理
不允许使用第三方对象或函数实现本题的要求
输入：
测试次数T，每组测试数据格式如下：
图类型 顶点数 （D—有向图，U—无向图）
顶点信息
边数
每行一条边（顶点1 顶点2）或弧（弧尾 弧头）信息
输出：
每组测试数据输出如下信息（具体输出格式见样例）：
图的邻接矩阵
按顶点信息输出各顶点的度（无向图）或各顶点的出度 入度 度（有向图）。孤立点的度信息不输出。
图的孤立点。若没有孤立点，不输出任何信息。
#include<iostream>
#define maxlen 20
using namespace std;
class map
{
private:
int **mat;//邻接矩阵
int n;
char **vertex;
int d[maxlen][2];//度
char type;
public:
void create(char w,int num)
{
n=num;//设置顶点数
type=w;//设置有向图/无向图
for(int i=0;i<maxlen;i++)//初始化
{
for(int j=0;j<2;j++)
{
d[i][j]=0;
}
}
mat=new int *[n];
vertex=new char *[n];
for(int i=0;i<n;i++)//初始化
{
vertex[i]=new char[maxlen];
mat[i]=new int[n];
for(int j=0;j<n;j++)
{
mat[i][j]=0;
}
for(int j=0;j<maxlen;j++)
vertex[i][j]=0;
}
for(int i=0;i<n;i++)
{
cin>>vertex[i];
}
int s;//边数
cin>>s;
while(s--)
{
if(type=='U')
{
uinsert();
}
else if(type=='D')
{
dinsert();
}
}
}
int find(char *a)
{
int i,j,flag;
for(i=0;i<n;i++)
{
flag=1;
for(j=0;j<10;j++)
{
if(vertex[i][j]!=a[j])
{
flag=0;
break;
}
}
if(flag==1)
{
return i;
}
}
return 0;
}
void uinsert()//无向图
{
char a[maxlen]={0},b[maxlen]={0};
cin>>a>>b;
int x,y;
x=find(a);
y=find(b);
mat[x][y]=1;//邻接矩阵图
mat[y][x]=1;
d[x][0]++;
d[y][0]++;
}
void dinsert()//有向图
{
char a[maxlen]={0},b[maxlen]={0};
cin>>a>>b;
int x,y;
x=find(a);
y=find(b);
mat[x][y]=1;
d[x][0]++;//x出度+1
d[y][1]++;//y出度+1
}
void print()
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(j==n-1)
{
cout<<mat[i][j];
}
else
{
cout<<mat[i][j]<<" ";
}
}
cout<<endl;
}
for(int i=0;i<n;i++)
{
cout<<vertex[i];//名字
if(type=='D')//有向图
{
if(d[i][0]||d[i][1])
{
cout<<": "<<d[i][0]<<" "<<d[i][1]<<" "<<d[i][0]+d[i][1];
}
}
else if(type=='U')//无向图
{
if(d[i][0])
{
cout<<": "<<d[i][0];
}
}
cout<<endl;
}
}
};
int main()
{
int t,n;
char w;
cin>>t;
while(t--)
{
cin>>w>>n;
map M;
M.create(w,n);
M.print();
}
return 0;
}DS图遍历--深度优先搜索
给出一个图的邻接矩阵，对图进行深度优先搜索，从顶点0开始
注意：图n个顶点编号从0到n-1
代码框架如下：
输入：
第一行输入t，表示有t个测试实例
第二行输入n，表示第1个图有n个结点
第三行起，每行输入邻接矩阵的一行，以此类推输入n行
第i个结点与其他结点如果相连则为1，无连接则为0，数据之间用空格隔开
以此类推输入下一个示例
输出：
每行输出一个图的深度优先搜索结果，结点编号之间用空格隔开
#include <iostream>
using namespace std;
const int maxlen = 20; //设定图最多有20个顶点
class map
{
private:
bool visit[maxlen]; //访问标志数组，标识每个顶点是否已访问
int matrix[maxlen][maxlen]; //图的邻接矩阵
int vexnum; //图的顶点数量
void dfs(int v);
public:
void setmatrix(int vnum, int mx[maxlen][maxlen]) //设置邻接矩阵
{
int i, j;
vexnum = vnum; //设置结点数
for (i = 0; i < maxlen; i++)
{
for (j = 0; j < maxlen; j++)
{
matrix[i][j] = 0; //初始化为0
}
}
for (i = 0; i < vexnum; i++)
{
for (j = 0; j < vexnum; j++)
{
matrix[i][j] = mx[i][j]; //矩阵初始化
}
}
}
//共有函数被main调用,对图作深度优先遍历
void dfstraverse()
{
int v;
for (int i = 0; i < vexnum; i++)
{
visit[i] = false;
}
for (v = 0; v < vexnum; v++)
{
if (visit[v] == false)
{
dfs(v); //如果该顶点未访问，则调用dfs访问
}
}
}
};
//深度优先搜索
void map::dfs(int v) //从第v个结点出发递归深度遍历图
{
int w, i, k;
visit[v] = true; //先访问v顶点
cout << v << " ";
int* adjvex = new int[vexnum]; //存放v顶点连接的顶点
for (i = 0; i < vexnum; i++)
{
adjvex[i] = -1; //数组初始化
}
k = 0; //k是数组adjvex空位置下标
for (i = 0; i < vexnum; i++)
{
//如果顶点i与顶点v相连接，则邻接矩阵第v行第i个位置的值为1
if (matrix[v][i] == 1)
{
adjvex[k] = i;
k++;
}
}
i = 0;
while (w != -1)
{
w = adjvex[i];
if (visit[w] == false)
{
dfs(w);
}
i++;
if(adjvex[i]==-1)
{
break;
}
}
delete[]adjvex;
}
int main()
{
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
int p[maxlen][maxlen];
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> p[i][j];
}
}
map g;
g.setmatrix(n, p);
g.dfstraverse();
cout << endl;
}
}DS图遍历--广度优先搜索
给出一个图的邻接矩阵，对图进行深度优先搜索，从顶点0开始
注意：图n个顶点编号从0到n-1
代码框架如下：
输入：
第一行输入t，表示有t个测试实例
第二行输入n，表示第1个图有n个结点
第三行起，每行输入邻接矩阵的一行，以此类推输入n行
第i个结点与其他结点如果相连则为1，无连接则为0，数据之间用空格隔开
以此类推输入下一个示例
输出：
每行输出一个图的广度优先搜索结果，结点编号之间用空格隔开
#include <iostream>
#include<queue>
using namespace std;
const int maxlen = 20; //设定图最多有20个顶点
class map
{
private:
bool visit[maxlen]; //访问标志数组，标识每个顶点是否已访问
int matrix[maxlen][maxlen]; //图的邻接矩阵
int vexnum; //图的顶点数量
void bfs(int v);
public:
void setmatrix(int vnum, int mx[maxlen][maxlen]) //设置邻接矩阵
{
int i, j;
vexnum = vnum; //设置结点数
for (i = 0; i < maxlen; i++)
{
for (j = 0; j < maxlen; j++)
{
matrix[i][j] = 0; //初始化为0
}
}
for (i = 0; i < vexnum; i++)
{
for (j = 0; j < vexnum; j++)
{
matrix[i][j] = mx[i][j]; //矩阵初始化
}
}
}
//共有函数被main调用,对图作广度优先遍历
void bfstraverse()
{
bfs(0);
}
};
//广度优先搜索
void map::bfs(int v) //v是当前结点
{
int w,u,i, k;
int* adjvex = new int[vexnum]; //存放v顶点连接的顶点
queue<int>q;
for (i = 0; i < vexnum; i++)
{
visit[i] = false;
}
for (v = 0; v < vexnum; ++v)
{
if (!visit[v])
{
visit[v] = true;
q.push(v);
while (!q.empty())
{
u = q.front();
cout << u << " ";
q.pop();
for (k = 0; k < vexnum; k++)
{
if (matrix[u][k] == 1 && visit[k] == 0)
{
q.push(k);
visit[k] = true;
}
else
continue;
}
}
}
}
cout << endl;
}
int main()
{
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
int p[maxlen][maxlen];
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> p[i][j];
}
}
map g;
g.setmatrix(n, p);
g.bfstraverse();
}
}图的应用之——图的连通
给定一个图的邻接矩阵，请判断该图是否是连通图。连通图：任意两个顶点之间都有路径。
--程序要求--
若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio
程序中若include多过一个头文件，不看代码，作0分处理
不允许使用第三方对象或函数实现本题的要求
输入：
第1行输入一个整数k，表示有k个测试数据
第2行输入一个整数n，表示有n个结点
从第3行起到第n+2行输入一个邻接矩阵，其中Matrix[i,j]=1表示第i，j个结点之间有边，否则不存在边。
接下来是第2到第k个测试数据的结点数和邻接矩阵
输出：
输出Yes or No表示图是否是强连通图
#include <iostream>
using namespace std;
const int maxlen = 20; //设定图最多有20个顶点
class map
{
private:
bool visit[maxlen]; //访问标志数组，标识每个顶点是否已访问
int matrix[maxlen][maxlen]; //图的邻接矩阵
int vexnum; //图的顶点数量
void dfs(int v);
public:
void setmatrix(int vnum, int mx[maxlen][maxlen]) //设置邻接矩阵
{
int i, j;
vexnum = vnum; //设置结点数
for (i = 0; i < maxlen; i++)
{
for (j = 0; j < maxlen; j++)
{
matrix[i][j] = 0; //初始化为0
}
}
for (i = 0; i < vexnum; i++)
{
for (j = 0; j < vexnum; j++)
{
matrix[i][j] = mx[i][j]; //矩阵初始化
}
}
}
void setvisit()
{
for(int i=0;i<vexnum;i++)
{
visit[i]=false;
}
}
void display()
{
int flag=0;
for(int i=0;i<vexnum;i++)
{
setvisit();
visit[i]=true;
dfs(i);
for(int j=0;j<vexnum;j++)
{
if(visit[j]==false)
{
flag=1;
break;
}
}
if(flag==1)
{
break;
}
}
if(flag==1)
{
cout<<"No"<<endl;
}
else
{
cout<<"Yes"<<endl;
}
}
};
//深度优先搜索
void map::dfs(int v) //从第v个结点出发递归深度遍历图
{
int w, i, k;
visit[v] = true; //先访问v顶点
int* adjvex = new int[vexnum]; //存放v顶点连接的顶点
for (i = 0; i < vexnum; i++)
{
adjvex[i] = -1; //数组初始化
}
k = 0; //k是数组adjvex空位置下标
for (i = 0; i < vexnum; i++)
{
//如果顶点i与顶点v相连接，则邻接矩阵第v行第i个位置的值为1
if (matrix[v][i] == 1)
{
adjvex[k] = i;
k++;
}
}
i = 0;
while (w != -1)
{
w = adjvex[i];
if (visit[w] == false)
{
dfs(w);
}
i++;
if(adjvex[i]==-1)
{
break;
}
}
delete[]adjvex;
}
int main()
{
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
int p[maxlen][maxlen];
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> p[i][j];
}
}
map g;
g.setmatrix(n, p);
g.display();
}
}DS图—最小生成树
根据输入创建无向网。分别用Prim算法和Kruskal算法构建最小生成树。（假设：输入数据的最小生成树唯一。）
输入：
顶点数n
n个顶点
边数m
m条边信息,格式为：顶点1 顶点2 权值
Prim算法的起点v
输出：
输出最小生成树的权值之和
对两种算法，按树的生长顺序，输出边信息(Kruskal中边顶点按数组序号升序输出)
#include<iostream>
#include<algorithm>
using namespace std;
class map
{
private:
int vexnum; //顶点数
string *p;
int **matrix; //邻接矩阵
int arcnum; //边数
bool *visit;
public:
map()
{
cin>>vexnum;
p = new string[vexnum];
for(int i=0;i<vexnum;i++)
{
cin>>p[i];
}
matrix = new int*[vexnum];
for(int i=0;i<vexnum;i++)
{
matrix[i] = new int[vexnum];
}
for(int i=0;i<vexnum;i++)
{
for(int j=0;j<vexnum;j++)
{
matrix[i][j] = 10000;
}
}
cin>>arcnum;
int a=0,b=0,number=0;
for(int i=0;i<arcnum;i++)
{
string s1,s2;
cin>>s1>>s2>>number;
for(int j=0;j<vexnum;j++)
{
if(s1==p[j])
{
a=j;
}
if(s2==p[j])
{
b=j;
}
}
matrix[a][b] = number;
matrix[b][a] = number;
}
visit = new bool[vexnum];
}
void Prim(string start)
{
string *s1 = new string[101];
string *s2 = new string[101];
int *q = new int[101];
int p1=0,p2=0,p3=0;
int count=0,pos=0;
for(int i=0;i<vexnum;i++)
{
visit[i] = false;
if(start==p[i])
{
pos=i;
}
}
visit[pos] = true;
int *w = new int[vexnum];
int a=0,b=0;
while(1)
{
int min=10000;
for(int j=0;j<vexnum;j++)
{
if(visit[j])
{
pos=j;
for(int i=0;i<vexnum;i++)
{
if(matrix[pos][i]<min&&visit[i] == false&&i!=pos)
{
a=i;
b=pos;
min=matrix[pos][i];
}
}
}
}
visit[a] = true;
s1[p1++]=p[b];
s2[p2++]=p[a];
w[p3++] = min;
count +=min;
int flag=0;
for(int i=0;i<vexnum;i++)
if(visit[i]==false)
{
flag=1;
break;
}
else
{
flag=0;
}
if(flag==0)
{
break;
}
}
cout<<count<<endl;
cout<<"prim:"<<endl;
for(int i=0;i<p1;i++)
{
cout<<s1[i]<<" "<<s2[i]<<" "<<w[i]<<endl;
}
}
void Kruskal();
};
void map::Kruskal()
{
cout<<"kruskal:"<<endl;
int *visit = new int[vexnum];
for(int i=0;i<vexnum;i++)
{
visit[i] = i;
}
int find[101];
for(int i=0;i<100;i++)
{
find[i] = 10000;
}
int p3=0;
for(int i=0;i<vexnum;i++)
{
for(int j=0;j<=i;j++)
{
if(matrix[i][j]!=10000)
find[p3++] = matrix[i][j];
}
}
sort(find,find+p3);
for(int k=0;k<p3;k++)
{
for(int i=0;i<vexnum;i++)
for(int j=0;j<vexnum;j++)
{
if(matrix[i][j] ==find[k] && visit[i] != visit[j])
{
for(int p=0;p<vexnum;p++)
{
if(visit[p] == visit[j]&&p!=i&&p!=j)
{
visit[p] = visit[i];
}
}
visit[j] = visit[i];
cout<<p[i]<<" "<<p[j]<<" "<<find[k]<<endl;
}
}
}
}
int main()
{
map m;
string start;
cin>>start;
m.Prim(start);
m.Kruskal();
return 0;
}图综合练习--拓扑排序
已知有向图，顶点从0开始编号，求它的求拓扑有序序列。
拓扑排序算法：给出有向图邻接矩阵
1.逐列扫描矩阵，找出入度为0且编号最小的顶点v
2.输出v，并标识v已访问
3.把矩阵第v行全清0
重复上述步骤，直到所有顶点输出为止
--程序要求--
若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio
程序中若include多过一个头文件，不看代码，作0分处理
不允许使用第三方对象或函数实现本题的要求
输入
第一行输入一个整数t，表示有t个有向图
第二行输入n，表示图有n个顶点
第三行起，输入n行整数，表示图对应的邻接矩阵
以此类推输入下一个图的顶点数和邻接矩阵
输出
每行输出一个图的拓扑有序序列
#include <iostream>
using namespace std;
class map
{
private:
int vexnum; //顶点数
int** matrix;
public:
map()
{
cin >> vexnum ;
matrix = new int* [vexnum];
for (int i = 0; i < vexnum; i++)
{
matrix[i] = new int[vexnum];
}
for (int i = 0; i < vexnum; i++)
{
for (int j = 0; j < vexnum; j++)
{
matrix[i][j] = 0;
}
}
for (int i = 0; i < vexnum; i++)
{
for (int j = 0; j < vexnum; j++)
{
cin>>matrix[i][j];
}
}
}
void top()
{
int t = vexnum;
int flag = 0;
while (t--)
{
for (int j = 0; j < vexnum; j++)
{
flag = 0;
if (matrix[j][j] == 0) //如果未输出过该顶点j
{
for (int i = 0; i < vexnum; i++)
{
if (matrix[i][j] != 0)
{
flag = 1; //入度不为0
}
}
if (flag == 0)
{
cout << j << " ";
for (int k = 0; k < vexnum; k++)
{
matrix[j][k] = 0;
}
matrix[j][j] = 1; //输出过则标记为1
}
}
}
}
cout << endl;
}
};
int main()
{
int t;
cin >> t;
while (t--)
{
map mymap;
mymap.top();
}
}DS图—图的最短路径（不含代码框架）
给出一个图的邻接矩阵，输入顶点v，用迪杰斯特拉算法求顶点v到其它顶点的最短路径。
注：不允许用STL实现。
输入
第一行输入t，表示有t个测试实例
第二行输入顶点数n和n个顶点信息
第三行起，每行输入邻接矩阵的一行，以此类推输入n行
第i个结点与其它结点如果相连则为距离，无连接则为0，数据之间用空格
隔开。第四行输入v0，表示求v0到其他顶点的最短路径距离
以此类推输入下一个示例
输出
对每组测试数据，输出：
每行输出v0到某个顶点的最短距离和最短路径
每行格式：v0编号-其他顶点编号-最短路径值----[最短路径]。没有路径输出：v0编号-其他顶点编号--1。具体请参考示范数据
输入：
2
5 0 1 2 3 4
0 5 0 7 15
0 0 5 0 0
0 0 0 0 1
0 0 2 0 0
0 0 0 0 0
0
6 V0 V1 V2 V3 V4 V5
0 0 10 0 30 100
0 0 5 0 0 0
0 0 0 50 0 0
0 0 0 0 0 10
0 0 0 20 0 60
0 0 0 0 0 0
V0
输出：
0-1-5----[0 1 ]
0-2-9----[0 3 2 ]
0-3-7----[0 3 ]
0-4-10----[0 3 2 4 ]
V0-V1--1
V0-V2-10----[V0 V2 ]
V0-V3-50----[V0 V4 V3 ]
V0-V4-30----[V0 V4 ]
V0-V5-60----[V0 V4 V3 V5 ]
#include<iostream>
#define max 10000
using namespace std;
class map
{
private:
int vexnum; //顶点数
string *p;
int **matrix; //邻接矩阵
string start;
string *q;
public:
map()
{
cin>>vexnum;
p = new string[vexnum];
for(int i=0;i<vexnum;i++)
{
cin>>p[i];
}
q=new string[vexnum];
matrix = new int*[vexnum];
for(int i=0;i<vexnum;i++)
{
matrix[i] = new int[vexnum];
}
for(int i=0;i<vexnum;i++)
{
for(int j=0;j<vexnum;j++)
{
matrix[i][j] = 0;
}
}
for(int i=0;i<vexnum;i++)
{
for(int j=0;j<vexnum;j++)
{
cin>>matrix[i][j];
if(matrix[i][j]==0)
{
matrix[i][j]=max;
}
}
}
cin>>start;
}
int find(string a)
{
for(int i=0;i<vexnum;i++)
{
if(a==p[i])
{
return i;
}
}
return -1;
}
void dijstra()
{
bool visit[vexnum];
int path[20][20]; //能走的路径
int dis[vexnum];
int index=find(start);
for(int i=0;i<vexnum;i++)
{
visit[i]=0;
dis[i]=matrix[index][i];
q[i]=start+" ";
for(int j=0;j<vexnum;j++)
{
path[i][j]=0;
}
if(dis[i]<max)
{
path[i][index]=1;
path[i][i]=1;
}
}
dis[index]=0;
visit[index]=1;
int min;
for(int i=1;i<vexnum;i++)
{
min=max;
int flag=-1;
for(int j=0;j<vexnum;j++)
{
if(!visit[j])
{
if(dis[j]<min)
{
flag=j;
min=dis[j];
}
}
}
if(flag!=-1)
{
visit[flag]=1;
q[flag]+=p[flag]+" ";
for(int k=0;k<vexnum;k++)
{
if(visit[k]==0&&min+matrix[flag][k]<dis[k])
{
dis[k]=min+matrix[flag][k];
q[k]=q[flag];
}
}
}
}
for(int i=1;i<vexnum;i++)
{
cout<<p[0]<<"-"<<p[i];
if(dis[i]>=max)
{
cout<<"--1"<<endl;
continue;
}
cout<<"-"<<dis[i]<<"----["<<q[i]<<"]"<<endl;
}
}
};
int main()
{
int t;
cin>>t;
while(t--)
{
map p;
p.dijstra();
}
}DS静态查找之折半查找
给出一个队列和要查找的数值，找出数值在队列中的位置，队列位置从1开始
要求使用折半查找算法
输入：
第一行输入n，表示队列有n个数据
第二行输入n个数据，都是正整数，用空格隔开
第三行输入t，表示有t个要查找的数值
第四行起，输入t个数值，输入t行
输出：
每行输出一个要查找的数值在队列的位置，如果查找不成功，输出字符串error
#include<iostream>
using namespace std;
int main()
{
int n;
cin>>n;
int data[n];
for(int i=1;i<=n;i++)
{
cin>>data[i];
}
int t;
cin>>t;
while(t--)
{
int da,flag=0;
cin>>da;
int start=1,end=n;
int mid;
while(start<=end)
{
mid=(start+end)/2;
if(data[mid]>da)
{
end=mid-1;
}
else if(data[mid]<da)
{
start=mid+1;
}
else
{
cout<<mid<<endl;
flag=1;
break;
}
}
if(flag==0)
{
cout<<"error"<<endl;
}
}
}DS静态查找之顺序索引查找
给出一个队列和要查找的数值，找出数值在队列中的位置，队列位置从1开始
要求使用顺序索引查找算法，其中索引表查找和块内查找都采用不带哨兵、从头开始的顺序查找方法。
输入
第一行输入n，表示主表有n个数据
第二行输入n个数据，都是正整数，用空格隔开
第三行输入k，表示主表划分为k个块，k也是索引表的长度
第四行输入k个数据，表示索引表中每个块的最大值
第五行输入t，表示有t个要查找的数值
第六行起，输入t个数值，输入t行
输出
每行输出一个要查找的数值在队列的位置和查找次数，数据之间用短划线隔开，如果查找不成功，输出字符串error
#include<iostream>
using namespace std;
int main()
{
int n;
cin>>n;
int data[n];
for(int i=1;i<=n;i++)
{
cin>>data[i];
}
int k;
cin>>k;
int list[k];
for(int i=1;i<=k;i++)
{
cin>>list[i];
}
int t;
cin>>t;
while(t--)
{
int da,flag=0,count=0;
int pos=0;
cin>>da;
for(int i=1;i<=k;i++)
{
if(da<=list[i])
{
pos=i;
break;
}
count++;
}
for(int i=(pos-1)*n/k;i<=n/k*pos;i++)
{
count++;
if(data[i]==da)
{
cout<<i<<"-";
flag=1;
break;
}
if(i==n/k*pos)
{
cout<<"error"<<endl;
flag=0;
}
}
if(flag==1)
{
cout<<count<<endl;
}
}
}
475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
