西工大数据结构实验期末复习

已于 2024-06-23 10:34:35 修改
阅读量218 收藏 4
点赞数 6
文章标签： 数据结构
于 2024-06-22 22:31:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Panda8qaq/article/details/139881019
版权

我也不知道题库，但是听说挺简单的，所以就自己想到一些题型可能会考到~

1_合并有序数组

直接用数组实现，他也管不了我用不用链表。

#include <stdio.h>

int seq1[20];
int seq2[20];
int seq3[40];
int m, n;

void readdata();
void merge();
void printseq3();

int main(){
	readdata();
	merge();
	printseq3();
	return 0;
}

void readdata(){
	scanf("%d", &n);
	for(int i = 0; i < n; i++){
		scanf("%d", &seq1[i]);
	}
	scanf("%d", &m);
	for (int i = 0; i < m; i++){
		scanf("%d", &seq2[i]);
	}
}

void merge(){
	int i = 0, j = 0, k = 0;
	while(i < n && j < m){
		if (seq1[i] < seq2[j]){
			seq3[k] = seq1[i];
			i++;
			k++;
		}
		else{
			seq3[k] = seq2[j];
			j++;
			k++;
		}
	}
	while (i < n){
		seq3[k] = seq1[i];
		i++;
		k++;
	}
	while (j < m){
		seq3[k] = seq2[j];
		k++;
		j++;
	}
	return;
}

void printseq3(){
	for (int i = 0; i < m+n-1; i++){
		printf("%d\n", seq3[i]);
	}
	printf("%d", seq3[m+n-1]);
}

2_排序类

排序都用快排实现。

#include <stdio.h>

#define MAXSIZE 10000

void readdata();
int sort(int seq[], int left, int right);
void quicksort(int seq[], int left, int right);
void print(int seq[]);

int seq[MAXSIZE];
int length;

int main(){
	readdata();
	quicksort(seq, 0, length-1);
	print(seq);
}
void readdata(){
	scanf("%d", &length);
	for (int i = 0; i < length; i++){
		scanf("%d", &seq[i]);
	}
}

int sort(int seq[], int left, int right){
	int i = left; 
	int j = right; 
	int tmp = seq[i];
	while (i != j){
		while (i < j && tmp <= seq[j]){
			j--;
		}
		seq[i] = seq[j];
		while (i < j && tmp >= seq[i]){
			i++;
		}
		seq[j] = seq[i];
	}
	seq[i] = tmp;
	return i;
}

void quicksort(int seq[], int left, int right){
	if (left < right){
		int i = sort(seq, left, right);
		quicksort(seq, left, i-1);
		quicksort(seq, i+1, right);
	}
}

void print(int seq[]){
	for (int i = 0; i < length; i++){
		printf("%d", seq[i]);
	}
}

3_三元组实现稀疏矩阵转置

按理来说需要限制一下行和列的数组溢出，但是我不管，他肯定不会给超出的测试用例（我们小镇做题家是这样的）

#include <stdio.h>
#define MAXSIZE 20

int matrix[20][3];
int n, m;

void readdata(){
	scanf("%d %d", &n, &m);
	int i = 0;
	while (1){
		scanf("%d %d %d", &matrix[i][0], &matrix[i][1], &matrix[i][2]);
		if (matrix[i][0] == 0 && matrix[i][1] == 0 && matrix[i][2] == 0){
			break;
		}
		i++;
	}
}

void transpose(int matrix[20][3]){
	int i = 0;
	while (1){
		int tmp = matrix[i][1];
		matrix[i][1] = matrix[i][2];
		matrix[i][2] = tmp;
		if (matrix[i][0] == 0 && matrix[i][1] == 0 && matrix[i][2] == 0){
			break;
		}
		i++;
	}
}

void printmatrix(int mat[20][3]){
	int i = 0;
	while(1){
		printf("%d %d %d\n", mat[i][0], mat[i][1], mat[i][2]);
		if (mat[i][0] == 0 && mat[i][1] == 0 && mat[i][2] == 0){
			break;
		}
		i++;
	}
}

int main(){
	readdata();
	transpose(matrix);
	printmatrix(matrix);
	return 0;
}

4_二分查找有序数组元素

