华科研究生复试机试题代码堆积供以后参考

最新推荐文章于 2022-12-11 10:48:42 发布

物联网小镇

最新推荐文章于 2022-12-11 10:48:42 发布

阅读量127

点赞数

分类专栏：编程初学

本文链接：https://blog.csdn.net/qq_41476542/article/details/106068659

版权

编程初学专栏收录该内容

51 篇文章 3 订阅

订阅专栏

#include "stdafx.h"
#include <cstdio>
#include <cstring>
using namespace std;

#define MaxSize 50
char str[MaxSize];

int main()
{
	// 测试
	// 正常情况：|hello world a.  
	// 边界情况：|a.
	// 异常情况(不考虑多个'.'和'.'与最后一个单词离开）
	// 扩展性良好的思路：先根据空格‘分割’字符串，然后数每个char[]中的字符数量并打印
	// 一般思路：边识别边统计字符
	while (fgets(str,MaxSize,stdin))
	{
		bool IsInWord = false;  //判断是否在单词里
		int count = 0;  //统计每个单词的字符数
		int length = strlen(str);
		for (int i = 0;i < length;++i)
		{
			// 当在单词中碰到空格、字符或'.'的情况时
			if (IsInWord)
			{
				if (' ' == str[i]) // 空格
				{
					printf("%d ", count);
					IsInWord = true;
					count = 0;
				}
				else if ('.' == str[i])  // 结束（但无法确保只有'.'）
				{
					printf("%d\n", count);

				}
				else  // 字符
				{
					count++;
				}
			}
			else  // 不在单词中
			{
				// 遇到字符，即开始一个单词
				if (str[i] != ' ')  // 遇到字符
				{
					count++;
					IsInWord = true;
				}
				
			}

		}
	}
    return 0;
}

// BST.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
//#include "stdio.h"

struct  BST
{
	BST* leftChild;
	BST* rightChild;
	BST* parent;
	int data;
};

// BST插入操作:root为BST的根节点，data要插入的数值，node为新插入的节点并返回
bool insert(BST* root, int data, BST** node)
 {
	// 0.处理异常情况
	if (root == NULL)
	{
		return false;
	}

	// 1.循环找到插入位置
	BST* tmp = root;
	BST* parent = root;
	bool isRight = true;
	while (tmp)
	{
		parent = tmp;  //记录下父节点

		// 比较data大小决定往哪走
		if (data > tmp->data)  //往右走
		{
			tmp = tmp->rightChild;
			isRight = true;
		}
		else  //不然，向左走
		{
			tmp = tmp->leftChild;
			isRight = false;
		}

	}

	// 跳出来，说明到插入位置了，开始插入节点
	BST* insertNode = new BST;
	insertNode->data = data;
	insertNode->rightChild = insertNode->leftChild = NULL;
	insertNode->parent = parent;
	if (isRight)  //插入右边
		parent->rightChild = insertNode;
	else  //插入左边
		parent->leftChild = insertNode;
	*node = insertNode;  // 返回该节点

	return true;
}

int main()
{
	//测试
	//正常情况
	//边界情况：一个节点
	//异常情况:null指针
	int NodeNumbers;
	BST* root=NULL;
	int data;
	while (scanf("%d", &NodeNumbers))
	{
		// 输入数字
		for (int i = 0;i < NodeNumbers;++i)
		{
			scanf("%d", &data);

			// 处理第一个节点
			if (i == 0)
			{
				root = new BST;
				root->data = data;
				root->leftChild = root->rightChild = root->parent= NULL;
				printf("%d\n", -1);
			}
			else
			{
				BST* node=NULL;
				if (insert(root, data, &node))
				{
					//插入成功后，打印父亲节点的数值
					printf("%d\n", node->parent->data);
				}
			}
		}

		// 存在内存泄漏，没有delete掉那些new 出来的内存，考试中为了速度不用考虑
	}

	
    return 0;
}

// InversionOfMatrix.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <cstdio>
#include <cstdlib>
#include <algorithm>
using namespace std;

#define MaxSize 50

bool inverse(int matrix[][MaxSize], int dimension)
{
	// 0.异常情况处理
	if (matrix == NULL || dimension <= 0)
		return false;
	// 1.核心部分
	for(int i=1;i<dimension;++i)
		for (int j = 0;j < i;++j)
		{
			swap(matrix[i][j], matrix[j][i]);
		}
	return true;
}

int matrix[MaxSize][MaxSize];

