C语言真题记录
1.输入奇数 n 、图形左上角的字母，在屏幕上输出如图所示的由大写英文字母围起的图形。无论输入的字母是大写或小写，输出的字母均是大写，且字母输出是循环的，即输出 ‘Z’ 后接着输出 ‘A’ 。（↙表示回车）如输入的左上角字符不是字母或输入的数字不是奇数，输出“input error! ↙”
样例输入:
5 m↙
样例输出：
M N O P Q↙
N P R↙
O Q S↙
P R T↙
Q R S T U↙
#include
int main()
{
int n,i,j,k;
char ch;
int resu(char);
scanf("%d %c",&n,&ch);
if(n%2==0||(ch<65||ch>122||(ch>90&&ch<97)))
printf("input error!\n");
else
for(i=1;i<=n;i++)
{
k=0;
if(i==1||i==n)
{
for(j=1;j<=n;j++)
printf("%c",(resu(ch)+i-1-'A'+k++)%26+'A'); //此算法可以直接实现字母的循环
printf("\n");
}
else
{
for(j=1;j<=n;j++)
{
if(j==n/2+1||j==1||j==n) //注意题目只要求中间有一列输出
printf("%c",(resu(ch)+i-1-'A'+k++)%26+'A');
else
{
printf(" ");
k++;
}
}
printf("\n");
}
}
}
int resu(char ch) //是输入的字母变成大写字母
{
if(ch>=97)
return ch-32;
else
return ch;
} 对于这道题要点：
1.把字母都变成大写形式，也就是ascii属于65~90
2.对于循环字母的处理：resu(ch)+i-1-'A'+k++)%26+'A'，此种写法可直接实现
3.另外注意此题目要求的形式是中间只有一列，试错的时候注意思考图形特点
2.输入一个英文句子（20单词以内，不含标点符号或者数字特殊字符等），将其中各个单词按照字典顺序排序输出，各单词之间以空格分隔。
算法一：
#include
#include
int main()
{
int i,j,r=0,h=0; //r是小标值，不是个数
char ch[50]={0},temp[50]={0};//初始化防止后续位置元素干扰
char str[20][50] = {0}; //这部很关键 ，解决最后一个单词后面的'\0'问题
gets(ch);
for(i=0;ch[i]!='\0';i++) //从字母串里取单词的算法，用二维数组来解决
{
if(ch[i]!=' ')
{
str[r][h++]=ch[i];
}
else
{
str[r][h++]='\0';
//注意此处如果是最后一个'\0'，这样是加不上的，因为最后一个不是空格
r++; //一个单词收集结束，进入下一行
h=0; //重新收集单词
}
}
for(i=0;i 此题要点：
1. 从字符串里获取单词的算法（二维数组的应用）
2.定义数组时养成初始化的习惯，避免后续元素影响
3.字符串处理函数：strcmp(str1,str2)，str1与str2比较大小
strcpy(str1,str2)，把str2复制到str1中
strncpy(str1,str2,n)把str2中前n个字符复制到str1中
算法二：
#include
#include
#include
char ch[100] = {0};
char s[100][100] = {0};
int main () {
int cnt1 = 0, cnt2 = 0;
gets(ch);
for (int i = 0; i < strlen(ch); i++) {
if (ch[i] >= 'a' && ch[i] <= 'z' || ch[i] >= 'A' && ch[i] <= 'Z' ) {
if (cnt2 == 0) cnt1 ++;
s[cnt1][cnt2++] = ch[i];}
else cnt2 = 0;
}
for (int i = 1; i <= cnt1; i++) {
for (int j = 1; j < cnt1; j++) {
if (strcmp(s[j], s[j + 1]) > 0) {
char t[100] = {0};
strcpy(t, s[j]);
strcpy(s[j], s[j + 1]);
strcpy(s[j + 1], t);
}
}
}
for (int i = 1; i <= cnt1; i++) {
if (i != cnt1) printf("%s ", s[i]);
else printf("%s\n", s[i]);}
return 0;
}
3.建立一个链表，每个结点存储一个学生的姓名和成绩，将a,b,c三个结点按照分数由高到低链接起来，然后输出，编写链表结点连接函数connect。
链表的结构定义方式如下：
struct Node {
char *name;
int score;
struct Node *next;
};
请你完成以下函数代码
struct Node * connect(struct Node *x, struct Node *y, struct Node *z)
{
}
前置代码为：
#include
#include
struct Node {
char *name;
int score;
struct Node *next;
};
struct Node * connect(struct Node *x, struct Node *y, struct Node *z);
int main(int argc, char *argv[]) {
struct Node a, b, c, *p;
a.name = "LiPing";
b.name = "LiuHai";
c.name = "FengYun";
scanf("%d,%d,%d", &a.score, &b.score, &c.score);
p= connect(&a,&b,&c);
printf("%s-%d\n",p->name,p->score);
p=p->next;
printf("%s-%d\n",p->name,p->score);
p=p->next;
printf("%s-%d\n",p->name,p->score);
return 0;
} 构建函数：
算法一：
struct Node * connect(struct Node *x, struct Node *y, struct Node *z)
{
int i,j;
struct Node temp; //创建同类型结构体变量便于进行结构体整体交换
struct Node * head,*p; //*p就是一个参考标记移动指针，辅助链表的链接
struct Node arr[3]; //结构体数组
arr[0]=*x;arr[1]=*y;arr[2]=*z;//解应用得到相应结构体变量
head=(struct Node * )malloc(sizeof(struct Node)); //创建头指针
head->next=NULL;
head->score=-1;
for(i=0;i<3;i++) //选择排序法，根据score成员的大小将结构体变量排序
{
for(j=i+1;j<3;j++)
{
if(arr[j].scorename=arr[i].name;
p->score=arr[i].score;
p->next=head->next;
head->next=p; //头指针不要动，只能动head->next
}
return head->next; //根据题意选择合适的返回值
} 此题要点：
1.注意形参类别
2.允许结构体变量以及共用体变量进行整体赋值
3.注意这步，每一个节点都需要开辟内存空间
4.头指针不要动
5.根据题意选择合适的返回值
算法二：
struct Node * connect(struct Node *x, struct Node *y, struct Node *z) {
int a = x -> score, b = y -> score, c = z -> score;
if (a >= b && b >= c) {
x -> next = y; y -> next = z; z -> next = NULL;
return x;}
else if (a >= c && c >= b ) {
x -> next = z; z -> next = y; y -> next = NULL;
return x;}
else if (b >= a && a >= c ) {
y -> next = x; x -> next = z; z -> next = NULL;
return y;}
else if (b >= c && c >= a ) {
y -> next = z; z -> next = x; x -> next = NULL;
return y;}
else if (c >= a && a >= b ) {
z -> next = x; x -> next = y; y -> next = NULL;
return z;}
else if (c >= b && b >= a ) {
z -> next = y; y -> next = x; x -> next = NULL;
return z;}
}
4.题目描述：
输入n个正整数，按照数字出现的顺序输出其中出现次数大于k的数字。
输入：
第一行为整数n和k，第二行为n个数字。
输出：
按照数字出现的顺序输出其中出现次数大于k的数字，如果没有满足条件的数字，输出No such element.
样例输入：
8 2
1 1 2 2 3 1 3 3
样例输出：
1
3
#include
#include
int main()
{
int n,k,i,j,count,flag=1,flag1;
char num[100]={0}; //原字符串
char num1[100]={0}; //参考字符串
scanf("%d %d",&n,&k);
for(i=0;ik) //满足条件
{
if(flag1)
{
printf("%d\n",num[i]);
flag1=0; //防止重复输出
}
flag=0; //条件满足的标志量
}
}
}
if(flag)
printf("No such element.\n");
} 新的思路点
for ( i = 1; i <= n; i++)
{
int m;
scanf("%d", &m);
a[m]++;
if (a[m] > k && !b[m] )
{
printf("%d\n", m), ok = 1, b[m] = 1;
}
} 此题要点：
1.防止对原字符串造成影响，在比较时引入参考字符串
2.注意标志量的使用从而达到满足题意和避免重复输出的效果
3. 新思路点的后续解决
5.题目描述：
对于任意一点(x, y)，假设只有两种移动方式：(x, y) ->(x, x + y) ，(x, y) -> (x + y, y)。给定起点坐标(x1, y1)，判断是否可以只通过上述移动方式到达终点坐标(x2, y2)。例如起点坐标为 (2, 10)，终点坐标为(26, 12)，
则 (2, 10)->(2, 12)->(14, 12)->(26, 12) 是有效的移动方式，可以从起点到达终点。
提示：判断能否从（x1，y1）通过限定的两种移动方式移动到（x2，y2），可以转化为判断能否从（x1，x1+y1）通过限定的两种移动方式移动到（x2，y2）以及能否从（x1+y1，y1）通过限定的两种移动方式移动到（x2，y2）。
输入:
第一行为起点坐标，第二行为终点坐标。
输出：
如果可以通过上述移动方式到达终点，输出Yes.,否则输出No.
样例输入：
2, 10
26, 12
样例输出：
Yes.
#include
#include
#include
int n, k, ok = 0;
int gcd (int m, int n)
{
return n == 0 ? m : gcd(n, m % n);
}
int main ()
{
int x1, y1, x2, y2;
scanf("%d,%d", &x1, &y1);
scanf("%d,%d", &x2, &y2);
if (gcd(x1, y1) == gcd(x2, y2) && x1 <= x2 && y1 <= y2)
printf("Yes.\n");
else
printf("No.\n");
} 此题要点：
如果用bfs是2的指数次幂复杂度，但是观察后不难发现这就是更相减损术，也就是辗转相除法，那么只要起点x小于等于终点且二者的gcd（最大公因数）一样即可
bfs算法介绍链接：
https://blog.csdn.net/weixin_45705162/article/details/108296417?utm_source=app&app_version=5.5.0&code=app_1562916241&uLinkId=usr1mkqgl919blen
6.在本题中，给出单链表的结构定义如下：
typedef struct node {
int data;
struct node *next;
} NODE;
请你实现一段代码，完成查找链表的倒数第二个元素的过程。程序所需要的其他代码已经写好。
输入：
第一行有一个正整数N，表示接下来有N个正整数元素要依次插入链表。
第二行有N个正整数，分别表示数据。
输出：
如果链表长度大于等于2，输出倒数第二个元素中的data数值。
否则，输出“No such element.”
样例输入：
6
1 2 3 4 5 6
样例输出:
5
前置代码：
#include
typedef struct node {
int data;
struct node *next;
} NODE;
NODE* findelement(NODE *head);
//****************HERE IS THE CODE FOR YOU TO FINISH****************************
//**函数签名为：NODE* findelement(NODE*)***这个函数的含义是找到倒数第二个元素***************
//******************************************************************************
//****************ABOVE IS THE CODE FOR YOU TO FINISH***************************
//******************************************************************************
int main()
{
NODE *head = (NODE*)malloc(sizeof(NODE));
head->data = 0;
head->next = NULL;
int n, x;
scanf("%d", &n);
NODE *pre = head;
while(n--) { //创建链表，每一个节点都要申请存储空间
scanf("%d", &x);
NODE* cnt = (NODE*)malloc(sizeof(NODE));
cnt->data = x;
cnt->next = NULL;
pre->next = cnt;
pre = cnt;
}
NODE *pos = findelement(head);
if(pos == NULL) puts("No such element.");
else printf("%d\n", pos->data);
return 0;
}
构建函数：
NODE* findelement(NODE *head)
{
NODE * p = head;
if (p -> next == NULL || p -> next -> next == NULL) return NULL;
//只有一个成员或者没有的时候返回空指针
while (p -> next -> next != NULL) p = p -> next;
return p;
} 直接遍历链表即可，
这种题是其他程序已经内置进去了，只能按他的要求不全函数
做这种题时需要注意函数的返回类型， NODE* findelement(NODE *head)
所以我们要返回一个结构指针
要注意如果它只有一个成员（即没有倒数第二个）需要返回NULL
7.预设代码中建立了一个带有头结点的单向链表。
编写一个函数，将链表中数值域的数值为偶数的节点移到链表尾部。
如果偶数节点多于一个,则连接到链表尾部节点的先后顺序按原来的顺序。
结构的定义：
struct node
{
int num;
struct node *next;
}
typedef struct node NODE;
函数的原型：NODE *MoveNode( NODE *head )。
其中：参数 head 是单向链表的头指针。函数的返回值是单向链表的头指针。
运行时输入有一行，输入各个节点的数值域的值，输入-1时结束。
例如链表节点数值成员值为：15 6 7 21 2 13 24 -1 //-1 是节点输入结束标志
输出：15 7 21 13 6 2 24
前置代码：
#include
#include
typedef struct numLink
{
int no;
struct numLink *next;
}NODE;
NODE *MoveNode( NODE * );
void SetLink( NODE *h )
{
NODE *p=NULL, *q=NULL;
int m;
while(1)
{
scanf("%d",&m);
if( m == -1 )
return ;
p = (NODE *)malloc(sizeof(NODE));
p->no = m;
p->next = NULL;
if( h->next == NULL )
{
h->next = p;
q = p;
}
else
{
q->next = p;
q = q->next;
}
}
return;
}
int main( )
{
NODE *head=NULL, *q=NULL;
head = (NODE *)malloc(sizeof(NODE));
head->no = -1;
head->next = NULL;
SetLink( head );
q = MoveNode( head );
do
{
printf("%d ",q->next->no);
q = q->next;
}while( q->next != NULL );
printf("\n");
return 0;
} 构建函数：
NODE *MoveNode( NODE *head )
{
int count,i;
i=0;
NODE *o,*p,*q,*head1,*head2;
count =0;
p=head;
head1 = (NODE *)malloc(sizeof(NODE));
head2 = (NODE *)malloc(sizeof(NODE));
head1->next=NULL;
head2->next=NULL;
q=head1;
o=head2;
while(p->next!=NULL)
{
p=p->next;
count ++;
}
p=head;
for(i=0;inext;
if(p->no%2!=0)
{
q->next=p;
q=p;
}
else
{
o->next=p;
o=p;
}
}
q->next=head2->next;
o->next=NULL;
return head1;
} 分为奇数链表和偶数链表，再把偶数链表接在技术链表后面，再返回技术链表表头