要记住中间一点细节：

1.不用像快排那样用函数递归调用来解，只用写一个while循环语句，再实时更新left & right的值就可以了。再有一个while的条件一定要是left<=right，否则会出问题。

#include <stdio.h>
#define MAXSIZE 10000

int seq[MAXSIZE];
int length;
int des_num;

void readdata(){
	scanf("%d", &length);
	for (int i = 0; i < length; i++){
		scanf("%d", &seq[i]);
	}
	scanf("%d", &des_num);
} 

int bisearch(int seq[], int des, int length){
	int left = 0;
	int right = length-1;
	while(left <= right){//left <= right 是必须的，否则导致输出错误 
		int mid = (left + right)/2;
		if (seq[mid] == des){
			return mid;
		}
		else if (des > seq[mid]){
			left = mid+1;
		}
		else if (des < seq[mid]){
			right = mid-1;
		}
	}
	return -1;
}

int main(){
	readdata();
	int i = bisearch(seq, des_num, length);
	printf("%d", i+1);
}

5_Floyd算法求任意两点的最短路径

哎不是哥们，数据结构实验考试应该不会对时间卡的太死吧~我就只学这个啦！哈哈啊哈！floyd真是比迪基简单好多呢！

#include <stdio.h>
#define MAXSIZE 100
#define INF 10000

int Node_num;
int dist[MAXSIZE][MAXSIZE];

void readdata(){
	scanf("%d", &Node_num);
	for (int i = 0; i < Node_num; i++){
		for (int j = 0; j < Node_num; j++){
			scanf("%d", &dist[i][j]);
		}
	}
}

void floyd(int dist[MAXSIZE][MAXSIZE]){
	for (int k = 0; k < Node_num; k++){
		for (int j = 0; j < Node_num; j++){
			for (int i = 0; i < Node_num; i++){
				if (dist[j][i] > dist[j][k]+dist[k][i]){
					dist[j][i] = dist[j][k]+dist[k][i];
				}
			}
		}
	}
}

void print(int dist[MAXSIZE][MAXSIZE]){
	for (int i = 0; i < Node_num; i++){
		for (int j = 0; j < Node_num; j++){
			printf("%d ", dist[i][j]);
		}
		printf("\n"); 
	}
}

int main(){
	readdata();
	floyd(dist);
	print(dist);
}

6_栈的基本操作（可以用来混分嘻嘻^ ^）

#include<stdio.h>
#define MAXSIZE 10000

typedef struct Stack{
	int num[];
	int top;
}Stack;

void init(Stack *s){
	s->top = -1;
}

int isEmpty(Stack *s){
	return s->top == -1;
}

int isFull(Stack *s){
	return s->top == MAXSIZE-1;
}

void push(Stack *s, char x){
	if (isFull(s)){
		return;
	}
	else{
		s->num[++s->top] = x;
	}
}

char pop(Stack *s){
	if (isEmpty(s)){
		return;
	}
	else{
		return s->num[--s->top];
	}
}

char getTop(Stack *s){
	if (isEmpty(s)){
		return;
	}
	else{
		return s->num[s->top];
	}
}

7_括号匹配问题

#include <stdio.h>
#include <stdlib.h> // 用于 malloc
#include <stdbool.h> // 用于 bool 类型

#define MAXSIZE 10000

typedef struct Stack {
    char num[MAXSIZE]; // 固定大小数组
    int top;
} Stack;

void init(Stack *s) {
    s->top = -1;
}

int isEmpty(Stack *s) {
    return s->top == -1;
}

int isFull(Stack *s) {
    return s->top == MAXSIZE - 1;
}

void push(Stack *s, char x) {
    if (isFull(s)) {
        return;
    }
    else {
        s->num[++s->top] = x;  //++,--的前后顺序不能错 
    }
}

char pop(Stack *s) {
    if (isEmpty(s)) {
        return -1;
    }
    else {
        return s->num[s->top--];
    }
}

char getTop(Stack *s) {
    if (isEmpty(s)) {
        return -1;
    }
    else {
        return s->num[s->top];
    }
}

