第二轮考核

YQq2022_0918

已于 2022-12-08 12:10:11 修改

阅读量306

点赞数

文章标签：学习

于 2022-12-08 12:09:00 首次发布

本文链接：https://blog.csdn.net/Qq2022_0918/article/details/128234614

版权

考核二

A.linux系统的学习

一.安装虚拟机

1.安装VMware √

2.下载镜像Ubuntu √

3.在VMware上安装上相应的Linux操作系统 √

二.掌握基本的linux操作

1.自主学习掌握： 基本的文件操作、vi/vim的使用方法、简单的shell语法

Linux笔记

2.实训作业：

注册并登入超算习堂 https://easyhpc.net/，进入在线实训部分，完成在线实训内容：

（1）linux基础入门√

（2）vim入门教程√

也记录在Linux笔记里面

3.编译运行程序将第一次考核中的 8. 判断回文质数代码，在虚拟机内的linux环境下编译运行

代码：

#include<iostream>
#include<cmath>
using namespace std;

bool isPrime(unsigned a);//质数 

bool isHuiwen(unsigned b);//回文 

int main()
{
	unsigned x;
	cin>>x;
	if(isPrime(x)&&isHuiwen(x)){
		cout<<"YES."<<endl;
	}else{
		cout<<"NO."<<endl;
	}
	
	return 0;
}

bool isPrime(unsigned a)
{
	int ret=1;
	int i;
	double n=sqrt(a);
	if(a==1||a==0){
		ret=0;
	}else{
		for(i=2;i<=n;i++){
			if(a%i==0){
				ret=0;
				break;
			}
		}
	}
	return ret==1;
}

bool isHuiwen(unsigned b)
{
	int ret=0,t=b,d;
	while(b>0){
		d=b%10;
		ret=ret*10+d;
		b/=10;
	}
	return t==ret;
}

运行：

yang@yang-virtual-machine:~$ g++ huiwenzhishu.cpp -o huiwenzhishu
yang@yang-virtual-machine:~$ ./huiwenzhishu
151
YES.
yang@yang-virtual-machine:~$ ./huiwenzhishu
121
NO.
yang@yang-virtual-machine:~$ ./huiwenzhishu
191
YES.
yang@yang-virtual-machine:~$ ./huiwenzhishu
55
NO.

B.编程语言的学习

一.基本数据结构学习

链表学习记录

队列和栈

1.实现一个单链表，链表初始为空，支持三种操作：

向链表头插入一个数；
删除第 k 个插入的数后面的数；
在第 k 个插入的数后插入一个数

考察内容：链表的基本使用

#include<stdio.h>
#include<stdlib.h> 
typedef struct MyLinkedList{
	int val;
	struct MyLinkedList* next;
} MyLinkedList;


MyLinkedList* myLinkedListCreate() {//创建链表 
	MyLinkedList *node=(MyLinkedList*)malloc(sizeof(MyLinkedList));
	node->next=NULL;
	return node;
}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {//向链表头插入一个数 
	MyLinkedList *head=(MyLinkedList*)malloc(sizeof(MyLinkedList));
	head->val=val;
	head->next=obj->next;//obj->next指向插入的第一个数 
	obj->next=head;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int k, int val) {//在第k个插入的数后插入一个数,k=0相当于在表头插入一个数，k小于0不插入。 
	if(k<0){//k小于0的时候不插入 
		printf("插入失败！\n");
		return ; 
	}
	int i;
	MyLinkedList *p=obj;
	for(i=0;i<k;i++){
	 	
	 	if(p->next==NULL){
	 		printf("插入失败！\n");
	 		return ;
		 }else{
		 	p=p->next;
		 }
	 }
	MyLinkedList *mid=(MyLinkedList*)malloc(sizeof(MyLinkedList));
	mid->val=val;
	mid->next=p->next;
	p->next=mid;
}


void myLinkedListDeleteAtIndex(MyLinkedList* obj, int k) {//删除第k个插入的数后面的数，k=0删除链表第一个数。 
	if(k<0){//k小于0的时候不删除 
		printf("删除失败！\n");
		return ;
	}
	 MyLinkedList* p=obj,*q;
	 int i;
	 for(i=0;i<k;i++){
	 	if(p->next==NULL){
	 		printf("删除失败！\n");
	 		return ;
		 }else{
		 	p=p->next;
		 }
	 }
	 if(p->next==NULL){
	 	printf("删除失败！\n");
	 	return ;
	 }//第k个插入的数后面没有数 
	 q=p->next;
	 p->next=q->next;
}

