计算机考研复试机试-考前速记

news2025/3/26 19:49:46

考前速记 知识点

1. 链表篇
1. 循环链表报数3，输出最后一个报数编号
#include <iostream>
using namespace std;

typedef struct Node {
	int no;
	struct Node* next;
}Node, *NodeList;

void createNodeListTail(NodeList&L, int n) {
	L = (Node*)malloc(sizeof(Node));
	L->no = -1;
	L->next = NULL;
	Node* tail = L;
	for (int i = 0; i < n; i++) {
		Node* x = (Node*)malloc(sizeof(Node));
		x->no = (i + 1);
		x->next = NULL;
		tail->next = x;
		tail = x;
	}
	tail->next = L->next; // 形成循环链表
	return;
}

int main() {
	int n;
	cin >> n;
	NodeList L;
	createNodeListTail(L, n);
	Node* pre = L; // 记录退出序号的前驱
	Node *p = pre->next;
	int LastNo = -1; // 记录每次退出的序号
	int count = 0; // 记录删除的结点个数
	while (count < n) {
		int i = 1;
		while (i < 3) {
			pre = p;
			p = p->next;
			i++;
		}
		Node* q = p; // 出队
		LastNo = q->no;
		pre->next = q->next;
		p = pre->next;
		free(q);
		count++;
	}
	cout << LastNo << endl;
	return 0;
}
2. 链表基本操作
#include <iostream>
#include <vector>
using namespace std;

typedef struct LNode {
	int data;
	struct LNode* next;
}LNode, *LinkList;

// 头插法建立链表
void createLinkListHead(LinkList &L, int n) {
	L = (LNode*)malloc(sizeof(LNode));
	L->data = -1;
	L->next = NULL;
	for (int i = 0; i < n; i++) {
		int data;
		cin >> data;
		LNode* x = (LNode*)malloc(sizeof(LNode));
		x->data = data;
		x->next = L->next;
		L->next = x;
	}
}

// 删除第n个位置的元素
bool deleteN(LinkList& L, int n) {
	int count = 1;
	LNode* pre = L;
	LNode* p = pre->next;
	while (p) {
		if (count == n) {
			LNode* q = p;
			pre->next = q->next;
			p = pre->next;
			free(q);
			cout << "delete OK" << endl;
			return true;
		}
		else {
			pre = pre->next;
			p = p->next;
		}
		count++;
	}
	cout << "delete fail" << endl;
	return false;
}

// 输出第n个位置元素
bool getN(LinkList L, int n) {
	int count = 1;
	LNode* p = L->next;
	while (p) {
		if (count == n) {
			cout << p->data << endl;
			return true;
		}
		p = p->next;
		count++;
	}
	cout << "get fail" << endl;
	return false;
}

// 在第n个元素之后插入元素
bool insertBeforePOSN(LinkList& L, int pos, int data) {
	int count = 1;
	LNode* pre = L;
	LNode* p = pre->next;
	LNode* x = (LNode*)malloc(sizeof(LNode));
	if (p == NULL && pos == 1) { // 处理空链表插入
		x->data = data;
		x->next = NULL;
		L->next = x;
		cout << "insert OK" << endl;
		return true;
	}
	while (p) {
		if (count == pos) {
			x->data = data;
			x->next = p;
			pre->next = x;
			cout << "insert OK" << endl;
			return true;
		}
		else {
			pre = p;
			p = pre->next;
		}
		count++;
	}
	cout << "insert fail" << endl;
	return false;
}

// 输出L
void showL(LinkList L) {
	LNode* p = L->next;
	if (p == NULL) {
		cout << "Link list is empty" << endl;
		return;
	}
	while (p) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
	return;
}