void readdata(char expression[MAXSIZE]) {
    int i = 0;
    char ch;
    while ((ch = getchar()) != '\n' && ch != EOF) {
        expression[i++] = ch;
    }
    expression[i] = '\0';
}

bool isMatched(char left, char right) {
    return (left == '(' && right == ')') || 
           (left == '[' && right == ']') || 
           (left == '{' && right == '}');
}

bool legal(char expression[MAXSIZE]) {
    Stack s;
    init(&s);
    for (int i = 0; expression[i] != '\0'; i++) {
        if (expression[i] == '(' || expression[i] == '[' || expression[i] == '{') {
            push(&s, expression[i]);
        }
        else if (expression[i] == ')' || expression[i] == ']' || expression[i] == '}') {
            if (isEmpty(&s) || !isMatched(pop(&s), expression[i])) {
                return false;
            }
        }
    }
    return isEmpty(&s);
}

int main() {
    char expression[MAXSIZE];
    readdata(expression);
    if (legal(expression)) {
        printf("yes\n");
    }
    else {
        printf("no\n");
    }
    return 0;
}

8_dfs

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10000

int start_Node, end_Node;
typedef struct Graph{
	int Node_num;
	int Edge_num;
	int mat[MAXSIZE][MAXSIZE];
}Graph;

void readdata(Graph *p){
	scanf("%d %d", &p->Node_num, &p->Edge_num);
	int vi, vj;
	for (int i = 0; i < p->Edge_num; i++){
		scanf("%d %d", &vi, &vj);
		p->mat[vi][vj] = 1;
	}
	scanf("%d %d", &start_Node, &end_Node);
}

int dfs(Graph *p, int beginning){
	if (beginning == end_Node){ //不用分成两种情况，如果不是就直接将判断交给后面的递归 
		return 1;
	}
	for (int i = 0; i < p->Node_num; i++){
		if (p->mat[beginning][i] == 1){
//				dfs(p,i);
				if (dfs(p,i)){
					return 1; //需要将返回值递归到调用栈的最顶层 
				}
			}
		}
	return 0;
}

int main(){
	Graph *p = (Graph *)malloc(sizeof(Graph));
	readdata(p);
	int isConnected = dfs(p, start_Node);
	if (isConnected){
		printf("yes");
	}
	else{
		printf("no");
	}
	free(p);
	return 0;
}