void myLinkedListPrint(MyLinkedList* obj){
	MyLinkedList *p=obj->next;
	printf("链表：");
	if(p==NULL){
		printf("Empty!");
	} 
	while(p){
		printf("%d ",p->val);
		p=p->next;
	}
	printf("\n");
}

int main()
{
	MyLinkedList *a=myLinkedListCreate(); 
	int num,k,i=0;
	
	printf("初始化链表（输入-1结束）：");
	scanf("%d",&num); 
	while(num!=-1){
		myLinkedListAddAtIndex(a,i,num);
		scanf("%d",&num); 
		i++;
	} 
	myLinkedListPrint(a);
	
	printf("输入一个要向链表头插入的数：");
	scanf("%d",&num);
	myLinkedListAddAtHead(a,num);
	myLinkedListPrint(a);
	
	printf("在第k个插入的数后面插入一个数（k=0相当于在表头插入一个数），输入k和要插入的数：");
	scanf("%d %d",&k,&num);
	myLinkedListAddAtIndex(a,k,num);
	myLinkedListPrint(a);
	
	printf("删除第k个插入的数后面的数，输入k值：");
	scanf("%d",&k);
	myLinkedListDeleteAtIndex(a,k);
	 myLinkedListPrint(a);
	
	return 0;
 }

将中缀表达式转化成对应的后缀表达式

所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右进行（不用考虑运算符的优先级）

例1：中缀表达式: 3(5–2)+7 对应的后缀表达式为：352-7+

例2：中缀表达式: 2+48+(88+1)/3 对应的后缀表达式为 248+881+3/+

考察内容：栈的基本使用

#include<iostream> 
#include<string>
#include<stack>
using namespace std;
int main()
{
	string a;
	getline(cin,a);
	stack<char> symbolx;
	int i,flag=0;//flag=0表示表达式的开头，flag=1表示不是开头，-1+2*2或者2*（-9）  
	for(i=0;i<a.length();i++){
		if(flag==0){
			if(a[i]=='-'){//表达式开头如果有负号，需要输出 
				flag=-1;
				continue;
			}else if(a[i]=='+'){//开头正号不需要输出 
				flag=1;
				continue;
			}
		}
		if(a[i]>='0'&&a[i]<='9'){//遇到数字，直接输出 
			if(flag==-1){
				cout<<'-';//输出表达式式开头的符号 
			}
			flag=1;
			while((i<a.length())&&(a[i]<='9'&&a[i]>='0'||a[i]=='.')){//可能有小数 
				cout<<a[i];
				i++;
			}
			i--;//多加了，减回去 
		}else{
			if(a[i]=='('){//左括号入栈 
				flag=0;
				symbolx.push(a[i]);
				continue;
			}
			if(a[i]==')'){//遇到右括号，不断出栈输出，直到栈空（一般不会）或遇到左括号 
				while(!symbolx.empty()&&symbolx.top()!='('){
					cout<<symbolx.top();
					symbolx.pop();
				}
				if(!symbolx.empty()&&symbolx.top()=='('){//弹出左括号 
					symbolx.pop();
				}
				continue;
			}
		}
		switch(a[i]){//+-*/
			case '-':
			case '+':
				//优先级：乘除>加减>左括号，所以不断出栈输出，直到栈空或者遇到左括号，然后入栈 
				while(!symbolx.empty()&&symbolx.top()!='('){
					cout<<symbolx.top();
					symbolx.pop();
				}
				symbolx.push(a[i]);
				break;
			case '*':
			case '/':
				//若栈顶符号不为乘除，只入栈；为乘除，先取出栈顶符号再入栈 
				if(!symbolx.empty()&&symbolx.top()!='('){
					if(symbolx.top()=='*'||symbolx.top()=='/'){
						cout<<symbolx.top();
						symbolx.pop();
					}
				}
				symbolx.push(a[i]);
				break;
			default:
			break;	
		}
	}
	while(!symbolx.empty()){//出栈输出非左括号的，直到栈空 
		if(symbolx.top()!='('){
			cout<<symbolx.top();
		}
		symbolx.pop();
	}
	return 0;
}