int main() {
	int n;
	cin >> n;
	LinkList L = (LNode*)malloc(sizeof(LNode));
	createLinkListHead(L, n);
	
	int m;
	cin >> m;
	vector<string> op(m);
	vector<int> param1(m);
	vector<int> param2(m);
	for (int i = 0; i < m; i++) {
		cin >> op[i];
		if (op[i] == "get" || op[i] == "delete") {
			cin >> param1[i];
			param2[i] = -1;
		}
		else if (op[i] == "insert") {
			cin >> param1[i] >> param2[i];
		}
		else if(op[i] == "show") {
			param1[i] = -1;
			param2[i] = -1;
		}
	}
	for (int i = 0; i < m; i++) {
		if (op[i] == "delete")
			deleteN(L, param1[i]);
		else if (op[i] == "get")
			getN(L, param1[i]);
		else if (op[i] == "insert")
			insertBeforePOSN(L, param1[i], param2[i]);
		else if (op[i] == "show")
			showL(L);
	}
	return 0;
}
2. vector & set
1. find方法
#include <vector>
#include <algorithm>
vector<int> arr;
auto it = find(arr.begin(), arr.end(), p->no);
if (it != arr.end()) {
    cout << it - arr.begin() << endl; // 获取下标
    //...
}
2. 一维数组，元素为[a, b]
vector<pair<int, int>> temp; // 记录感染的房间
temp.push_back({i, j});
for (int k = 0; k < temp.size(); k++) { 
	int i = temp[k].first;
	int j = temp[k].second;
	//...
}
3. set去重
#include <iostream>
#include <algorithm>
#include <set>
using namespace std;

int main() {
	int arr[31] = { 0 };
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	sort(arr, arr + n);
	set <pair< int,int >> unique_pairs; // 定义set
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			if (i != j && unique_pairs.find({ arr[i], arr[j] }) == unique_pairs.end()) { // set查找
				cout << "(" << arr[i] << "," << arr[j] << ")" << endl;
				unique_pairs.insert({ arr[i], arr[j] }); // set插入
			}
		}
	}
	return 0;
}
3. 排序
1. 快速排序
#include <iostream>
using namespace std;

int partition(int arr[], int left, int right) {
	int pivot = arr[left];
	while (left < right) {
		while (left<right && arr[right] >= pivot) right--;
		arr[left] = arr[right];
		while (left<right && arr[left] <= pivot) left++;
		arr[right] = arr[left];
	}
	arr[left] = pivot;
	return left;
}

void QuickSort(int arr[], int left, int right) {
	if(left>=right) return;
    int mid = partition(arr, left, right);
    QuickSort(arr, left, mid - 1);
    QuickSort(arr, mid + 1, right);
	return;
}

int main() {
	int arr[100];
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	QuickSort(arr, 0, n - 1);
	for (int i = 0; i < n; i++) 
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}
2. 归并排序
#include <iostream>
using namespace std;

const int MAXN = 1e5 + 10;
int temp[MAXN];
int arr[MAXN];
void merge(int arr[], int left, int right) {
	for (int i = left; i <= right; i++)
		temp[i] = arr[i];
	int mid = (left + right) / 2;
	int i = left, j = mid + 1;
	int k = left; // 从left位置开始存储
	while (i <= mid && j <= right) {
		if (temp[i] <= temp[j])
			arr[k++] = temp[i++];
		else
			arr[k++] = temp[j++];
	}
	while (i <= mid)
		arr[k++] = temp[i++];
	while (j <= right)
		arr[k++] = temp[j++];
	return;
}

void mergeSort(int arr[], int left, int right) {
	if (left >= right) return;
	int mid = (left + right) / 2;
	mergeSort(arr, left, mid); // 对左边递归
	mergeSort(arr, mid + 1, right); // 对右边递归
	merge(arr, left, right); // 归并
}
int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	mergeSort(arr, 0, n - 1);
	for (int i = 0; i < n; i++)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}
3. 希尔排序
#include <iostream>
using namespace std;

const int MAXN = 1e5 + 10;
int arr[MAXN];

void printArr(int arr[], int n) {
	for (int i = 0; i < n; i++)
		cout << arr[i] << " ";
	cout << endl;
}

void insertSort(int arr[], int n, int dk) {
	for (int i = dk; i < n; i++) { // dk:n-1
		int k = arr[i];
		int j;
		for (j = i - dk; j >= 0; j -= dk) {
			if (arr[j] > k)
				arr[j + dk] = arr[j];
			else
				break;
		}
		arr[j + dk] = k;
	}
	return;
}

void shellSort(int arr[], int n) {
	for (int dk = n / 2; dk >= 1; dk /= 2){
		insertSort(arr, n, dk%2==0?dk+1:dk);
		printArr(arr, n);
	}
	return;
}

int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	shellSort(arr, n);
	return 0;
}
4. 折半插入排序
#include <iostream>
using namespace std;