int main()
{
	// 测试
	// 正常情况

	// 异常情况

	// 边界情况：1*1
	int dimension;
	while (scanf("%d", &dimension))
	{
		for (int i = 0;i < dimension;++i)
			for (int j = 0;j < dimension;++j)
				scanf("%d", &matrix[i][j]);

		// 转置
		if (inverse(matrix, dimension))
		{
			// 打印结果
			for (int i = 0;i<dimension;++i)
				for (int j = 0;j < dimension;++j)
				{
					if (j == dimension - 1)
						printf("%d\n", matrix[i][j]);
					else
						printf("%d ", matrix[i][j]);

				}
		}
		
	}
    return 0;
}

#include "stdafx.h"
#include <cstdio>
#include <cstring>
#include <cstdlib>
using namespace std;

#define MaxSize 50
char result[MaxSize][MaxSize];
char str[MaxSize];
// 一个简单的splitString函数，依据char分割由char紧密连接的string。
// 如：255.255.255.255中的'.' 或者 hello world you 中的空格。
bool splitString(char str[], int length, char Reg, char result[][MaxSize])
{
	// 0.异常情况处理
	if (str == NULL || result == NULL||length<=0)
		return false;
	// 1.核心部分
	char* source = str;
	int count = 0,num=0;  // count计数，num表示在result中存放字符串的顺序
	for (int i = 0;i < length;++i)
	{
		// 根据当前是不是分隔符来划分字符串
		if (str[i] == Reg||i==length-1)
		{
			// 把前面的字符串复制到result中
			memcpy(result[num], source, count);
			result[num][count+1] = '\0';
			// count重新计数,num\source移位
			source += count+1;
			count = 0;
			num++;
		}
		else
		{
			// count计数
			count++;
		}
	}
	return true;
}

bool IsRight(char str[], int length)
{
	// 0.异常情况处理
	if (str == NULL || length <= 0)
		return false;
	// 将字符串转换成数值，进行比较 
	int data = atoi(str);
	if (data >= 0 && data <= 255)
		return true;
	else
		return false;
}

int main()
{
	// 测试
	// 正常情况 256.2.1.1
	// 边界情况 
	// 异常情况
	while (fgets(str, MaxSize, stdin))
	{
		int length = strlen(str);
		bool isRight = true;
		if (splitString(str, length, '.', result))
		{
			for (int i = 0;i < 4;i++)
			{
				length = strlen(result[i]);
				if (!IsRight(result[i], length))
				{
					isRight = false;
					break;
				}
			}
		}
		if(isRight)
			printf("%s\n", "Yes!");
		else
			printf("%s\n", "No!");
	}
    return 0;
}

在这里插入代码片
// sort.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "stdlib.h"
#include "time.h"
// 快速排序
// 一次分配过程
void Swap(int* a, int *b)
{
	int c;
	c = *b;
	*b = *a;
	*a = c;
}

int Partition(int* data, int start, int end)
{
	// 0.处理异常情况
	/*if (data == NULL || start > end)
		return ;*/
	// 1.核心部分
	/and(time(NULL));  //种子
	//int index = rand() % (end - start) + start;
	//Swap(&data[index], &data[start]);
	int i = start, j = end, tmp = data[start];
	while (i < j)
	{
		while (i < j&&tmp < data[j]) j--;
		if (i < j)
		{
			data[i]=data[j];
			i++;
		}
		while (i<j&&tmp>data[i]) i++;
		if (i < j)
		{
			data[j] = data[i];
			j--;
		}
	}
	data[i] = tmp;
	return i;
}

void qsort(int* data, int start, int end)
{
	// 0.处理异常情况
	if (data == NULL || start > end)
		return;
	// 1.核心部分
	int index = Partition(data, start, end);
	if (index > start)
		qsort(data, start, index-1);
	if (index < end)
		qsort(data, index+1, end);
}

// 归并排序
int data[100];
int main()
{
	// 测试
	// 正常情况
	// 边界情况
	// 异常情况
	int n;
	while (scanf("%d", &n))
	{
		for (int i = 0;i < n;i++)
			scanf("%d", &data[i]);
		qsort(data, 0, n - 1);
		for (int i = 0;i < n;i++)
		{
			if (i == n - 1)
				printf("%d\n", data[i]);
			else
				printf("%d ", data[i]);

		}
	}
    return 0;
}

在这里插入代码片
初学者 2020/5/12 9:08:01
// sort.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "stdlib.h"
#include "time.h"
// 快速排序
// 一次分配过程
void Swap(int* a, int *b)
{
	int c;
	c = *b;
	*b = *a;
	*a = c;
}

