LEEYANGY

LEEYANGY 关注TA

拼搏百天,我要上湖工大!

LEEYANGY

LEEYANGY

关注TA

拼搏百天,我要上湖工大!

  •  wuhan
  • 学生
  • 写了54,274字

最近回复

该文章投稿至Nemo社区   编程综合  板块 复制链接


C语言备份😃 && c程序设计试题汇编我觉得有问题的地方

发布于 2022/04/15 23:43 3,540浏览 0回复 14,290

以下内容均不考虑  xxx复杂度,只解决需求问题,先有需求,再优化

题目


给定一个字符串,删除指定字符,然后形成一个新的字符串
intput
"abaabaaabbaaaa"
target -> b
out
"aaaccaaxaztaaua"


//    初始化i和j变量,用来当循环计数
int i=0,j=0;
// 字符串
char strings[]="abaabaccaaxbbaztaaua";
printf("origin string is: ");

while (strings[i++] != '\0') {
printf("%c", strings[i]);
}
i=0;
// 遍历的字符串不等于\0,就让它一直输出
while(strings[i]!='\0'){
// 不等于指定的字符,就让它追加到之前数组里去
if(strings[i]!='b'){
strings[j++]=strings[i];
}
// 每次自加 1
++i;
}
// 循环结束添加一个结束标记
strings[j]='\0'; // 遍历字符串的函数和上同



输入两个字符串s1,s2,并从s1中删除s2中出现的字符。。。如下描述
intput:
char s1[300] = "abcaa63akdfk";
char s2[300] = "ayk5"; output:

bc63df


需求分析:

/**
* char s1[300]="abcaa63akdfk";
* char s2[300]="ayk5";
* modify -> bc63df
* 第一次 提取 a 出来判断s1中是否存在 字符 a
* 第二次 提取y ,判断 s1中是否存在 字符y
* 第三次 提取k 判断 s1中是否存在 字符k
* 第三次 提取 5 判断 s1中是否存在 字符5
* 结束循环
*
* @param s1
* @param s2
*/


不用指针的方法

void modify(char s1[300], char s2[300]) {
// 初始化循环条件
int i = 0, j = 0, k = 0;
// 外层循环的初始条件可以忽略不写,但在内循环结束时要让k i自加一次
for (; s2[i] != '\0'; i++) {
// 内层循环的初始条件就是让s1下标置0,然后每一次循环,都去和s2做判断,
for (j = k = 0; s1[j] != '\0'; j++) {
// 这里就是判断
if (s1[j] != s2[i]) {
// 把s1中没用的元素再写进s1...
s1[k++] = s1[j];
}
}
// s1的末尾加上\0,表示结束,然后继续执行循环
s1[k] = '\0';
}
printf("modify string is:%s\n", s1);
}




/***
 *  数组排序---选择排序
 *  描述:
* 在待排序中的一组数据中,选出最大或者最小的数,和第一个作比较
* 找到之后进行交换
* 外层循环移动到下一位,再和之后的所有数作比较
* @param arr
* @param n
*/
void selection_sort(int arr[], int len) {
printf("origin arr is:");
for (int i = 0; i < len; ++i) {
printf("%d ", arr[i]);
}
printf("\n");
// 定义一个计数器
int min = 0;
// 定义一个循环计数器
int i, j;
// 从0开始
for (i = 0; i < len - 1; i++) {
min = i;
// 从1开始
for (j = i + 1; j < len; j++) {
// 如果发现最小的数,就记录,最后a[min]再去和a[i]做交换,即完成排序
if (arr[j] < arr[min]) {
// 记录最小值的位置
min = j;
}
}
// 交换函数
swap(&arr[min], &arr[i]);
}
printf("modify arr is:");
for (int k = 0; k < len; ++k) {
printf("%d ", arr[k]);
}
}


快速排序
#include <iostream>
#include <cstring>
#include <algorithm>
const int N = 1e5;

using namespace std;
void quick_sort(int q[], int l, int r){
if (l >= r) return;

int i = l - 1, j = r + 1, x = q[l + r >> 1];
while (i < j){ //这里的while等价于 do-while写法,总是要移动指针到下一个目标,再判断条件 while (q[++i] < x);
while (q[--j] > x);
if (i < j) swap(q[i], q[j]);
}
quick_sort(q, l, j), quick_sort(q, j + 1, r);
}
int main(){
int n=0,arr[N];
cin >> n;
for (int i = 0; i < n; i ++ ){
cin >> arr[i];
}
quick_sort(arr,0,n-1);
// 遍历数组
for (int i = 0; i < n; i ++ ){
cout << arr[i] << " ";
}
return 0;
}