void insertSort(int arr[], int n) {
	for (int i = 2; i <= n; i++) {
		arr[0] = arr[i]; // 待排元素
		int left = 1, right = i - 1;
		while (left <= right) { // 找位置
			int mid = (left + right) / 2;
			if (arr[mid] <= arr[0])
				left = mid + 1;
			else
				right = mid - 1;
		}
		// 位置(含)之后元素后移
		for (int j = i - 1; j >= left; j--)
			arr[j + 1] = arr[j];
		// 插入待排元素
		arr[left] = arr[0];
	}
	return;
}
int arr[1000];
int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
		cin >> arr[i];
	insertSort(arr, n);
	for (int i = 1; i <= n; i++)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}
5. 堆排序
#include <iostream>
using namespace std;

void HeapAdjust(int arr[], int k, int len) {
	arr[0] = arr[k]; // 存储待排元素
	for (int i = k * 2; i <= len; i = 2 * i) { // 不停下坠找到存放arr[0]的位置
		if (i < len&& arr[i] < arr[i + 1])
			i++;
		if (arr[0] > arr[i])
			break;
		else {
			arr[k] = arr[i];
			k = i;
		}
	}
	arr[k] = arr[0]; // 放置待排元素
	return;
}

void BuildMaxHeap(int arr[], int len) { // 建立大根堆
	for (int i = len / 2; i > 0; i--)
		HeapAdjust(arr, i, len);
}

void swap(int& a, int& b) {
	int t = a;
	a = b;
	b = t;
	return;
}

void HeapSort(int arr[], int len) {
	BuildMaxHeap(arr, len); // 建堆
	while (len > 1) {
		swap(arr[1], arr[len--]);
		HeapAdjust(arr, 1, len);
	}
	//for (int i = len; i > 1; i--) {
	//	swap(arr[1], arr[i]);  // 交换arr[1] 和 arr[len--] 
	//	HeapAdjust(arr, 1, i - 1); // 重新调整堆
	//}
	return;
}

const int MAXN = 1e5 + 10;
int arr[MAXN];

int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
		cin >> arr[i];
	HeapSort(arr, n);
	for (int i = 1; i <= n; i++)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}
4. 数学
1. 质数
#include <iostream>
using namespace std;

const int MAXN = 1000;
bool isPrime[MAXN];

void init() {
	for (int i = 0; i < MAXN; i++)
		isPrime[i] = true; // 初始化都是质数
	isPrime[0] = false;
	isPrime[1] = false;
	for (int i = 2; i < MAXN; i++) {
		if (isPrime[i] == false)
			continue;
         // i是质数
		for (int k = i*i; k < MAXN; k += i) {
			isPrime[k] = false; // 质数的倍数不是质数
		}
	}
}

int main() {
	int n;
	cin >> n;
	init();
	for (int i = 0; i <= n; i++)
		if (isPrime[i])
			cout << i << endl;
	return 0;
}
2. double小数问题
#include <iostream>
#include <iomanip> // ***
using namespace std;

int main() {
	int n;
	cin >> n;
	double sum = 0;
	for (int i = 1; i <= n; i++) 
		sum += double(1.0 / i);  // ** 1.0/i
	cout << fixed << setprecision(6) << sum << endl; // ***
	return 0;
}
3. ip转16进制输出
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

int main() {
	int a, b, c, d;
	scanf("%d.%d.%d.%d", &a, &b, &c, &d);
	bool isFlag = true; // 输入是否合法
	if (a > 255 || b > 255 || c > 255 || d > 255)
		isFlag = false;
	if(a<0||b<0||c<0||d<0)
		isFlag = false;
	if(getchar() != '\n')
		isFlag = false;
	if (isFlag == false)
		printf("Error\n");
	else
		printf("0x%02X%02X%02X%02X", a, b, c, d); // printf("%4o %2X\n", num, num); // 输出8进制 16进制
	return 0;
}
4. 快速幂
#include <iostream>
using namespace std;

int main() {
	long x, n;
	cin >> x >> n;
	int mod = 233333;
	long long res = 1;
	while (n != 0) {
		if (n % 2 == 1)
			res = (res * x) % mod;
		x = (x * x) % mod;
		n /= 2;
	}
	cout << res << endl;
	return 0;
}
5. 字符转数字 数字转字符
char c;
int n;
int num = c - '0';
char cc = n + '0';
string str="1234";
int num = stoi(str);
5.动态规划
1. 放苹果
#include <iostream>
#include <cstring>
using namespace std;

