数据结构实验期末复习-矿大

已于 2023-12-06 19:35:01 修改
阅读量436 收藏 7
点赞数 1
文章标签： 数据结构 c++ 算法
于 2022-06-25 14:54:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64372178/article/details/125381242
版权

转圈圈

习题一：

题目描述：假如有一次班里组织户外活动，同学们随机围坐成一圈做游戏，每个同学都记住了左右同学的编号，活动结束后，老师想让你帮忙复原当时大家坐的位置，你能通过每个同学记录的左右同学的编号，把当时大家坐的一圈情况复原吗？

输入：

5
4 5
5 3
2 4
3 1
1 2
3

输出：3 2 5 1 4

#include<iostream>
using namespace std;
struct student//哈希表记录自身利用左右指针找下一个节点
{
	int left;
	int right;
}s[105];
int bn;
void output(int x)//递归 正向逆时针 输出顺时针
{
	if (x == bn)return;
	else
	{
		printf("%d ", x);
		output(s[x].left);
	}
}
int main()
{
	int num;
	cin >> num;
	for (int i = 1; i <= num; i++)
	{
		cin >> s[i].left >> s[i].right;
	}
	
	cin >> bn;
	printf("%d ", bn);
	output(s[bn].left);
	return 0;
}

栈的合法性

习题二：

题目描述：设栈S的初始状态为空，元素a, b, c, d, e, f, g 依次入栈，给你一个出栈序列，请编程判断出栈序列是否正确。

思路解析：https://www.bilibili.com/video/BV1CT4y1R7Z2?spm_id_from=333.880.my_history.page.click&vd_source=bfcf91eb1daac75f3364c0f74ac175a5

输入：

a b c d e f g

输出：

True

#include<iostream>
#include<queue>
#include<stack>
using namespace std;
char arr[] = { 'a','b','c','d','e','f','g' };//入栈序列
int main()
{
	queue<char> Q;
	stack<char> S;
	char temp;
	for (int i = 0; i < 7; i++)
	{
		cin >> temp;
		Q.push(temp);//将出栈序列入队
	}
	int tag=0;//用来访问入栈
	while ( !Q.empty() && S.size() < 7)
	{
		S.push(arr[tag++]);//入栈序列一次入栈
		while (!S.empty()&&!Q.empty()&&S.top() == Q.front())//当栈顶与队首相等弹出
		{
			Q.pop();
			S.pop();
		}
		if (tag == 7) break;
	}
	if (S.empty() && Q.empty())printf("True");//都为空才是正确
	else printf("False");
	return 0;

}

栈容量

习题三：

题目描述：设栈S的初始状态为空，元素a，b，c，d，e，f，g依次入栈，出栈顺序为b，d，c，f，e，a，g那么栈容量至少应该是3。如果任意给你一个出栈序列，你能编程判断相应的栈容量至少是多少吗？

思路解析：同上题一样不过设置一个栈尺寸的计数器，用于比较最大值

样例输入 

b d c f e a g

样例输出 

3
#include<iostream>
#include<queue>
#include<stack>
using namespace std;
char arr[] = { 'a','b','c','d','e','f','g' };
int main()
{
	queue<char> Q;
	stack<char> S;
	char temp;
	for (int i = 0; i < 7; i++)
	{
		cin >> temp;
		Q.push(temp);
	}
	int tag=0,maxSize=-1,sum=0;//设置一个表示栈尺寸的计数器
	while ( !Q.empty() && S.size() < 7)
	{
		
		S.push(arr[tag++]);
		sum++;//入栈尺寸++必须加完后再比
		if (sum > maxSize)maxSize = sum;//当栈的尺寸大于最大值时置换
		while (!S.empty()&&!Q.empty()&&S.top() == Q.front())
		{
			Q.pop();
			S.pop();
			sum--;//出栈尺寸--
		}

		
		if (tag == 7) break;
	}
	if (S.empty() && Q.empty())printf("%d",maxSize);
	else printf("False");
	return 0;

}