是雬可落儿呀
关注
西工大数据结构实验第一题
mss965的博客
02-07 115
西工大数据结构作业
数据结构实验复习
qq_41486817的博客
07-05 264
1 顺序建立链表题目描述输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。输入第一行输入整数的个数N；第二行依次输入每个整数。输出输出这组整数。示例输入8 12 56 4 6 55 15 33 62示例输出12 56 4 6 55 15 33 62#include&lt;stdio.h&gt; #include&lt;iostream&gt; using namesp...
西工大2022数据结构期末备考记录
a15735748145a的博客
07-13 2136
西工大2022数据结构期末备考记录
西北工业大学算法设计与分析期末考试复习资料汇总
Linaiii的博客
11-05 3684
算法设计与分析实验考试复习 理论题 1.算法的基本概念，性质及其与程序的联系与区别 算法：算法是指解决问题的一系列计算步骤，是解决方案准确而完整的描述。 算法的基本性质： 输入性：有零个或多个外部量作为算法的输入。 输出性：算法产生至少一个量作为输出。 确定性：组成算法的每条指令必须是清晰的，无二义性的。 有限性：算法中指令的执行次数有限和执行的时间有限。 可行性：算法中每一条运算都必须足够基本，能够精确的执行。 程序：是算法用某种设计语言的具体实现，程序可以不满足算法的有限性。 2.算法的复杂性，如何
西北工业大学数据结构实验报告
07-12
包含11次数据结构实验报告以及配套代码，结构完整，符合要求，实验成绩97分。 啰嗦几句： 更加建议大家自己写，我这个更多的是自己的资源存档 有问题的话私信，看到会回复 关于代码，因为当时比较仓促，还没有进行...
西工大-数据结构期末复习资料.pdf
05-26
西工大-数据结构期末复习资料.pdf
西北工业大学数据结构noj_1-6题
04-27
在“西北工业大学数据结构noj_1-6题”中，我们可以推测这是一系列与数据结构相关的编程练习题目，旨在帮助学生理解和应用各种数据结构。以下是基于这些题目可能涵盖的一些关键知识点的详细解释： 1. **线性数据结构...
西北工业大学数据结构历届考题
06-29
在“西北工业大学数据结构历届考题”中，我们可以找到一系列针对这门课程的考试题目，这对于正在准备考试的西工大学生来说是非常宝贵的资源。 数据结构主要包括数组、链表、栈、队列、树、图、哈希表等多种类型。...
西北工业大学 操作系统期末复习
06-28
西北工业大学的操作系统期末复习要点可以从以下几个方面进行详细梳理： 1. 操作系统的四大组成部分： - 进程管理：涉及进程的概念、进程状态及其转换、线程概念及区别、进程线程联系、进程调度、同步互斥、死锁...
【数据结构】线段树复杂应用
2302_80811345的博客
09-13 1069
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的 IPv6 协议，虽然有2128级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称 IPxxaf。在 IPxxaf 协议中，一个地址由n位二进制位组成，其中。
数据结构---非线性--树
2301_80434764的博客
09-13 805
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
【数据结构】顺序表的定义和实现
m0_74209563的博客
09-13 578
顺序表是指用的方式实现线性表顺序存储：把的元素存储在的存储单元中，元素之间的关系由存储单元的邻接关系来体现【看到这是否会和我有同样的疑问：顺序表和数组是一样的吗？这个问题可以参考这篇文章的解释】
重头开始嵌入式第三十九天（数据结构 栈）
qq_64792908的博客
09-13 766
栈是一种数据结构，它具有以下特点：1. 只能在一端进行插入和删除操作，这一端被称为栈顶。2. 遵循“后进先出”（Last In First Out，LIFO）的原则。也就是说，最后进入栈的元素最先被弹出。3. 可以用数组或链表来实现。例如，把书一本一本叠放在桌子上，只能从最上面取书或放书，这就类似栈的操作。后放上去的书先被拿走，符合“后进先出”原则。
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
BamBoo_Bean的博客
09-13 655
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
Java-数据结构-二叉树-基础 (oﾟ▽ﾟ)o
2303_80388948的博客
09-12 936
OK，到这里呢，我们的二叉树基础就到这里就结束了，我们接下来看看关于二叉树的相关的习题，并且在题中我们会看见我们 二叉树的创建方法。让我们期待下次的博客吧！！！拜拜啦~~~
数据结构——栈和队列（队列的定义、顺序队列以及链式队列的基本操作）
weixin_74209413的博客
09-13 1191
队列和栈一样，也是限定只能在表的“端点”进行的线性表。队列在插入的时候，只能在表尾进行插入，在删除的时候，只能在表头进行删除。（先进先出），表尾即队尾，表头即队头。栈和队列是线性表的子集（是插入和删除位置受限的线性表）由于队列的操作具有先进先出的特性，使得队列成为程序设计中解决类似排队问题的有用工具。队列的逻辑结构与同线性表相同，仍为一对一关系。队列的存储结构有顺序队和链队，以循环顺序队列更常见。关键是掌握入队和出队操作，具体实现依顺序队或链队的不同而不同。
数据结构—顺序表
最新发布
2301_80151359的博客
09-15 499
线性表是一种在实际中广泛使用的数据结构，线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。
《征服数据结构》滚动数组
数据结构和算法
09-12 293
摘要：1，一维滚动数组的介绍2，多维滚动数组的介绍1，一维滚动数组的介绍滚动数组不是一种数据结构，它是一种算法优化思想，滚动数组的作用在于优化空间，降低空间复杂度，每次使用固定的一些存储空间。比如我们常见的斐波那契数列：f[n] = f[n – 1] + f[n – 2] ，普通的写法如下：Java 代码：//1、2、3、5、8、13、21、34、…… privateintfibonacci...
西北工大软件学院计算机视觉期末复习要点解析
"该资源是针对西北工业大学软件学院计算机视觉课程的期末复习材料，涵盖了从基础知识到关键概念的梳理，旨在帮助学生准备考试。" 在计算机视觉领域，学习者需要理解的基本概念包括： 1. 计算机视觉的定义：它是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值