int main() {
	int dp[13][13] = { 0 };
	int count;
	cin >> count;
	while (count--) {
		int m, n; // dp[m][n] m个苹果放入n个盘子
		cin >> m >> n;
		memset(dp, 0, 13 * 13);
		for (int i = 0; i <= m; i++) {
			dp[i][1] = 1; // 一个盘子只有1种方法放苹果
		}
		for (int i = 1; i <= n; i++) { // 至少一个盘子 从1开始遍历
			dp[0][i] = 1; // 0/1个苹果只有一种
			dp[1][i] = 1;
		}
		for (int i = 2; i <= m; i++) {
			for (int j = 2; j <= n; j++) {
				if (i >= j) { // 苹果大于等于盘子
					dp[i][j] = dp[i][j - 1] + dp[i - j][j];
				}
				else { // 苹果数量小于盘子 取决苹果
					dp[i][j] = dp[i][i];
				}
			}
		}
		cout << dp[m][n] << endl;
	}
	return 0;
}
2. 最长公共子序列长度
#include <iostream>
#include <algorithm>
using namespace std;

int dp[1010][1010];

int main() {
	string str1, str2;
	cin >> str1 >> str2;
	int m = str1.size(), n = str2.size();
	// dp[i][j] str1的前i个元素 str2的前j个元素的最大公共长度
	for (int i = 0; i <= m; i++) {
		dp[i][0] = 0;
	}
	for (int i = 0; i <= n; i++) {
		dp[0][i] = 0;
	}
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (str1[i-1] == str2[j-1])
				// str1[0, i-1] str2[0, j-1] ij元素取决于前0~i-1  0~j-1个元素
				dp[i][j] = dp[i - 1][j - 1] + 1;
			else
				dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
		}
	}
	cout << dp[m][n] << endl;
	return 0;
}
3. 最长连续公共序列 不含数字 只统计小写字母
#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

int dp[1010][1010];
int main() {
	string str1, str2;
	cin >> str1 >> str2;
	int m = str1.size(), n = str2.size();
	// dp[i][j] str1前i个元素和str2前j个元素的最长连续字串长度
	for (int i = 0; i <= m; i++) 
		dp[i][0] = 0;
	for (int i = 0; i <= n; i++)
		dp[0][i] = 0;
	int curmax = 0; // 记录当前最长连续子串长度
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (str1[i - 1] >= 'a' && str1[i - 1] <= 'z' && str1[i - 1] == str2[j - 1]) {
				// 右边缘相等为条件
				dp[i][j] = dp[i - 1][j - 1] + 1;
				curmax = max(dp[i][j], curmax);
			}
			else
				dp[i][j] = 0;
		}
	}
	cout << curmax << endl;
	return 0;
}
4. 最大连续序列和
#include <iostream>
#include <algorithm>

using namespace std;
int dp[1000];
int arr[1000];

int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	dp[1] = arr[0];
	int curmax = dp[1];
	for (int i = 2; i <= n; i++) {
		if (dp[i - 1] > 0) // 前i-1个元素的连续序列和
			dp[i] = dp[i - 1] + arr[i-1]; // dp[i]代表前i个元素的连续序列和 arr[i-1] 代表第i个元素
		else
			dp[i] = arr[i-1];
		curmax = max(dp[i], curmax);
	}
	cout << curmax << endl;
	return 0;
}
5. 最长递增子序列长度（非连续）
#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 1000 + 10;
int arr[MAXN];
int dp[MAXN];
int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	for (int i = 1; i <= n; i++) // 初始化 dp[i]都是1
		dp[i] = 1;
	int curmax = dp[1];
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= i; j++) { // 第i个元素 与 前面的第j个元素比较 [i.....j] 
			if (arr[i - 1] > arr[j - 1]) { // 第i个元素 > 第j个元素
				dp[i] = max(dp[j] + 1, dp[i]); // 刷新dp[i]的值
				curmax = max(dp[i], curmax);
			}
		}
	}
	cout << curmax << endl;
	return 0;
}
6. 01背包
#include <iostream>
#include <algorithm>
using namespace std;