二叉搜索树的建立与查找

题目四：

题目描述：给你一个数据序列，请构造一个二叉搜索树，然后计算出找到给定数据需比较的次数。

输入：第一行是N，表示序列中数的个数，序列最长1000，第二行是一个数据序列，第三行是要找的数x。

5
1 2 3 5 4
5

输出：如果找到x，输出比较的次数，没找到则输出NO。

4
#include<iostream>
using namespace std;
struct edge
{
	int data;
	int left;
	int right;
}e[104];
int m,cnt=0;
void insert(int x)
{
	if (!cnt) {
		e[++cnt].data = x;
		e[cnt].left = -1;
		e[cnt].right = -1;//初始化结点
		return;
	}//第一个元素时
	int cur = 1;//当前结点
	while (cur <= cnt) {
		if (e[cur].data == x)return;//相同不插
		if (e[cur].data < x) {
			if (e[cur].right == -1) {//此时结点右边可插
				e[++cnt].data = x;
				e[cnt].left = -1;
				e[cnt].right = -1;//初始化结点
				e[cur].right = cnt;
				break;
			}
			else cur = e[cur].right;//继续向下找直到结点右边可插
		}
		else {
			if (e[cur].left == -1) {
				e[++cnt].data = x;
				e[cnt].left = -1;
				e[cnt].right = -1;
				e[cur].left = cnt;
				break;
			}
			else cur = e[cur].left;
		}
	}
}
int findpath(int t)
{
	int cur = 1,ans = 0;
	while (cur <= cnt && cur != -1)//全部结点找完或已经到叶子结点也没找到
	{
		ans++;
		if (e[cur].data == t) {	
			return ans;
		}
		if (e[cur].data < t) {
				cur = e[cur].right;
		}
		else {
			cur = e[cur].left;
		}	
	}
	return - 1;
}
int main()
{
	int temp;
	cin >> m;
	for (int i = 0; i < m; i++) {
		cin >> temp;
		insert(temp);
	}
	int target;
	cin >> target;
	int ans = findpath(target);
	if (ans == -1)printf("NO");
	else printf("%d", ans);
	return 0;
}

最短路径

题目五：

题目描述：有若干个节点，每个节点上都有编号，把这些节点随意地构成二叉树，请编程输出该二叉树的前序遍历序列。

输入：

4
1 2 4
3 1 -1
2 -1 -1
4 -1 -1

习题六：

题目描述：已知一个有向图，每个边都有一个正整数表示边长，请编程求出其中两个顶点间的最短路径长度。

dijkstra算法思想：大致84e3176000514865816360def92dd177.png

 final->visited   path->before

一：三个数组 visited dist before

87d481ba149e46c88e40c14ba887ca83.png

二：初始化visited dist before

0a234a41029542768f4539e1e463fc9c.png

三：

遍历每个顶点{

        找与原点相连的未访问的最小结点{

                更改与原点的最小距离{

                }

        }

} 

63bd063e9f4b42908eca83725aca2e2b.png

输入：

5 7
A B 10
B C 50
A E 100
A D 30
C E 10
D C 20
D E 60
A E

输出：

60

#include<iostream>
#include<stack>
using namespace std;
const int N = 104;
const int INF = 10000000;
int E[N][N],n ,m,dist[N];//dist表示起始点到每个节点的距离
char before[N];//到这个节点的前一个节点
bool visited[N];//标记已访问