int arr[5]={0,2,4,6,8};//在main函数中定义

插入排序

/**
* 通过比较当前下标数和下标-1的数,使用m来记录当前下标的数据,将它和后面的数做比较,满足条件就交换,反之不交换,
* 使用一个待排序的数列来举例:
* 0,2,4,6,8
* 第一次选择下标为1的数据,将其和下标-1的数据做比较(也可以理解为下标的左边,这样会更容易理解),满足条件则交换,反之不交换
* 可以认为前面排序好的数是有序数列,对于要比较的数,它的下标每次都向后移动一位,
* 再将它和左边的数(也可以理解为前面的数)做比较
*
* @param arr
*/
void insert_sort(int arr[]){

int m,j;
for (int i = 1; i < 5; ++i) {
m=arr[i];
j=i-1;
while(j>=0 && m>arr[j]){
arr[(j--)+1]=arr[j];
// j--;
}
arr[j+1]=m;
for (int k = 0; k < 5; ++k) {
cout << arr[k] << " ";
}
cout << endl;
}
for (int i = 0; i < 5; ++i) {
cout << arr[i] << " ";
}
}

output:

2 0 4 6 8
4 2 0 6 8
6 4 2 0 8
8 6 4 2 0
8 6 4 2 0 (这个是排序后的结果,降序)



数组反转

给定一个数组,将其逆序输出



1-200的素数(质数)

需求分析
2%2
3%2
4%2 4%3
5%2 5%3 5%4
.......
200%2==0,--->> break;


//    穷举法
// count计数标记,和flag标记 0,1
int count = 0;
int flag = 0;
// 外循环2-200
for (int i = 2; i < 201; ++i) {
// 内循环
for (int j = 2; j < i; ++j) {
// 将外循环不断除内循环 内循环要小于外循环
if (i % j == 0) {
// 如果模为,直接break,跳出当前循环,flag一直置1
flag = 1;
break;
} else {
// 如果不满足以上条件,falg置0
flag = 0;
}
}
if (flag == 0) {
// 当flag为0,则计数
printf("%d ", i);
count++;
}
}
printf("\nprime have :%d\n\n\n", count);


最大公约数和最小公倍数
/** * 最小公倍数 * 暴力求解,用k做计数k累加到一定的数后,
* 分别除需要判断的数,==0即为目标数,
* 然后break跳出循环,即为最终解。
* k=0 或 k=1都可以,如果用
* 目前能想到的最简写法
*/
int p = 11, q = 65;
int count = 0;
while (count++ < (p * q)) {
if (count % q == 0 && count % p == 0) {
printf("最小公倍数%2d", count);
break;
}
}


/**

* 最大公约数 * 辗转相除法 求最大公约数
* 当b为0的时候,就不满足条件

* 当一个小数 取模 模不过大数 时候他们会发生交换

* 目前最简写法
*/
int a = 24, b = 12, c;
while (b) { //运算
c = a % b;
a = b;
b = c;
}
printf("\n最大公约数是%d\n", a);


二分/折半查找

code:
/**
*
* @param arr
* @param l
* @param r
* @param s
*
* 二分/折半查找,针对有序数组来说
* 开始先比较这个有序数组中间的元素,如果小与中间元素,则将要查找的数据锁定在 [ l,mid ]区间内
* 大于中间元素,则将要查找的数据锁定在 [ mid+1,r ]这个区间内
*
*/

void binsearch(int arr[], int l, int r, int s) {
// if (l == r) return;
// check是判断是否满足条件的标志
// count作为计数器,找这一个数需要循环多少次
int mid = 0, check = 0,count=0;
while (l < r) {
++count;
mid = l+r >>1;
if (s > arr[mid]) {
l = mid + 1;
} else if (s < arr[mid]) {
r = mid - 1;
} else {
// 找到了指定的数,if条件就不成立,将check置为1,用来标记真
check = 1;
break;
}
}
if (check == 1) {
cout << s <<" Found ,index is " << mid << endl ;
cout<< count;
} else{
cout << s << " no found!" << endl ;
cout << count;
}
}