int dp[5001][202]; // 200个元素下标
int main() {
	int m, n; //01背包重量m n组数据 m[1, 5000]
	int w[202] = { 0 }, v[202] = { 0 }; // 每个物品的重量以及价值 [1, 200]
	cin >> m >> n;
	for (int i = 0; i < n; i++) // 输入n个物品的信息
		cin >> w[i] >> v[i];
	for (int i = 0; i <= m; i++) // 没有物品 价值0
		dp[i][0] = 0;
	for (int i = 0; i < n; i++) // 背包没有容纳重量 价值0
		dp[0][i] = 0;
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (i < w[j - 1]) {
				// 如果背包剩余容量无法容纳第j件物品 返回前j-1物品的【value】
				dp[i][j] = dp[i][j - 1]; // dp[i][j-1] 代表i重量，前j-1件物品的价值 实际物品下标[0, j-2]
			}
			else {
				int remainM = i - w[j - 1]; // dp[remainM][j - 1] 买了第y件商品后剩下的钱用于买剩下的y-1件商品
				dp[i][j] = max(dp[i][j - 1], dp[remainM][j - 1] + v[j - 1]); // 前j-1的结果+第j件物品的价值
                // 不买第y件商品的价值 与 买第y件商品之后的价值对比 。。。剩下的钱不一定买的起前面j-1件商品
			}
		}
	}
	cout << dp[m][n] << endl;
	return 0;
}
6. 回溯
1. 组合
#include <iostream>
#include <vector>
using namespace std;
int choosen[100];
vector<int> res;

void backTracking(int n, int k, int startIndex) {
	if (res.size() == k) {
		for (int i = 0; i < res.size(); i++)
			cout << res[i] << " ";
		cout << endl;
		return;
	}
	for (int i = startIndex; i <= n; i++) {
		if (choosen[i])
			continue;
		choosen[i] = 1;
		res.push_back(i);
		backTracking(n, k, i + 1); // 第三个参数：0 全排列, i+1递增集合（元素不可重复）
		res.pop_back();
		choosen[i] = 0;
	}
}

int main() {
	int n;
	cin >> n;
	backTracking(n, 2, 1);
	return 0;
}
2. 全排列输出字母
#include <iostream>
#include <vector>
using namespace std;

bool choosen[100];
vector<char> res;

void backTracking(string str, int n, int startIdx) {
	if (res.size() == n) {
		for (int i = 0; i < res.size(); i++) 
			cout << res[i];
		cout << endl;
	}
	for (int i = startIdx; i < n; i++) {
		if (choosen[i])
			continue;
		choosen[i] = true;
		res.push_back(str[i]);
		backTracking(str, n, 0);
		res.pop_back();
		choosen[i] = false;
	}
	return;
}

int main() {
	string str;
	cin >> str;
	backTracking(str, str.size(), 0);
	return 0;
}
2024真题
1. 直接插入排序 第k趟结果
#include <iostream>
using namespace std;

const int MAXN = 1010;
int arr[MAXN];

void InsertSort(int arr[], int &n, int k) { // 输出插入排序第k趟排序
	for (int i = 1; i < n && i<k; i++) {
		int temp = arr[i]; // 当前待排元素
		int j;
		for (j = i - 1; j >= 0; j--) { // 对[0, i-1]元素排序
			if (arr[j] > temp) // 后移
				arr[j + 1] = arr[j];
			else
				break;
		}
		arr[j + 1] = temp;
	}
	for (int i = 0; i < n; i++)
		cout << arr[i] << " ";
	cout << endl;
	return;
}
int main() {
	int k, x;
	cin >> k;
	int n = 0;
	while (cin >> x)
		arr[n++] = x;
	InsertSort(arr, n, k);
	return 0;
}
2. 最大连续序列和
#include <iostream>
#include <algorithm>
using namespace std;

int arr[1010];
int dp[1010];
int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> arr[i];
	dp[1] = arr[0]; // dp[i] 前i个数的序列和
	int curmax = dp[1];
	for (int i = 2; i <=n; i++) { // 处理dp[n]
		if (dp[i - 1] <= 0)
			dp[i] = arr[i - 1]; // arr[i-1] 指代第i个元素 arr范围[0, i-1] // 前i个元素
		else
			dp[i] = dp[i - 1] + arr[i - 1];
		curmax = max(curmax, dp[i]);
	}
	cout << curmax << endl;
	return 0;
 }