void init(int u)//初始化 将能与原点联通的初始dist 将访问赋为false
{
	for (int i = 1; i <= n; i++) {
		dist[i] = E[u][i];
		visited[i] = false;
		if (dist[i] == INF) {//与原点不能联通
			before[i] = -1;
		}
		else {//能联通的前置结点赋为原点
			before[i] = u;
		}
	}
}
void Dij(int u)
{
	init(u);
	visited[u] = true;
	dist[u] = 0;
	for (int i = 1; i <= n; i++)//遍历到每一节点，遍历数与结点数相同
	{
		int min = INF, mintag = u;
		for (int j = 1; j <= n; j++)
		{
			if (!visited[j] && dist[j] < min) {
				min = dist[j];
				mintag = j;
			}
		}//每次找出最小的到原点路径的节点

		if (mintag == u)return;//找不到结点与原点联通
		visited[mintag] = true;//访问这个最小结点

		for (int j = 1; j <= n; j++) {//遍历每一个结点
			if (!visited[j] && E[mintag][j] < INF) {//在未访问的结点中能与mintag联通的
				if (dist[j] > (dist[mintag] + E[mintag][j])) {//如果原点到ta的直接距离大于经过mintag再到ta的距离就更新
					dist[j] = dist[mintag] + E[mintag][j];//原点到ta的路径更改为最小的
					before[j] = mintag;//ta的前置结点改为mintag
				}
			}
		}


	}
}
int main()
{
	cin >> n >> m;
	char temp1, temp2;
	int weight;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			E[i][j] = INF;
		}
	}//必须要初始化边为无穷，后面找最小结点要比较用
	for (int i = 1; i <= m; i++) {
		cin >> temp1 >> temp2 >> weight;
		E[temp1 - 'A' + 1][temp2 - 'A' + 1] = weight;
	}
	char begin, target;
	cin >> begin >> target;
	Dij(begin - 'A' + 1);
	printf("%d ", dist[target-'A'+1]);
	return 0;
}

最短路径遍历

习题七：

题目描述：已知一个有向图，每个边都有一个正整数表示边长，请编程求出其中两个顶点间的最短路径长度，相应两个顶点的最短路径经过的顶点序列。

思路解析：与上一题相似，不过加了个findpath函数

输入：

5 7
A B 10
B C 50
A E 100
A D 30
C E 10
D C 20
D E 60
A E

输出：

A D C E
#include<iostream>
using namespace std;
const int N = 104;
const int INF = 10000000;
int E[N][N], n, m, dist[N];
char before[N];
bool visited[N];
void init(int u)
{
	for (int i = 1; i <= n; i++) {
		visited[i] = false;
		dist[i] = E[u][i];
		if (dist[i] == INF) {
			before[i] = -1;
		}
		else before[i] = u;
	}
	before[u] = 0;
	visited[u] = true;
	dist[u] = 0;
}
void dji(int u)
{
	init(u);
	for (int i = 1; i <= n; i++) {
		int mintag = u, min = INF;
		for (int j = 1; j <= n; j++) {
			if (!visited[j] && dist[j] < min) {
				min = dist[j];
				mintag = j;
			}
		}
		if (mintag == u)return;
		visited[mintag] = true;
		for (int j = 1; j <= n; j++) {
			if (!visited[j] && E[mintag][j] < INF) {
				if (dist[j] > dist[mintag] + E[mintag][j]) {
					dist[j] = dist[mintag] + E[mintag][j];
					before[j] = mintag;
				}
			}
		}
	}
}
void findpath(int t)//增加一个寻找路径的递归函数，利用before将其串起来
{
	if (before[t] == -1) {//此点断了
		cout << "not found path" << endl;
		return;
	}
	if (before[t] == 0) {//找到了原点输出
		printf("%c ", t + 'A' - 1);
        return;
	}
	else {
		
		findpath(before[t]);//输出要在递归完后面才能前序输出
		printf("%c ", t + 'A' - 1);//通过改变这两句的顺序可以实现前序和后序输出
	}
}
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			E[i][j] = INF;
		}
	}
	char temp1, temp2;
	int weight;
	for (int i = 1; i <= m; i++) {
		cin >> temp1 >> temp2 >> weight;
		E[temp1-'A'+1][temp2-'A'+1] = weight;
	}
	char begin, target;
	cin >> begin >> target;
	dji(begin - 'A' + 1);
	findpath(target - 'A' + 1);
	return 0;
}

