文章目录
1.判断是否是闰年
题目描述:
#include<stdio.h>
int main(){
int year;
scanf("%d",&year);
//清楚判断闰年的条件是什么
if((year%400==0) || year%4 && year%100 != 0){
printf("yes\n");
}else
{printf("no\n");}
return 0;
}
2.输出ascii对应的字母
#include<stdio.h>
int main(){
int num;
scanf("%d",&num);
if(num>=97&&num<=122){
//若是以字符输出,则就是输出了ascii码对应的字符
printf("%c",num);
}
return 0;
}
3. 混合类型相加
#include<stdio.h>
int main() {
int i;
char j;
float k;
float sum;
scanf("%d %c %f", &i, &j, &k);
sum = i + j + k;
printf("%.2f\n", sum);
return 0;
}
4.判断是否是回文数(对称数)
//这样写是比较麻烦冗余的办法
//先把每个数字放到数组里,再根据数字位数相乘相加
#include<stdio.h>
#include<math.h>
int main() {
int num;
scanf("%d", &num);
int after_num = 0;
int num_div = num;//被除数,为0是说明已经除尽
int sum = 0;//计算是几位数
int a, b;
int shuzi[100];
for (int i = 0;; i++) {
//当被除数为0是退出循环
if (num_div == 0) {
break;
}
a = num_div % 10;
num_div = num_div / 10;
shuzi[i] = a;
sum++;
}
int x = sum;
int xx = 1;
//x等于1的时候就会多乘一遍,此时不需要,只需要使xx是sum位数即可
//比如sum=5 就需要有4个0
while (x>1) {
x--;
xx *= 10;
}
for (int j = 0; j < sum; j++) {
after_num += shuzi[j] * xx;
xx /= 10;
}
if (after_num == num) {
printf("yes\n");
}
else {
printf("no\n");
}
}
简单做法
在获取最后的个位数时,直接乘以10再与个位数相加
#include <stdio.h>
#include <math.h>
int main(){
int g,a,k;
scanf("%d",&a);
g = 0;
k = a;
while (k) {
//关键步骤,k就是最后的个位数,乘以10再加个位数,再乘以10与个位数相加
g = g * 10 + k % 10;
k = k / 10;
}
if (g == a) {
printf("yes\n");
}else{
printf("no\n");
}
return 0;
}
5.while循环计算阶乘
此处需要注意while循环的终止条件
//7.while循环计算n的阶乘
#include<stdio.h>
int main() {
int n;
scanf("%d", &n);
int multi_num = n;
//为1时不需要再计算一遍
while (n>1) {
multi_num *= (n - 1);
n--;
}
printf("%d", multi_num);
return 0;
}
6.兑换100元
暴力循环
#include<stdio.h>
int main() {
//穷举法
int sum_money = 0;//钱
int sum_paper = 0;//张数
int sum_way = 0;//方法
int a1, b1, c1, d1;//分别对应 1,2,5,10
a1 = b1 = c1 = d1 = 1;
//每个都选一张,就剩92元钱,36张
//1元最多40张,2元最多40,5元最多20张(更严谨点应该是1 + 92/5),10元最多10张( 1+92/10)
for (a1 = 1; a1 <= 40; a1++) {
for (b1 = 1; b1 <= 40; b1++) {
for (c1 = 1; c1 <= 20; c1++) {
for (d1 = 1; d1 <= 10; d1++) {
sum_money = a1 * 1 + b1 * 2 + c1 * 5 + d1 * 10;
sum_paper = a1 + b1 + c1 + d1;
if (sum_money == 100 && sum_paper == 40) {
sum_way += 1;
}
}
}
}
}
printf("%d\n", sum_way);
return 0;
}
7.某个数字出现的次数
//9. 2的出现次数
#include<stdio.h>
int main() {
int a[100],n;
int sum = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++)
{
scanf("%d", &a[i]);
if (a[i] == 2) {
sum++;
}
}
printf("%d\n", sum);
return 0;
}
8.翻转后的字符串与原字符串比较
这里有一个点:翻转后的b数组需要最后加上‘\0’表示输入终止
//10. 字符串判断
#include<stdio.h>
#include<string.h>
int main() {
char a[1000];//原始
char b[1000];//翻转
scanf("%s", a);
int i = strlen(a) - 1;
int j,k = 0;
for (j = i , k = 0; j >= 0, k <= i; j--, k++) {
b[k] = a[j];
}
b[i+1] = '\0';//必须要加这句,不然一直显示 字符无效 ?????
int result = strcmp(a, b);
if (result < 0)
{
printf("%d\n", -1);
}
else if (result > 0)
{
printf("%d\n", 1);
}
else {
printf("%d\n", 0);
}
return 0;
}
9.子函数输出商
//11. 子函数
#include <stdio.h>
//输入一个整型数,存入变量i,通过子函数change把主函数的变量i除2,
// 然后打印i,例如如果输入的为10,打印出5,如果输入的为7,打印出3
int change(int j)
{
j = j / 2;
printf("%d", j);
}
int main() {
int i;
scanf("%d", &i);
change(i);
return 0;
}
10.利用malloc函数获取空间
//12. 申请空间
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//gets可以接收空格;而scanf遇到空格、回车和Tab键都会认为输入结束,所有它不能接收空格。
int main() {
char* p;
int n;
scanf("%d", &n);
p = (char*)malloc(n);
char c;
scanf("%c", &c);//在scanf和gets中间使用scanf("%c",&c),去除换行
//scanf("%s", p);
//可以挨个读入字符,只需要最后再利用%c读入一个回车
for(int i = 0;i<n;i++){
scanf("%c", &p[i]);}
scanf("%c", &c);//在scanf和gets中间使用scanf("%c",&c),去除换行
//VS 这里有问题 错误原因:没有与参数列表匹配的 重载函数 "gets_s" 实例
//gets_s(p);
//因为p是指针,所以要使用gets函数的话,函数调用中有两个参数,第二个参数要给定开辟的空间范围
//gets_s(p,n);//写成这样即可
puts(p);
return 0;
}
11.青蛙上台阶
1.确定终止条件
2.寻找等价关系
//13. 递归上台阶
#include<stdio.h>
int upstairs(int n) {
//1.寻找终止条件
if (n == 1 || n == 2) {
return n;
}
//2.找等价关系,计算上台阶的方法
return upstairs(n - 1) + upstairs(n - 2);
}
int main() {
int n;
scanf("%d", &n);
int num = upstairs(n);
printf("%d", num);
return 0;
}
12.结构体输出名字
#include <stdio.h>
//输入一个学生的学号,姓名,性别,用结构体存储,通过scanf读取后,然后再通过printf打印输出
struct student {
int num;
char name[20];
char sex;
}; //定义一个结构体类型student
int main()
{
struct student s;
scanf("%d%s %c", &s.num, &s.name, &s.sex);
printf("%d %s %c\n", s.num, s.name, s.sex);
return 0;
}
// 15.输出字符串
#include<iostream>
using namespace std;
int main() {
char* p;
p = (char*)malloc(100);
fgets(p, 100, stdin);
puts(p);
return 0;
}
13.利用C++引用输出字符串
#include<iostream>
using namespace std;
int main() {
char* p;
p = (char*)malloc(100);
fgets(p, 100, stdin);
puts(p);
return 0;
}
14.顺序表插入删除
// 16.插入输出
#include<iostream>
using namespace std;
int main() {
int a[5] = { 1,2,3 };
int m, n;
cin >> m;//输入插入元素值,默认在第二个位置插入
cin >> n;//删除该位置的元素
int i = 3;
while (i>1) {
a[i] = a[i-1];
i--;
}
a[1] = m;
for (int k = 0; k < 4; k++) {
printf("%3d", a[k]);
}
printf("\n");
int j = n - 1;
if (n > 4) {
printf("false");
}
else {
while (a[j] != 0) {
a[j] = a[j + 1];
j++;
}
for (int k = 0; k < 3; k++) {
printf("%3d", a[k]);
}
}
return 0;
}
15.链表的创建输出
#include<stdio.h>
#include<stdlib.h>
typedef struct ListNode{
int data;
ListNode* next;
}ListNode,*LNode;
//1.头插法
void head_insert(LNode& L) {
//创建头结点
//在参数那里已经写了 LNode& L 已经进行了定义,所以下面不可以再次定义
//比如一个函数传入了 int a,b;直接使用即可,不用再次定义 int a,b;
L = (LNode)malloc(sizeof(ListNode));
L->next = NULL;
//第一个节点
int num;
scanf("%d", &num);
LNode p_new = (LNode)malloc(sizeof(ListNode));
p_new->data = num;
//把第一个节点插在头结点后面,且要在L->next的前面
p_new->next = L->next;//把L的next赋值给p_new->next
L->next = p_new;
//先把第一个节点存进去再存后序节点有一个弊端就是 会把9999也存进去
while (p_new->data != 9999) {
scanf("%d", &num);
//要插入新节点,首先需要开辟一块空间
LNode p = (LNode)malloc(sizeof(ListNode));
p->data = num;
p->next = p_new;
L->next = p;
p_new = p;
}
}
//2. 尾插法
void tail_insert(LNode& L) {
//创建头结点
L = (LNode)malloc(sizeof(ListNode));//这里sizeof的大小是结构体名称,即申请结构体大小的空间
L->next = NULL;
LNode L1 = L;//申请一个新的指针指向L;
//这里改变一下,第一个节点也在while循环中申请
int num;
scanf("%d", &num);
while (num != 9999) {
//给新节点申请空间
LNode q_new = (LNode)malloc(sizeof(ListNode));
q_new->data = num;
//这样没连起来
//q_new->next = L1->next;
//应该让 q_new指向L1->next,最后再单独给L1的结尾设为NULL
L1->next = q_new;
L1 = q_new;//L1向后一个
scanf("%d", &num);//这样不会把9999存进去
}
L1->next = NULL;
}
void PrintList(LNode& L)
{
L = L->next;
while (L != NULL)
{
if (L->data == 9999) {
L = L->next;
continue;
}
printf("%d", L->data);//打印当前结点数据
L = L->next;//指向下一个结点
if (L != NULL)
{
printf(" ");
}
}
printf("\n");
}
int main() {
LNode L;
head_insert(L);
PrintList(L);
tail_insert(L);
PrintList(L);
return 0;
}
16.链表的删除查找以及插入
//18.新建链表删除插入
#include<stdio.h>
#include<stdlib.h>
typedef struct ListNode{
int data;
ListNode* next;
}ListNode,*LNode;
//1. 尾插法
void tail_insert(LNode& L) {
//创建头结点
L = (LNode)malloc(sizeof(ListNode));//这里sizeof的大小是结构体名称,即申请结构体大小的空间
L->next = NULL;
LNode L1 = L;//申请一个新的指针指向L;
//这里改变一下,第一个节点也在while循环中申请
int num;
scanf("%d", &num);
while (num != 9999) {
//给新节点申请空间
LNode q_new = (LNode)malloc(sizeof(ListNode));
q_new->data = num;
//这样没连起来
//q_new->next = L1->next;
//应该让 q_new指向L1->next,最后再单独给L1的结尾设为NULL
L1->next = q_new;
L1 = q_new;//L1向后一个
scanf("%d", &num);//这样不会把9999存进去
}
L1->next = NULL;
}
//2.查找
LNode search(LNode& L,int i) {
LNode p = L;
//判断是否合法
if (i == 0) {
return L;
}
if (i < 1) {
return NULL;
}
while (i > 0 && p!=NULL) {
p = p->next;
i--;
}
//printf("%d\n", p->next);
return p;
}
//3.插入
void insert(LNode& L,int i,int num) {
//int i = 2;
LNode q = search(L,i-1);//获取到插入位置的前驱节点
if (q == NULL) {
return;
}
LNode q_new = (LNode)malloc(sizeof(ListNode));
q_new->data = num;
q_new->next = q->next;//先把要插入位置的元素放到新节点的后面
q->next = q_new;
}
//4.删除
void delett(LNode& L,int i) {
LNode k = search(L, i - 1);
if (k == NULL) {
return;
}
LNode key = search(L, i);//指向要删除的节点
if (k == NULL) {
return;
}
k->next = key->next;//把要删除的节点的后继节点指向前驱节点的后继节点
free(key);
}
void PrintList(LNode& L)
{
LNode L_new = L;
L_new = L_new->next;
while (L_new != NULL)
{
if (L_new->data == 9999) {
L_new = L_new->next;
continue;
}
printf("%3d", L_new->data);//打印当前结点数据
L_new = L_new->next;//指向下一个结点
}
printf("\n");
}
int main() {
LNode L;
tail_insert(L);
//查找
LNode p_new = search(L,2);
printf("%d\n", p_new->data);
//插入
insert(L, 2, 99);
PrintList(L);
//删除
delett(L, 4);
PrintList(L);
return 0;
}
17.栈和循环队列
//19.栈和队列
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 5
//线性栈
typedef struct stack{
int top;
int base;
int data[MaxSize];
};
//初始化栈
void init(stack& S) {
//stack S;
S.top = S.base = -1;
}
//入栈
void push(stack& S, int m) {
//判断是否满栈
if (S.top == MaxSize - 1) {
return;
}
S.data[++S.top] = m;
}
//判断是否为空
bool Empty(stack& S) {
if (S.top == -1) {
return false;
}
else
return true;
}
//出栈
void pop(stack& S) {
int num;
bool ret = Empty(S);
if (ret) {
num = S.data[S.top--];
}
printf("%2d", num);
}
//队列
typedef struct queue{
int data[MaxSize];
int rear;
int front;
};
//初始化
void init_queue(queue &Q) {
Q.front = Q.rear = 0;
}
//入队
bool en_queue(queue& Q,int num) {
//判断满不满 队列长度 (Q.rear-Q.front+MaxSize)%MaxSize;
if ((Q.rear + 1) % MaxSize == Q.front) {
return false;
}
Q.data[Q.rear] = num;
Q.rear = (Q.rear + 1) % MaxSize;
return true;
}
//判空
bool empty_queue(queue& Q) {
if (Q.rear == Q.front) {
return false;
}
else
return true;
}
//出队
void out_queue(queue& Q) {
int num = 0;
bool ret = empty_queue(Q);
if (ret) {
num = Q.data[Q.front];
Q.front = (Q.front + 1) % MaxSize;
printf("%2d", num);
}
}
int main() {
//栈
stack S;
init(S);
int a[10];
for (int i = 0; i < 3; i++) {
scanf("%d", &a[i]);
push(S, a[i]);
}
for (int i = 0; i < 3; i++) {
pop(S);
}
printf("\n");
//队列
queue Q;
init_queue(Q);//一定要初始化!!!!!!!
int b[MaxSize];
bool ret = false;
for (int i = 0; i < MaxSize; i++) {
scanf("%d", &b[i]);
ret = en_queue(Q, b[i]);
if (!ret) {
printf("false\n");
}
}
for (int i = 0; i < MaxSize; i++) {
out_queue(Q);
}
printf("\n");
return 0;
}
18.排序
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//交换函数
void swap(int &a,int &b)
{
int temp;
temp = a;
a = b;
b = temp;
}
int pos(int a[], int left, int right)
{
int i = left;
for (int j = left; j < right; j++)
{
if (a[j]<a[right])
{
swap(a[i], a[j]);
i++;
}
}
swap(a[i], a[right]);
return i;
}
//冒泡排序
void bubble_sort(int b[],int n)
{
for (int i = 0; i < n; i++)
{
int flag=0;
for (int j = n; j >i; j--)
{
if (b[j-1]>b[j])
{
swap(b[j - 1], b[j]);
flag = 1;
}
}
if (0==flag)
{
break;
}
}
}
//快速排序
void quick_sort(int b[],int low,int high)
{
if (low<high)
{
int a = pos(b, low, high);
quick_sort(b, low, a-1);
quick_sort(b, a+1, high);
}
}
//插入排序
void insert_sort(int a[],int n)
{
int flag;
for (int i = 1; i < n; i++)
{
int j;
if (a[i]<a[i-1])
{
flag = a[i];
for (j = i - 1; flag < a[j]; j--)
{
a[j + 1] = a[j];
}
a[j + 1] = flag;
}
}
}
//输出函数
void print(int a[],int n)
{
for (int i = 0; i < n; i++)
{
printf("%3d", a[i]);
}
printf("\n");
}
int main()
{
int a[10];
int b[10];
int c[10];
for (int i = 0; i < 10; i++)
{
scanf("%d", &a[i]);
}
for (int i = 0; i < 10; i++)
{
b[i] = a[i];
c[i] = a[i];
}
bubble_sort(a, 9);
print(a, 10);
quick_sort(b, 0, 9);
print(b, 10);
insert_sort(c, 10);
print(c, 10);
return 0;
}