int Partition(int* data, int start, int end)
{
	// 0.处理异常情况
	/*if (data == NULL || start > end)
		return ;*/
	// 1.核心部分
	/and(time(NULL));  //种子
	//int index = rand() % (end - start) + start;
	//Swap(&data[index], &data[start]);
	int i = start, j = end, tmp = data[start];
	while (i < j)
	{
		while (i < j&&tmp < data[j]) j--;
		if (i < j)
		{
			data[i]=data[j];
			i++;
		}
		while (i<j&&tmp>data[i]) i++;
		if (i < j)
		{
			data[j] = data[i];
			j--;
		}
	}
	data[i] = tmp;
	return i;
}

void qsort(int* data, int start, int end)
{
	// 0.处理异常情况
	if (data == NULL || start > end)
		return;
	// 1.核心部分
	int index = Partition(data, start, end);
	if (index > start)
		qsort(data, start, index-1);
	if (index < end)
		qsort(data, index+1, end);
}

// 归并排序
int data[100];
int main()
{
	// 测试
	// 正常情况
	// 边界情况
	// 异常情况
	int n;
	while (scanf("%d", &n))
	{
		for (int i = 0;i < n;i++)
			scanf("%d", &data[i]);
		qsort(data, 0, n - 1);
		for (int i = 0;i < n;i++)
		{
			if (i == n - 1)
				printf("%d\n", data[i]);
			else
				printf("%d ", data[i]);

		}
	}
    return 0;
}

初学者 2020/5/12 9:08:39
// SpecialSort.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"

void Swap(int* a, int* b)
{
	int c;
	c = *b;
	*b = *a;
	*a = c;
}

// 堆排序
void adjustHeap(int *data, int node, int length)  //调整堆 
{
	int lchild = 2 * node + 1;       //i的左孩子节点序号 
	int rchild = 2 * node + 2;     //i的右孩子节点序号 
	int parent = node;
	while (lchild <= length-1)  //左孩子在堆里
	{
		if (rchild <= length-1)  //若右孩子也在堆里
		{
			if (data[rchild] > data[lchild])  //左孩子比右孩子小
			{
				// 右孩子与父亲节点比较
				if (data[parent] < data[rchild])
				{
					Swap(&data[parent], &data[rchild]);
					parent = rchild;
					lchild = parent * 2 + 1;
					rchild = parent * 2 + 2;
					continue;
				}
				else
					break;
			}
		}
		if (data[lchild] > data[parent]) //左孩子大于父亲节点
		{
			Swap(&data[lchild], &data[parent]);
			parent = lchild;
			lchild = parent * 2 + 1;
			rchild = parent * 2 + 2;
		}
		else
			break;
	}
}

void buildHeap(int *data, int length)    //建堆 
{
	for (int i = length / 2 - 1;i >= 0;i--)    //非叶节点最大序号值为length/2 - 1 
	{
		adjustHeap(data, i, length);
	}
}

void HeapSort(int *data, int length)    //堆排序 
{
	// 0.异常情况
	if (data == NULL || length <= 0)
		return;
	int i;
	// 建堆
	buildHeap(data, length);
	// 调整堆顶元素，并进行堆调整
	for (i = length-1;i >= 1;i--)
	{
		Swap(&data[0], &data[i]);    //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面 
		adjustHeap(data, 0, i);      //重新调整堆顶节点成为大顶堆
	}
}

int data[1000];

int main()
{
	// 测试
	// 正常情况
	// 边界情况
	// 异常情况
	int n;
	while (scanf("%d", &n))
	{
		for (int i = 0;i < n;i++)
			scanf("%d", &data[i]);
		HeapSort(data, n);  //堆排序
		printf("%d\n", data[n - 1]);
		for (int i = 0;i < n-1;i++)
		{
			if (i == n - 2)
			{ 
				printf("%d\n", data[i]);
				break;
			}
			printf("%d ", data[i]);

		}
	}
    return 0;
}

物联网小镇

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
华科研究生复试机试题代码堆积供以后参考

题目描述对N个长度最长可达到1000的数进行排序。输入描述:输入第一行为一个整数N，(1<=N<=100)。接下来的N行每行有一个数，数的长度范围为1<=len<=1000。每个数都是一个正数，并且保证不包含前缀零。输出描述:可能有多组测试数据，对于每组数据，将给出的N个数从小到大进行排序，输出排序后的结果，每个数占一行。示例1输入复制31111111111111111111111111111122222222222222222222222222222222
复制链接

扫一扫