判断最小堆

习题八：题目描述：堆是以线性连续方式存储的完全二叉树，小根堆的每一个元素都不大于其左右孩子，现在给你n个完全二叉树数组存储序列，请编程判定相应完全二叉树数组存储序列是否为小根堆。

输入：

2
30 26 27 88
5 6 7 8 9 10

输出：

False
True
#include<iostream>
using namespace std;
int T[104];
bool check(int x, int m)//检查x结点是否满足小根堆的根更小原则
{
	int flag = true;
	if (2 * x + 1 <= m&&T[x]>T[2*x+1]) {//当时叶子结点时不满足不进
		flag = false;
	}
	if (2 * x <= m && T[x] > T[2 * x]) {
		flag = false;
	}
	return flag;
}
int main()
{
	int n,cnt=0;
	cin >> n;//输入流末尾是\n
	bool ans[104];
	for (int i = 0; i < n; i++)
	{
		bool flag = true;
		int cur = 2;
		cin >> T[1];//因此要先输入第一个数使输入流末尾是空格进入循环
		while (cin.get() != '\n') {//cin.get()取输入流末尾元素
			cin >> T[cur++];
		}
		for (int i = 1; i < cur; i++) {//循环每个检查一遍
			//printf("%d ", T[i]);
			if (!check(i, cur - 1)) {
				flag = false;
				break;
			}
		}
		if (flag)ans[cnt++] = true;
		else ans[cnt++] = false;
	}
	for (int i = 0; i < n; i++) {
		if (ans[i]) {
			printf("True\n");
		}
		else printf("False\n");
	}
}

输出最小堆的存储结构

习题九：现在给你n个结点的完全二叉树数组存储序列，请编程调整为最小堆，并输出相应最小堆的存储序列。

输入：

8
53 17 78 23 45 65 87 9

输出：

9 17 65 23 45 78 87 53
#include<iostream>
#include<queue>
using namespace std;
int arr[104];
void shiftdown(int x, int n)
{
	int temp = arr[x];
	int child = 2 * x;//child 表示更小的孩子
	while (child <= n) {//存在左孩子 
		if (child < n&&arr[child] > arr[child+1]) {//存在右孩子且右孩子更小
			child++;//将更小孩子表示为右孩子
		}
		if (temp > arr[child]) {//不符合就将更小的向上移必须用temp比
			arr[x] = arr[child];
			x = child;
			child = 2 * x;
		}
		else break;
		
	}
	arr[x] = temp;//小的上移后的空缺位置用起始的补上
}
int main()
{
	int n,temp;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> temp;
		arr[i] = temp;
	}
	for (int i = n / 2; i >= 1; i--) {
	//从最后分支结点开始向上调整因为右节点=2root+1,左节点2root;所以最后一个节点/2=root为它的根节点即最后节点
		shiftdown(i, n);
	}
	for (int i = 1; i <= n; i++) {
		printf("%d ", arr[i]);
	}
	return 0;

}

图的深度优先搜索

习题十：题目描述：已知一个无向图G的顶点和边，顶点从0依次编号，现在需要深度优先搜索，访问任一邻接顶点时编号小的顶点优先，请编程输出图G的深度优先搜索序列。

输入：第一行是整数m和n（1<m,n<100），分别代表顶点数和边数。后边n行，每行2个数，分别表示一个边的两个顶点。

5 5
0 1
2 0
1 3
1 4
4 2

输出：该图从0号顶点开始的深度优先搜索序列。