3. 动态规划-多组数据，输入餐馆位置，餐馆需指定间隔距离， 餐馆利润，计算最大利润
#include <iostream>
using namespace std;

int main() {
	int n; // n组数据
	cin >> n;
	int p[101]; // 位置
	int v[101]; // 利润
	int dp[102]; // dp[i] 前i个元素的结果
	while (n--) {
		int posN, dis; // 店铺数 间隔距离
		cin >> posN >> dis;
		for (int i = 0; i < posN; i++) // 输入店铺位置
			cin >> p[i]; 
		for (int i = 0; i < posN; i++) // 输入店铺对应位置的利润
			cin >> v[i]; 
		dp[1] = v[0]; // 只有一个餐馆
		int curmax = dp[1];
		for (int i = 2; i <= posN; i++) {
			if (p[i - 1] - p[i - 2] >= dis)  // 第i个地点与前一个地点相差距离需要满足dis
				dp[i] = dp[i - 1] + v[i - 1];
			else 
				dp[i] = max(dp[i-1], v[i-1]);
			curmax = max(dp[i], curmax);
		}
		cout << curmax << endl;
	}
	return 0;
}
4. 找到第k个素数
#include <iostream>
#include <vector>

using namespace std;

const int MAXN = 1010;
bool isPrime[MAXN]; // 记录0-1000 是否是素数
vector<int> prime; // 存入素数

void init() {
	for (int i = 0; i < MAXN; i++)
		isPrime[i] = true;
	isPrime[0] = false;
	isPrime[1] = false;
	for (int i = 2; i < MAXN; i++) {
		if (isPrime[i] == false)
			continue;
		prime.push_back(i);
		for (int k = i * i; k < MAXN; k += i) // 质数的倍数 不是质数
			isPrime[k] = false;
	}
}


int main() {
	init();
	int n;
	cin >> n;
	if (isPrime[n]) {
		cout << true << endl;
	}
	else {
		for (int i = n + 1; i < MAXN; i++)
			if (isPrime[i]) {
				cout << i << endl;
				break;
			}	
	}
	return 0;
}
5.中缀表达式转后缀表达式
#include <iostream>
#include <string>
#include <vector>
using namespace std;

bool isOperator(char c) {
	return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
}

bool isAbleOut(vector<char> stackArr, char c) {
	int tail = stackArr.size()-1;
	if (c == '(')
		return false;
	if (c == ')' && stackArr[tail] != '(')
		return true;
	if (stackArr[tail] != '(') 
		if (c == '+' || c == '-')
			return true;
		else if (stackArr[tail] == '*' || stackArr[tail] == '/')
			return true;
	return false;
}