example:

int arr[13] = {1, 2, 3, 6, 11, 22, 25, 36, 45, 56, 58, 60, 61}, s = 61;
binsearch(arr, 0, 13, s);

output: 61 found,index is 12 测试样例均以通过




c程序设计试题汇编(第三版)参考答案错误

第六章 数组

    6.70,和 6.71

我用clion编译器跑出来的结果如下:

code:

int a[5],max=0,min=0,i=0,j=0,k=0;
for (i=0;i<5;i++){
cin >> a[i];
}
min=a[0];
for (i=1;i<5;i++){
if(a[i]<min){
min=a[i];
// 原题答案 i=j=k 是什么鬼?
// i=j=k;
j=i;
}
}
max=a[0];
for (i=1;i<5;i++){
if(a[i]>max){
max=a[i];
k=i;
}
}
a[j]=max;
a[k]=min;
cout << "The position of min is:" << " " << k <<endl;
cout << "The position of min is:" << " " << j <<endl;
for (i=0;i<5;i++){
cout << a[i] <<" ";
}

input:
6 2 3 1 0
output:
The position of min is: 0
The position of min is: 4
0 2 3 1 6


6.71

int i,f[10];
f[0]=f[1]=1;
for(i=2;i<10;i++){
f[i]=f[i-2]+f[i-1];
}
for (i=0;i<10;i++){
if(i%4==0){
cout << endl;
}
cout << f[i]<< " ";
}

//以上写法等价于c语言 cout等于 printf output:
1 1 2 3
5 8 13 21
34 55



c++结构体

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;
struct person{
int id;
char name[20];
double score;
};
int main() {

person myfriend1[3];

for (int i = 0; i < 3; ++i) {
cout << "Please input " << i+1 << " id:";
cin >> myfriend1[i].id;
cout << "Please input " << i+1 << " name:";
cin >> myfriend1[i].name;
cout << "Please input " << i+1 << " score:";
cin >> myfriend1[i].score;
}

// cout << " " << myfriend1.id << " " << myfriend1.name << " " << myfriend1.score;
for ( int i=0;i<3;i++ )
cout << i+1 << ". " << " " << myfriend1[i].id << " " << myfriend1[i].name << " " << myfriend1[i].score << endl;
return 0;
}

output:
Please input 1 id:1
Please input 1 name:leeyangyang
Please input 1 score:100
Please input 2 id:2
Please input 2 name:leeyangyang
Please input 2 score:101
Please input 3 id:3
Please input 3 name:leeyangyang
Please input 3 score:103
1. 1 leeyangyang 100
2. 2 leeyangyang 101
3. 3 leeyangyang 103




动态单向链表

https://github.com/leeyangyangy/difficult_to_understand/tree/studentManager-dev

代码水平一般,如有问题,请大佬指正。 #include <iostream>
#include <vector>
#include <cstring>
#include <memory>

using namespace std;

/**
* 在c++中,可以间接的将struct认为是class
*/

/**
* 测试数据:
* 10 20 30 40 50 60 70 80 90 100 0
*
* 查找元素:
* 520
*
* 删除元素:
* 50
*
* 添加元素
* 尾插 110 ok
*
*
*/

struct linknode{
int val;
linknode *next;
};

//函数声明
void printfLinkNode(linknode *p);
linknode *creatLinkNode(void);
linknode *delLinkNode(linknode *head,int del);
linknode *insertLinkNode(linknode *head,int insert,int site);
linknode *modifyData(linknode *head,int before_modify,int after_modify);
void searchLinkNode(linknode *head,int searchData);
int main() {
// 正常链表
cout << "----You input the linklist:----" << endl;
/**
* test data
* 10 20 30 40 50 0
*/
linknode *current=creatLinkNode();
printfLinkNode(current);

cout << endl << "----del element after the linklist:----" << endl;
/**
* test data
* 10 20 30 40 50 0
*/
current=delLinkNode(current,50);
printfLinkNode(current);

cout << endl << "----you insert after linklist----" <<endl;
/**
* test input data
* 10 20 30 40 50 0
*/
current = insertLinkNode(current,50,40);
printfLinkNode(current);

cout << endl << "----you modify after linklist----" <<endl;
/**
* test input data
* 10 20 30 40 50 0
*/
current = modifyData(current,40,520);
printfLinkNode(current);
searchLinkNode(current,520);
return 0;
}