0 1 3 4 2
#include<iostream>
using namespace std;
bool v[104];
int e[104][104];
int m, n;
void dfs(int x)//深度优先搜索需要栈这里用了递归模拟栈
{
	if (x<0 || x>=m)return;//不符要求
	printf("%d ", x);//顺序在前
	for (int col = 0; col < m; col++) {//递归深入不通跳出来继续下一个
		if (!v[col] && e[x][col]) {
			v[col] = true;//通过标记访问可以保证同层全部访问
			dfs(col);
		}
	}
	return;
}
int main()
{
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < m; j++) {
			e[i][j] = 0;
		}
	}
	for (int i = 0; i < m; i++) {
		v[i] = false;
	}
	//初始化
	cin >> m >> n;
	int tmp1, tmp2;
	for (int i = 0; i < n; i++) {
		cin >> tmp1 >> tmp2;
		e[tmp1][tmp2] = e[tmp2][tmp1] = 1;
	}
	v[0] = true;
	dfs(0);
	return 0;
		
}

图的广度优先搜索

习题十一：

题目描述：已知一个无向图G的顶点和边，顶点从0依次编号，现在需要广度优先搜索，访问任一邻接顶点时编号小的顶点优先，请编程输出图G的广度优先搜索序列。

输入：第一行是整数m和n（1<m,n<100），分别代表顶点数和边数。后边n行，每行2个数，分别表示一个边的两个顶点。

5 5
0 1
2 0
1 3
1 4
4 2

输出：该图从0号顶点开始的广度优先搜索序列。

0 1 2 3 4
#include<iostream>
#include<queue>//图的广度优先搜索需要队列
using namespace std;
bool v[104];
int e[104][104];
int m, n;
void bfs(int x)
{
	printf("%d ", x);
	queue<int> Q;
	for (int i = 0; i < m; i++) {
		if (!v[i] && e[i][x]) {
			v[i] = true;
			Q.push(i);
		}
	}//第一层入队
	while (!Q.empty()) {
		for (int i = 0; i < m; i++) {
			if (!v[i] && e[i][Q.front()]) {
				v[i] = true;
				Q.push(i);
			}
		}//与当前结点相连的一次入队
		printf("%d ", Q.front());//输出该结点
		Q.pop();
	}
}
int main()
{
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < m; j++) {
			e[i][j] = 0;
		}
	}
	for (int i = 0; i < m; i++) {
		v[i] = false;
	}
	//初始化
	cin >> m >> n;
	int tmp1, tmp2;
	for (int i = 0; i < n; i++) {
		cin >> tmp1 >> tmp2;
		e[tmp1][tmp2] = e[tmp2][tmp1] = 1;
	}
	v[0] = true;
	bfs(0);
	return 0;
		
}

最小生成树

题目十二：

题目描述：已知一个无向图G的顶点和边，顶点从0依次编号，请编程输出图G的最小生成树对应的边权之和。

输入：第一行是整数m和n（1<m,n<100），分别代表顶点数和边数。后边n行，每行3个数，分别表示一个边的两个顶点和该边的权值。

4 5
0 1 6
0 2 9
2 1 12
1 3 10
3 2 3

输出：最小生成树对应的边权之和。

#include<iostream>
#include<algorithm>
using namespace std;
struct edge
{
	int l, r;
	int w;
}e[104];
int n, m;
int f[104];
bool cmp(edge x, edge y)
{
	return x.w < y.w;
}
void init()//并查集初始化祖宗
{
	for (int i = 1; i <= n; i++) {
		f[i] = i;
	}
}
int find(int x)//找祖宗
{
	if (x == f[x]) return x;
	return f[x] = find(f[x]);
}