int main() {
	string str;
	cin >> str;
	vector<char> stackArr;
	string res;
	for (int i = 0; i < str.size(); i++) {
		if (isOperator(str[i]) == false)
			res += str[i];
		else {
			while (stackArr.size() && isAbleOut(stackArr, str[i])) {
				int tail = stackArr.size()-1;
				res += stackArr[tail];
				stackArr.pop_back();
			}	
			if (str[i] != ')')
				stackArr.push_back(str[i]);
			else
				// 右括号时 直到结束时， stack需要弹出(
				stackArr.pop_back();
		}
	}
	for (int i = stackArr.size() - 1; i >= 0; i--)
		res += stackArr[i];
	cout << res << endl;
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2321215.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

环境评价分析中土地利用现状图的制作方法

环境评价分析中土地利用现状图的制作方法

在环境评价中&#xff0c;土地利用现状图是重要的基础图件&#xff0c;用于分析项目区域的土地利用类型、分布格局及其生态环境特征。 以下是制作土地利用现状图的详细步骤和方法&#xff1a; 一、前期准备工作 确定制图范围和比例尺 根据评价范围确定制图区域边界 常用比例…
阅读更多...
编程题记录3

编程题记录3

九宫幻方 题目链接&#xff1a;https://www.lanqiao.cn/problems/100/learning/?page1&first_category_id1&second_category_id3&tags%E7%9C%81%E8%B5%9B&tag_relationintersection 先旋转、镜像得到所有的情况&#xff0c;可以发现情况是可以暴力得出的。…
阅读更多...
sql语句给表添加一个递增列

sql语句给表添加一个递增列

SSMS–》视图-》数据库(表)-》新建查询 ALTER TABLE [表名] DROP COLUMN ID ALTER TABLE [表名] ADD ID INT IDENTITY(1,1)执行完以上操作&#xff0c;会在表的最后一列添加一个自增字段 接下来如何把最后一个字段放到第一个字段呢&#xff1f; 假如sqlserver 表test 有以下…
阅读更多...
vue java 实现大地图切片上传

vue java 实现大地图切片上传

文章目录 一、项目背景二、页面三、代码1.前端2.mock-i18n.js文件3.xx.js文件定义方法4.配置文件 application.properties5.后端方法 四、易错点易错点1&#xff1a;前端要进行分片切割&#xff0c;然后再分片上传。易错点2&#xff1a;后端配置文件要配置。易错点3&#xff1a…
阅读更多...
langchain+ollama+deepseek的部署（win）

langchain+ollama+deepseek的部署（win）

ANACONDA 安装 官网&#xff1a;Download Anaconda Distribution | Anaconda 配置系统环境 在系统变量中配置 检查是否配置成功 通过 cmd 窗口输入&#xff1a; conda info 如图&#xff1a;表示成功 配置你的虚拟环境 二、安装 ollama allama 安装 官网地址&#xff1a…
阅读更多...
deepseek实战教程-第四篇开放平台接口文档使用

deepseek实战教程-第四篇开放平台接口文档使用

第二篇讲解了如何本地安装大模型&#xff0c;然后编写一个基于jsspringboot的项目&#xff0c;通过页面实现对话的功能。实际上&#xff0c;上面的demo用到是deepseek提供的接口&#xff0c;那么deepseek共提供了多少接口呢&#xff1f;这就要讨论到deepseek的接口库了&#xf…
阅读更多...
一站式电脑工具箱，功能全面且实用

一站式电脑工具箱，功能全面且实用

小明工具箱是一款集成了系统设置、维护工具、实用工具、图像处理等四大类工具的电脑工具箱&#xff0c;涵盖了上百种实用工具&#xff0c;能够满足用户在文件管理、文本处理、系统优化、图像处理等多方面的需求。 初次使用&#xff0c;需双击软件&#xff0c;便会自动将工具解压…
阅读更多...
那些正常的动态规划

那些正常的动态规划

文章目录 前言动态规划到底是啥&#xff1f; 线性dp最长上升子序列子集和子序列和子串的区别内容分析 最大上升子序列例题1——[NOIP2004 提高组] 合唱队形分析 最长公共子序列最长公共子串 平面dp例题2——[NOIP2000 提高组] 方格取数分析 例题3——[NOIP2008 提高组] 传纸条分…
阅读更多...
华为交换相关

华为交换相关

端口模式 &#xff08;1&#xff09;access&#xff1a;只能属于单个VLAN&#xff0c;一般用于连接计算机端口 &#xff08;2&#xff09;trunk&#xff1a;端口允许多个VLAN通过&#xff0c;可以接收和发送多个VLAN报文&#xff0c;默认情况下只有管理VLAN不携带标签信息 &…
阅读更多...
Chrome Performance 面板完全指南：从卡顿到丝滑的终极调试术

Chrome Performance 面板完全指南：从卡顿到丝滑的终极调试术

1.写在前面 前端性能调试是优化网页加载速度和运行效率的关键步骤&#xff0c;Chrome DevTools 的 Performance 面板 是核心工具; 2.Performance 面板使用步骤 ★ 基础 打开面板 在 Chrome 中按 F12 → 切换到 Performance 标签页。 开始录制 方式一&#xff1a;点击 ⚫️ 圆…
阅读更多...
JDK 24：Java 24 中的新功能

JDK 24：Java 24 中的新功能

&#x1f9d1; 博主简介&#xff1a;CSDN博客专家&#xff0c;历代文学网&#xff08;PC端可以访问&#xff1a;历代文学&#xff0c;移动端可微信小程序搜索“历代文学”&#xff09;总架构师&#xff0c;15年工作经验&#xff0c;精通Java编程&#xff0c;高并发设计&#xf…
阅读更多...
ubuntu服务器server版安装，ssh远程连接xmanager管理，改ip网络连接。图文教程

ubuntu服务器server版安装，ssh远程连接xmanager管理，改ip网络连接。图文教程

ventoy启动服务器版iso镜像&#xff0c;注意看server名称&#xff0c;跟之前desktop版ubuntu不一样。没有gui界面。好&#xff0c;进入命令行界面。语言彻底没汉化了&#xff0c;选英文吧&#xff0c;别的更看不懂。 跟桌面版ubuntu类似&#xff0c;选择是否精简系统&#xff0…
阅读更多...
python机器学习——新手入门学习笔记

python机器学习——新手入门学习笔记

一&#xff0c;概论 1.什么是机器学习 定义&#xff1a; 机器学习是从数据中自动分析获得模型&#xff0c;并利用模型对未知数据进行预测。 其实就是通过问题和数据&#xff0c;发现规律&#xff0c;并进行预测&#xff0c;与人脑相似。目的就是从历史数据当中获得规律&#x…
阅读更多...
LabVIEW 与 PLC 通讯的常见方式

LabVIEW 与 PLC 通讯的常见方式

在工业自动化和数据采集系统中&#xff0c;PLC&#xff08;可编程逻辑控制器&#xff09; 广泛用于控制和监测各种设备&#xff0c;而 LabVIEW 作为强大的图形化编程工具&#xff0c;常用于上位机数据处理和可视化。为了实现 LabVIEW 与 PLC 的高效通讯&#xff0c;常见的方法包…
阅读更多...
深度学习 Deep Learning 第9章 卷积网络 CNN

深度学习 Deep Learning 第9章 卷积网络 CNN

深度学习 Deep Learning 第9章 卷积网络 章节概述 本章深入探讨了卷积网络的原理、变体及其在深度学习中的应用。卷积网络通过卷积操作实现了参数共享和稀疏连接&#xff0c;显著提高了模型的效率和性能。本章首先介绍了卷积操作的基本形式及其在不同数据维度上的应用&#x…
阅读更多...
Tekton系列之实践篇-从触发到完成的完整执行过程

Tekton系列之实践篇-从触发到完成的完整执行过程

以下介绍的是基于 Gitee 仓库 的 Tekton 工作流程 操作流程 定义task 克隆代码的task # task-clone.yaml apiVersion: tekton.dev/v1beta1 kind: Task metadata:name: git-clone spec:workspaces:- name: source # 工作目录params:- name: repo-url # 你的 Gitee 仓库地址…
阅读更多...
【简单学习】Prompt Engineering 提示词工程

【简单学习】Prompt Engineering 提示词工程

一、Prompt 1、Prompt 是什么&#xff1f; Prompt 是一种人为构造的输入序列&#xff0c;用于引导 GPT 模型根据先前输入的内容生成相关的输出。简单来说&#xff0c;就是你向模型提供的 “提示词”。 在 ChatGpt 中&#xff0c;我们可以通过设计不同的 prompt&#xff0c;让…
阅读更多...
零基础入门网络爬虫第5天：Scrapy框架

零基础入门网络爬虫第5天：Scrapy框架

4周 Srapy爬虫框架 不是一个简单的函数功能库&#xff0c;而是一个爬虫框架 安装&#xff1a;pip install scrapy 检测&#xff1a;scrapy -h Scrapy爬虫框架结构 爬虫框架 爬虫框架是实现爬虫功能的一个软件结构和功能组件集合爬虫框架是一个半成品&#xff0c;能够帮助…
阅读更多...
C#设计模式快速回顾

C#设计模式快速回顾

知识点来源&#xff1a;人间自有韬哥在&#xff0c;豆包 目录 一、七大原则1. 单一职责原则 (Single Responsibility Principle)2. 开放封闭原则 (Open-Closed Principle)3. 里氏替换原则 (Liskov Substitution Principle)4. 接口隔离原则 (Interface Segregation Principle)5…
阅读更多...
分页查询互动问题(用户端)

分页查询互动问题(用户端)

文章目录 概要整体架构流程技术细节小结 概要 需求分析以及接口设计 技术细节 1.Controller层 GetMapping("/page")ApiOperation("分页查询问题")public PageDTO<QuestionVO> queryQuestionPage(QuestionPageQuery query){return questionService…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023