// 遍历链表
void printfLinkNode(linknode *head){
while(head!= nullptr){
cout << head->val << " ";
head=head->next;
}
}

linknode *creatLinkNode(void){
// 定义头节点
linknode *head= new linknode;
linknode *current =new linknode;
linknode *ln = new linknode;
// new class/struct
// head= new linknode;
// head->val=110;
// head->next= nullptr;
// 插入元素到链表
// current = head;
head= nullptr;
cout << "请输入一个整形数据(输入0结束): " << endl;
cin >> current->val;
while (current->val!=0){
// 判断链表是否存在
if(head== nullptr){
// 拿到current记录的地址
head=current;
} else {
ln->next=current;
}
ln=current;
current = new linknode;
cin >> current->val;
}
// 结尾补上一个尾巴
ln->next= nullptr;
return head;
}
/**
* 删除操作思路:
* 找到元素后,把当前的
* @param head
* @param del
* @return
*/
linknode *delLinkNode(linknode *head,int del){
linknode *prev,*current=head;
cout << "head add = " << head->next << " head->val = " << head->val<< endl;
while (current!= nullptr){
cout << "current->next add = " << current->next << " " << "current->val = " << current->val << endl;
if(del==current->val){
/**
* 通过调试可以知道,p1现在的位置是上一个地址,
* p2现在指在下一个地址上
* 我们找到的这个元素把下一个也就是p2的地址给指向p1
*
*/
prev->next=current->next;
break;
} else{
prev=current;
current=current->next;
}
}
// cout << "current->next add = " << cu current->next << " " << "current->val = " << current->val << endl;
return head;
}

//指定位置插进去
linknode *insertLinkNode(linknode *head,int insert,int site){
// 创建两个指针,current指向head头指针
linknode *current=head;
// 开辟一个内存空间
linknode *ln=new linknode;
ln->val=insert;
// 记录位置 判断链表是否为空
while(current->next!= nullptr){
// 找位置插进去
if(site==current->val){
ln->next=current->next;
current->next=ln;
break;
} else{
// current向后移动
current=current->next;
}
}
// 在末尾插入
if(current->next == nullptr){
ln->next=current->next;
current->next=ln;
}
return head;
}

//改指定的元素
linknode *modifyData(linknode *head,int before_modify,int after_modify){
linknode *current=head;
while (current!= nullptr){
if(before_modify==current->val){
// 找到后修改
current->val=after_modify;
break;
}else{
// 指针向后移动
current=current->next;
}
}
return head;
}

//查找指定元素
void searchLinkNode(linknode *head,int searchData){
linknode *current=head;
int flag=0;
while(current->next!= nullptr){
if(current->val==searchData){
flag=1;
break;
} else{
current=current->next;
}
}
if(flag==1){
cout << endl << searchData << " Found!";
}else{
cout << endl << searchData << " No Found!";
}
}

void menu(){
cout << "-------欢迎使用学生管理系统--------";
/**
* 正常的尾插数据
*/
cout << "--------1.添加学生---------------";
/**
* 搜索进行删除
*/
cout << "--------2.删除学生---------------";
/**
* 读取文件
*/
cout << "--------3.打开文件---------------";
/**
* 直接删除整个保存的数据
*/
cout << "--------4.删除数据(不可逆操作,谨慎!)";
/**
* 文件以乱序形式存储,打开后按需进行排序
*/
cout << "--------5.保存数据---------------";
} output:

----You input the linklist:----
请输入一个整形数据(输入0结束):
10 20 30 40 50 0
10 20 30 40 50
----del element after the linklist:----
head add = 0x1bf26d11c80 head->val = 10
current->next add = 0x1bf26d11c80 current->val = 10
current->next add = 0x1bf26d11ca0 current->val = 20
current->next add = 0x1bf26d11cc0 current->val = 30
current->next add = 0x1bf26d11ce0 current->val = 40
current->next add = 0 current->val = 50
10 20 30 40
----you insert after linklist----
10 20 30 40 50
----you modify after linklist----
10 20 30 520 50
520 Found!

------目前已知问题,不能删除头节点元素------




点赞(0)

下一个文章:制作caf内核

点了个评