int kruskal()
{
	int ans = 0, cnt = 0;
	init();
	sort(e + 1, e + m +1, cmp);//对边进行排序注意是m+1表示边
	
	for (int i = 1; i <= m; i++) {//遍历每一个边
		if (cnt == n - 1)break;//当所有顶点已访问就结束(边数>结点数)正常提前break
		int lp = find(e[i].l);
		int rp = find(e[i].r);
		if (lp != rp ) {//判断是否是同一个祖宗即保证不构成回路
			f[find(lp)] = find(rp);//并查集的合并
			ans += e[i].w;
			cnt++;//已加入结点加一
		}
	}
	if (cnt != n-1) {
		return 0;//边全部访问完结点却未全部加入
	}
	return ans;
}
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= m; i++) {
		cin >> e[i].l >> e[i].r >> e[i].w;
	}
	int ans = kruskal();
	if (ans)printf("%d",ans);
	else printf("NO");
	return 0;
}

ˇasushiro
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
中国矿业大学-数据结构试题及答案.pdf
02-03
中国矿业大学-数据结构试题及答案.pdf
完全二叉树与堆的转换
薯条和番茄酱的博客
01-28 699
1.实际上是一种完全二叉树，且某个节点的值总是不大于或者不小于其父节点的值（分别称为最大堆、最小堆）。2.jdk1.8中优先级队列 PriorityQueue，底层即采用堆的数据结构存储，具有返回优先级最高的对象，添加新的对象的最基本操作。3.堆底层使用数组实现（顺序存储），使用堆总是完全二叉树，这样不会出现数组中间出现 null 的情况。
【笔试】春招秋招技术岗笔试必考题归纳总结
Sig的博客
03-18 4286
目录一、数据结构必考1. 排序算法1）什么时候用什么排序算法类2） 排序算法的稳定性3）排序算法的时间复杂度&空间复杂度2. 二叉树1）二叉树的三种遍历2）二叉树结点计算问题3）图的遍历与二叉树遍历4）平衡二叉树5）满二叉树与完全二叉树6）完全二叉树的深度3. 出栈顺序已知入栈序列，判断出栈顺序是否合理4. 散列表1）线性探测法2）链地址法5. 数组地址计算6. 二分法查找7. 广义表二、计算机网络必考1. 各层的协议及设备2. 各协议名称及端口号3. 单工通信/半双工通信/全双工通信三、数据库必考
二叉树的层次遍历 小根堆的判定和构造 图的深度和广度优先搜索 最小生成树
qq_44343213的博客
06-16 894
二叉树的层次遍历 小根堆的判定和构造 图的深度和广度优先搜索 最小生成树
最小堆 / 优先队列（C语言实现）
Jymn_Chen
04-17 1万+
最近找实习，复习下数据结构方面的内容：用C语言实现最小堆/优先队列。并通过最小堆求解查找第k大元素的问题。
二叉树 最小堆
学习，记录，总结 的专栏
12-07 922
堆的最小堆化，插入，删除 /**************** 算法5.12 堆的类定义和筛选法 **********************/ #include using namespace std; #define FALSE 0 #define TRUE 1 template class MinHeap //最小堆类定义 { p
数据结构试题及答案1.pdf
05-11
数据结构试题及答案1.pdf
Python-矿大哆点网络路由器自动登陆教程
08-10
矿大哆点网络路由器自动登陆教程
数据结构课设，包括五个实验，亲测可用
08-17
数据结构课设，包括二叉树、中缀转后缀等五个文件，矿大专属
矿大2004年《电路理论》期末试题（信科）.pdf-教程与笔记习题
05-19
矿大2004年《电路理论》期末试题（信科）.pdf
带权图最短路（C语言实现）
07-13
使用C语言实现对于带权图最短路的求解，经测试能够正确求解带权图的最短路问题，使用编程语言求解图论中的经典问题。
试设计一个算法，求图中一个源点到其他各顶点的最短路径
05-27
试设计一个算法，求图中一个源点到其他各顶点的最短路径。 （1）用邻接表表示图； （2）按长度非递减次序打印输出最短路径的长度及相应路径。
Floyd算法，求有向图中各顶点之间的最短路径及其长度
09-30
用Floyd算法实现求有向图中各顶点之间的最短路径及其长度
将二叉树转化成最大堆或最小堆
weixin_42894327的博客
09-08 4396
将二叉树转化成最大堆或最小堆： 最大堆： 1.堆树是一颗完全二叉树 2.父节点总是大于或等于他的孩子节点 3.堆树中每个节点的子树都是堆树。 最小堆的转化同理。 ...
java完全二叉树最小堆_Java实现最小堆一
weixin_32304785的博客
03-02 444
Java实现最小堆一堆是一种经过排序的完全二叉树，其中任一非终端节点的数据值均不大于(或不小于)其左孩子和右孩子节点的值。最大堆和最小堆是二叉堆的两种形式。最大堆：根结点的键值是所有堆结点键值中最大者。最小堆：根结点的键值是所有堆结点键值中最小者。就像下面这棵树一样。 这棵二叉树有一个特点，就是所有父结点都比子结点要小(注意：圆圈里面的数是值，圆圈上面的数是这个结点的编号，此规定仅适用于本节)。符...
图解二叉堆（最小堆&最大堆）
august5291的博客
11-03 1265
二叉堆 二叉堆是一颗完全二叉树，该树中的某个节点的值总是不大于(不小于)其左右子节点的值，包括最小堆和最大堆。可以通过下图理解，为什么会使用数组来保存呢？因为利用完全二叉树的性质，我们可以通过数组来表示完全二叉树(数组下标与完全二叉树节点存在映射关系，比如父节点可以通过Math.floor((index-1)/2)来获取、左子节点可以通过2index+1来获取、右子节点可以通过2index+2来获取，从而简化了实现及开销，避免使用额外的指针来实现树结构。 最小堆 最小(大)堆性质 树根节
c++笔试题
热门推荐
snwang_miss的博客
10-25 1万+
微软亚 微软亚洲技术中心的面试题！！！ 1．进程和线程的差别。 线程是指进程内的一个执行单元,也是进程内的可调度实体. 与进程的区别: (1)调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位 (2)并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行 (3)拥有资源：进程是拥有资源的独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源.
习题整理12.19
aaacome的博客
12-20 1283
3.如果使用比较高效的算法判断单链表有没有环的算法中，至少需要几个指针？ 解析：快慢指针法，判断链表有没有环，可以用快慢指针来实现，两指针的移动速度不一样。如果相遇，则表示有环，否则表示无环 5.对于一个具有n个顶点的无向图，若采用邻接矩阵表示，则该矩阵的大小是（） 解析：无向图的邻接矩阵是一个对称矩阵等同于一个二维数组，数组的大小为n2，一般用一个长度为N(N+1)/2的1维数组可以节省空间 8.在有向图 G 的拓扑序列中，若顶点 Vi 在顶点 Vj 之前，则下列情形不可能出现的是（）。 拓扑排序，
矿 第三次数据结构实验
yueazero的博客
06-16 1997
堆是以线性连续方式存储的完全二叉树，小根堆的每一个元素都不大于其左右孩子，现在给你n个完全二叉树数组存储序列，请编程判定相应完全二叉树数组存储序列是否为小根堆。已知一个无向图G的顶点和边，顶点从0依次编号，现在需要深度优先搜索，访问任一邻接顶点时编号小的顶点优先，请编程输出图G的深度优先搜索序列。已知一个无向图G的顶点和边，顶点从0依次编号，现在需要广度优先搜索，访问任一邻接顶点时编号小的顶点优先，请编程输出图G的广度优先搜索序列。后边n行，每行3个数，分别表示一个边的两个顶点和该边的权值。
计算机网络期末复习（矿大版）
最新发布
08-27
4. 网络层：了解 IP 地址的结构和分类，了解 IPv4 和 IPv6 的区别。掌握 IP 数据报的格式和分片重组过程。 5. 传输层：了解传输层协议 TCP 和 UDP 的特点和应用场景。掌握 TCP 的三次握手和四次挥手过程，了解流量...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ˇasushiro

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值