1、矩阵转置
题目描述
输入一个N*N的矩阵，将其转置后输出。要求：不得使用任何数组(就地逆置)。
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
while(~scanf("%d",&n))
{
int a[101][101];
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
scanf("%d",&a[i][j]);
}
}
for(int j=1;j<=n;j++)
{
for(int i=1;i<=n;i++)
{
printf("%d ",a[i][j]);
}
printf("\n");
}
}
return 0;
}
2、统计单词
题目描述
编一个程序，读入用户输入的，以“.”结尾的一行文字，统计一共有多少个单词，并分别输出每个单词含有多少个字符。
（凡是以一个或多个空格隔开的部分就为一个单词）
#include<bits/stdc++.h>
using namespace std;
int main()
{
char str[10001];
gets(str);
int len=strlen(str),r=0,c=0;
int a[10010]={0};
for(int i=0;i<len-1;i++)
{
if(str[i]!=' ')
{
a[r]++;
}
else
{
r++;
}
}
for(int i=0;i<=r;i++)
{
printf("%d",a[i]);
if(i!=r)
printf(" ");
}
return 0;
}
3、ip地址
题目描述
输入一个ip地址串，判断是否合法。
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,d;
while(~scanf("%d.%d.%d.%d",&a,&b,&c,&d))
{
if(a>=0&&a<=255&&b>=0&&b<=255&&c>=0&&c<=255&&d>=0&&d<=255)
{
printf("Yes!\n");
}
else
{
printf("No!\n");
}
}
return 0;
}
4、二叉排序树
题目描述
二叉排序树，也称为二叉查找树。可以是一颗空树，也可以是一颗具有如下特性的非空二叉树： 1. 若左子树非空，则左子树上所有节点关键字值均不大于根节点的关键字值； 2. 若右子树非空，则右子树上所有节点关键字值均不小于根节点的关键字值； 3. 左、右子树本身也是一颗二叉排序树。 现在给你N个关键字值各不相同的节点，要求你按顺序插入一个初始为空树的二叉排序树中，每次插入后成功后，求相应的父亲节点的关键字值，如果没有父亲节点，则输出-1。
输入描述:
输入包含多组测试数据，每组测试数据两行。
第一行，一个数字N（N<=100），表示待插入的节点数。
第二行，N个互不相同的正整数，表示要顺序插入节点的关键字值，这些值不超过10^8。
输出描述:
输出共N行，每次插入节点后，该节点对应的父亲节点的关键字值。
#include<bits/stdc++.h>
using namespace std;
struct BinTree
{
int data;
BinTree* lchild;
BinTree* rchild;
};
void inSert(BinTree* &root,int data,int pre)
{
if(root==NULL)
{
root = new BinTree;
root->data=data;
root->lchild=root->rchild=NULL;
printf("%d\n",pre);
return;
}
if(data<root->data)
inSert(root->lchild,data,root->data);
else
inSert(root->rchild,data,root->data);
}
int main()
{
int n;
while(~scanf("%d",&n))
{
int x;
BinTree* root=NULL;
for(int i=0;i<n;i++)
{
scanf("%d",&x);
inSert(root,x,-1);
}
}
return 0;
}
5、字符串连接
题目描述
不借用任何字符串库函数实现无冗余地接受两个字符串，然后把它们无冗余的连接起来。
输入描述:
每一行包括两个字符串，长度不超过100。
输出描述:
可能有多组测试数据，对于每组数据，
不借用任何字符串库函数实现无冗余地接受两个字符串，然后把它们无冗余的连接起来。
输出连接后的字符串。
示例1
输入
abc def
输出
abcdef
#include<bits/stdc++.h>
using namespace std;
int main(){
char a[202],b[101];
while(~scanf("%s %s",a,b))
{
int i=0;
while(a[i]!='\0')
{
i++;
}
for(int j=0;b[j]!='\0';j++)
{
a[i++]=b[j];
}
a[i]='\0';
puts(a);
}
return 0;
}
6、a+b
题目描述
实现一个加法器，使其能够输出a+b的值。
输入描述:
输入包括两个数a和b，其中a和b的位数不超过1000位。
输出描述:
可能有多组测试数据，对于每组数据，
输出a+b的值。
示例1
输入
复制
2 6
10000000000000000000 10000000000000000000000000000000
输出
复制
8
10000000000010000000000000000000
#include<bits/stdc++.h>
using namespace std;
struct bign{
int d[1000];
int len;
bign()
{
memset(d,0,sizeof(d));
len=0;
}
};
bign change(char str[])
{
bign a;
a.len=strlen(str);
for(int i=0;i<a.len;i++)
{
a.d[i]=str[a.len-i-1]-'0';//让整数顺位存储低位在低，高位在高。
}
return a;
}
bign add(bign a,bign b)
{
bign c;
int carry=0;//进位
for(int i=0;i<a.len||i<b.len;i++)
{
int temp=a.d[i]+b.d[i]+carry;//每一位相加加上相应的进位
c.d[c.len++]=temp%10;//temp个位为该位
carry=temp/10;//temp十位为进位
}
if(carry!=0)
{
c.d[c.len++]=carry;//最后一位相加产生了进位
}
return c;
}
void print(bign a)
{
for(int i=a.len-1;i>=0;i--)//高位在高位所以要倒着输出 比如123，现在高位1在数组最后一位
{
printf("%d",a.d[i]);
}
}
int main(){
char str1[1001],str2[1001];
while(~scanf("%s%s",str1,str2))
{
bign a=change(str1);
bign b=change(str2);
print(add(a,b));
}
return 0;
}
7、排序
题目描述
对输入的n个数进行排序并输出。
输入描述:
输入的第一行包括一个整数n(1<=n<=100)。
接下来的一行包括n个整数。
输出描述:
可能有多组测试数据，对于每组数据，将排序后的n个整数输出，每个数后面都有一个空格。
每组测试数据的结果占一行。
示例1
输入
复制
4
1 4 3 2
输出
复制
1 2 3 4
#include<bits/stdc++.h>
using namespace std;
void bubbleSort(int a[],int n)
{
for(int i=0;i<n-1;i++)
{
for(int j=0;j<n-1-i;j++)
{
if(a[j]>a[j+1])
{
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
void insertSort(int a[],int n)
{
int i,j;
for(i=1;i<n;i++)
{
int temp=a[i],j=i-1;
while(j>=0&&temp<a[j])
{
a[j+1]=a[j];
--j;
}
a[j+1]=temp;
}
}
void selectSort(int a[],int n)
{
for(int i=0;i<n;i++)
{
int Min=i;
for(int j=i+1;j<n;j++)
{
if(a[j]<a[Min])
{
Min=j;
}
}
if(Min!=i)
swap(a[i],a[Min]);
}
}
int main(){
int n;
while(cin>>n)
{
int a[101];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
bubbleSort(a,n);
for(int i=0;i<n;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
}
return 0;
}
8、特殊排序
题目描述
输入一系列整数，将其中最大的数挑出(如果有多个，则挑出一个即可)，并将剩下的数进行排序，如果无剩余的数，则输出-1。
输入描述:
输入第一行包括1个整数N，1<=N<=1000，代表输入数据的个数。
接下来的一行有N个整数。
输出描述:
可能有多组测试数据，对于每组数据，
第一行输出一个整数，代表N个整数中的最大值，并将此值从数组中去除，将剩下的数进行排序。
第二行将排序的结果输出。
示例1
输入
4
1 3 4 2
输出
4
1 2 3
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
while(cin>>n)
{
int a[1001];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
if(n==1)
{
cout<<a[0]<<endl;
cout<<"-1"<<endl;
}
else
{
sort(a,a+n);
cout<<a[n-1]<<endl;
for(int i=0;i<n-1;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
}
}
return 0;
}
9、二叉树遍历
题目描述
二叉树的前序、中序、后序遍历的定义：
前序遍历：对任一子树，先访问跟，然后遍历其左子树，最后遍历其右子树；
中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树；
后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。
给定一棵二叉树的前序遍历和中序遍历，求其后序遍历（提示：给定前序遍历与中序遍历能够唯一确定后序遍历）
法一:不构建树，直接根据先序中序得到后序，可通过
#include<bits/stdc++.h>
using namespace std;
struct BinTree
{
char data;
BinTree* lchild;
BinTree* rchild;
};
char pre[27],in[27],post[27];
/*
root为当前⼦树的根结点在前序pre中的下标，start和end为当前⼦树的最左边和最右边的结点在中序in
中的下标。⽤index找到当前⼦树的根结点root在中序中的下标，然后左边和右边就分别为当前根结点root
的左⼦树和右⼦树。递归实现*/
void PostOrder(int s,int e,int root)
{
if(s>e)return;
int index=0;
while(in[index]!=pre[root])
index++;
PostOrder(s,index-1,root+1);
PostOrder(index+1,e,root+1+(index-s));
cout<<in[index];
}
int main()
{
while(~scanf("%s%s",pre,in))
{
int len=strlen(pre);
PostOrder(0,len-1,0);
printf("\n");
}
return 0;
}
法二:根据先序中序构建树，再后序遍历，样例全正确不知道为啥无法通过
#include<bits/stdc++.h>
using namespace std;
struct BinTree
{
char data;
BinTree* lchild;
BinTree* rchild;
};
char pre[27],in[27],post[27];
BinTree* Create(int preL,int preR,int inL,int inR)
{
if(preL>preR)
{
return NULL;//先序序列长度小于等于0时直接返回
}
BinTree* root = new BinTree;//新建结点
root->data=pre[preL];//根结点是先序遍历第一个结点
int k=inL;
while(in[k]!=pre[preL])//在中序序列中找到in[k]==pre[L]的结点
{
k++;
}
int numLeft = k - inL;//左子树结点个数
root->lchild = Create(preL+1,preL+numLeft,inL,k-1);
root->rchild = Create(preL+numLeft+1,preR,k+1,inR);
}
void PostOrder(BinTree* root)
{
if(root==NULL)
return;
PostOrder(root->lchild);
PostOrder(root->rchild);
printf("%c",root->data);
}
int main()
{
while(~scanf("%s%s",pre,in))
{
int len=strlen(pre);
BinTree* root=Create(0,len-1,0,len-1);
PostOrder(root);
printf("\n");
}
return 0;
}
10、奇偶校验
题目描述
输入一个字符串，然后对每个字符进行奇校验，最后输出校验后的二进制数(如’3’，输出：10110011)。
输入描述:
输入包括一个字符串，字符串长度不超过100。
输出描述:
可能有多组测试数据，对于每组数据，
对于字符串中的每一个字符，输出按题目进行奇偶校验后的数，每个字符校验的结果占一行。
示例1
输入
3
3a
输出
10110011
10110011
01100001
#include<bits/stdc++.h>
using namespace std;
void ji(char ch)
{
int x=ch;
int a[101];
int k=0;
do
{
a[k++]=x%2;
x/=2;
}while(x!=0);
int sum=0;
while(k<8)
{
a[k++]=0;
}
for(int i=k-1;i>=0;i--)
{
if(a[i]==1)
sum++;
}
if(sum%2==0)
{
for(int i=k-1;i>=0;i--)
{
if(a[i]==0)
{
a[i]=1;
break;
}
}
}
for(int i=k-1;i>=0;i--)
{
printf("%d",a[i]);
}
printf("\n");
}
int main()
{
char str[101];
while(~scanf("%s",str))
{
int len=strlen(str);
for(int i=0;i<len;i++)
{
ji(str[i]);
}
}
return 0;
}
11、最大的两个数
题目描述
输入一个四行五列的矩阵，找出每列最大的两个数。
输入描述:
接下来的四行每行包括五个整数。代表一个四行五列的矩阵，矩阵元素全部是整数。
输出描述:
可能有多组测试数据，对于每组数据，按照样例输出的格式将每列最大的两个数输出，如果最大的两个数中的一个数在这一列中有多个相同的值，则行值取行值小的那一个。
输出时要保留原矩阵的行列顺序，即在原矩阵中行值小的，在输出矩阵中的行值依然小。
示例1
输入
1
1 2 4 9 8
-1 4 9 8 8
12 9 8 7 0
7 8 9 7 0
输出
8 12 9 9 9
8 7 8 9 8
#include<bits/stdc++.h>
using namespace std;
#define min INT_MIN
int main()
{
int a[5][6];
while(~scanf("%d",&a[0][0]))//给的输入样例有问题
{
int res[2][5];
for(int i=0;i<4;i++)
{
for(int j=0;j<5;j++)
{
if(i==0&&j==0)continue;
scanf("%d",&a[i][j]);
}
}
int max1,max2,m1,m2;
for(int j=0;j<5;j++)
{
max1=max2=min;
for(int i=0;i<4;i++)
{
if(a[i][j]>max1)
{
max1=a[i][j];
m1=i;
}
}
for(int i=0;i<4;i++)
{
if(a[i][j]>max2&&m1!=i)
{
max2=a[i][j];
m2=i;
}
}
if(m1<m2)
{
res[0][j]=max1;
res[1][j]=max2;
}
else
{
res[0][j]=max2;
res[1][j]=max1;
}
}
for(int i=0;i<2;i++)
{
for(int j=0;j<5;j++)
{
printf("%d ",res[i][j]);
}
printf("\n");
}
}
return 0;
}
12、成绩排序
题目描述
有N个学生的数据，将学生数据按成绩从低到高排序，如果成绩相同则按姓名字符的字典序由小到大排序，如果姓名的字典序也相同则按照学生的年龄从小到大排序，并输出N个学生排序后的信息。
输入描述:
测试数据有多组，每组输入第一行有一个整数N（N<=1000），接下来的N行包括N个学生的数据。
每个学生的数据包括姓名（长度不超过100的字符串）、年龄（整形数）、成绩（小于等于100的正数）。
输出描述:
将学生信息按成绩进行排序，成绩相同的则按姓名的字母序进行排序。
然后输出学生信息，按照如下格式：
姓名 年龄 成绩
学生姓名的字母序区分字母的大小写，如A要比a的字母序靠前(因为A的ASC码比a的ASC码要小)。
示例1
输入
3
abc 20 99
bcd 19 97
bed 20 97
输出
bcd 19 97
bed 20 97
abc 20 99
#include<bits/stdc++.h>
using namespace std;
struct student{
char name[101];
int old;
int score;
}stu[1001];
bool cmp(student a,student b)
{
if(a.score!=b.score)return a.score<b.score;
else
{
if(strcmp(a.name,b.name)!=0)
{
return strcmp(a.name,b.name)<0;
}
else
{
return a.old<b.old;
}
}
}
int main(){
int n;
while(~scanf("%d",&n))
{
for(int i=0;i<n;i++)
{
scanf("%s %d %d",stu[i].name,&stu[i].old,&stu[i].score);
}
sort(stu,stu+n,cmp);
for(int i=0;i<n;i++)
{
printf("%s %d %d\n",stu[i].name,stu[i].old,stu[i].score);
}
}
return 0;
}
13、遍历链表
题目描述
建立一个升序链表并遍历输出。
输入描述:
输入的每个案例中第一行包括1个整数：n(1<=n<=1000)，接下来的一行包括n个整数。
输出描述:
可能有多组测试数据，对于每组数据，
将n个整数建立升序链表，之后遍历链表并输出。
示例1
输入
4
3 5 7 9
输出
3 5 7 9
#include<bits/stdc++.h>
using namespace std;
typedef struct LNode
{
int data;
struct LNode* next;
}LNode;
void Insert(LNode* L,int data)
{
LNode *node;
node=new LNode;
node->data=data;
node->next=NULL;
LNode *pre,*now;
now=L->next;
pre=L;
while(now!=NULL&&now->data<data)
{
pre=now;
now=now->next;
}
node->next=now;
pre->next=node;
}
int main()
{
int n;
LNode* C=new LNode;
while(~scanf("%d",&n))
{
int x;
C->next=NULL;
C->data=0;
for(int i=0;i<n;i++)
{
scanf("%d",&x);
Insert(C,x);
}
LNode* now=C->next;
while(now)
{
if(now->next==NULL)
{
printf("%d",now->data);
}
else
{
printf("%d ",now->data);
}
now=now->next;
}
printf("\n");
}
return 0;
}
14、守形数
题目描述
守形数是这样一种整数，它的平方的低位部分等于它本身。 比如25的平方是625，低位部分是25，因此25是一个守形数。 编一个程序，判断N是否为守形数。
输入描述:
输入包括1个整数N，2<=N<100。
输出描述:
可能有多组测试数据，对于每组数据，
输出"Yes!”表示N是守形数。
输出"No!”表示N不是守形数。
示例1
输入
25
4
输出
Yes!
No!
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
while(~scanf("%d",&n))
{
int a=n*n;
int diwei=0;
int k=1;
while(a>10)
{
diwei=diwei+(a%10)*k;
k=k*10;
a=a/10;
}
if(diwei==n)
printf("Yes!\n");
else
printf("No!\n");
}
return 0;
}
15、矩阵最大值
题目描述
编写一个程序输入一个mXn的矩阵存储并输出，并且求出每行的最大值和每行的总和。 要求把每行总和放入每行最大值的位置，如果有多个最大值，取下标值最小的那一个作为最大值。 最后将结果矩阵输出。
输入描述:
输入的第一行包括两个整数m和n(1<=m,n<=100)，分别代表矩阵的行和列的维数。
接下来的m行每行有n个数，代表矩阵的元素。
输出描述:
可能有多组测试数据，对于每组数据，输出按题目要求执行后的矩阵。
示例1
输入
3 3
1 1 1
1 1 1
1 1 1
3 3
3 2 3
2 3 2
3 2 3
输出
3 1 1
3 1 1
3 1 1
8 2 3
2 7 2
8 2 3
#include<bits/stdc++.h>
using namespace std;
#define min INT_MIN
int main()
{
int n,m;
while(~scanf("%d%d",&m,&n))
{
int a[101][101];
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
}
int Max,x,sum;
for(int i=0;i<m;i++)
{
sum=0;
Max=min;
for(int j=0;j<n;j++)
{
sum+=a[i][j];
if(a[i][j]>Max)
{
Max = a[i][j];
x = j;
}
}
a[i][x]=sum;
}
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
printf("%d ",a[i][j]);
}
printf("\n");
}
}
return 0;
}
16、最小年龄的三个职工
题目描述
职工有职工号，姓名，年龄.输入n个职工的信息，找出3个年龄最小的职工打印出来。
输入描述:
输入第一行包括1个整数N，1<=N<=30，代表输入数据的个数。
接下来的N行有N个职工的信息：
包括职工号(整数)， 姓名(字符串，长度不超过10)， 年龄(1<=age<=100)。
输出描述:
可能有多组测试数据，对于每组数据，
输出结果行数为N和3的较小值，分别为年龄最小的职工的信息。
关键字顺序：年龄>工号>姓名，从小到大。
示例1
输入
5
501 Jack 6
102 Nathon 100
599 Lily 79
923 Lucy 15
814 Mickle 65
输出
501 Jack 6
923 Lucy 15
814 Mickle 65
#include<bits/stdc++.h>
using namespace std;
#define min INT_MIN
struct staff
{
int id;
char name[11];
int age;
};
bool cmp(staff a,staff b)
{
if(a.age!=b.age)return a.age<b.age;
else
{
if(a.id!=b.id)return a.id<b.id;
else
return a.name<b.name;
}
}
int main()
{
int n;
while(~scanf("%d",&n))
{
staff s[31];
for(int i=0;i<n;i++)
{
scanf("%d%s%d",&s[i].id,s[i].name,&s[i].age);
}
int k=n>3?3:n;
sort(s,s+n,cmp);
for(int i=0;i<k;i++)
{
printf("%d %s %d\n",s[i].id,s[i].name,s[i].age);
}
}
return 0;
}
17、对称矩阵
题目描述
输入一个N维矩阵，判断是否对称。
输入描述:
输入第一行包括一个数：N(1<=N<=100)，表示矩阵的维数。
接下来的N行，每行包括N个数，表示N*N矩阵的元素。
输出描述:
可能有多组测试数据，对于每组数据，
输出"Yes!”表示矩阵为对称矩阵。
输出"No!”表示矩阵不是对称矩阵。
示例1
输入
4
16 19 16 6
19 16 14 5
16 14 16 3
6 5 3 16
2
1 2
3 4
输出
Yes!
No!
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
while(~scanf("%d",&n))
{
int a[101][101];
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
scanf("%d",&a[i][j]);
bool temp=true;
for(int j=0;j<n;j++)
{
for(int i=0;i<n;i++)
{
if(a[i][j]!=a[j][i])
{
temp=false;
break;
}
}
}
if(temp)
{
printf("Yes!\n");
}
else
{
printf("No!\n");
}
}
return 0;
}
18、A+B
题目描述
给定两个整数A和B，其表示形式是：从个位开始，每三位数用逗号","隔开。 现在请计算A+B的结果，并以正常形式输出。
输入描述:
输入包含多组数据数据，每组数据占一行，由两个整数A和B组成（-10^9 < A,B < 10^9）。
输出描述:
请计算A+B的结果，并以正常形式输出，每组数据占一行。
示例1
输入
-234,567,890 123,456,789
1,234 2,345,678
输出
-111111101
2346912
#include<bits/stdc++.h>
using namespace std;
long long toInt(char a[])
{
long long sum=0,j=1,i;
for(int i=strlen(a)-1;i>=0;i--)
{
if(a[i]>='0'&&a[i]<='9')
{
sum=sum+(a[i]-'0')*j;
j*=10;
}
}
if(a[0]=='-')
sum=-sum;
return sum;
}
int main()
{
char str1[101],str2[101];
long long A,B;
while(~scanf("%s%s",str1,str2))
{
A=toInt(str1);
B=toInt(str2);
printf("%lld\n",A+B);
}
return 0;
}
19、打印日期
题目描述
给出年分m和一年中的第n天，算出第n天是几月几号。
输入描述:
输入包括两个整数y(1<=y<=3000)，n(1<=n<=366)。
输出描述:
可能有多组测试数据，对于每组数据，
按 yyyy-mm-dd的格式将输入中对应的日期打印出来。
示例1
输入
2000 3
2000 31
2000 40
2000 60
2000 61
2001 60
输出
2000-01-03
2000-01-31
2000-02-09
2000-02-29
2000-03-01
2001-03-01
#include<bits/stdc++.h>
using namespace std;
bool isLeap(int year)
{
if(year%4==0&&year%100!=0||year%400==0)
{
return true;
}
else
return false;
}
int main()
{
int month[13][2]={{0,0},{31,31},{28,29},{31,31},{30,30},{31,31},{30,30},{31,31},{31,31},{30,30},{31,31},{30,30},{31,31}};
int y,n;
int m,d;
while(~scanf("%d %d",&y,&n))
{
d=0;
m=1;
while(n>0)
{
d++;
if(d==month[m][isLeap(y)]+1)
{
m++;
d=1;
}
if(m==13)
{
y++;
m=1;
}
n--;
}
printf("%04d-%02d-%02d\n",y,m,d);
}
return 0;
}
20、二叉排序树
题目描述
输入一系列整数，建立二叉排序树，并进行前序，中序，后序遍历。
输入描述:
输入第一行包括一个整数n(1<=n<=100)。
接下来的一行包括n个整数。
输出描述:
可能有多组测试数据，对于每组数据，将题目所给数据建立一个二叉排序树，并对二叉排序树进行前序、中序和后序遍历。
每种遍历结果输出一行。每行最后一个数据之后有一个空格。
输入中可能有重复元素，但是输出的二叉树遍历序列中重复元素不用输出。
示例1
输入
5
1 6 5 9 8
输出
1 6 5 9 8
1 5 6 8 9
5 8 9 6 1
#include<bits/stdc++.h>
using namespace std;
typedef struct Node
{
int data;
struct Node* lchild;
struct Node* rchild;
}Node,*BinTree;
void PreOrder(BinTree root)
{
if(root==NULL)return;
printf("%d ",root->data);
PreOrder(root->lchild);
PreOrder(root->rchild);
}
void InOrder(BinTree root)
{
if(root==NULL)return;
InOrder(root->lchild);
printf("%d ",root->data);
InOrder(root->rchild);
}
void PostOrder(BinTree root)
{
if(root==NULL)return;
PostOrder(root->lchild);
PostOrder(root->rchild);
printf("%d ",root->data);
}
void Insert(BinTree &root,int data)
{
if(root==NULL)
{
root = new Node;
root->data=data;
root->lchild=root->rchild=NULL;
return;
}
if(data<root->data)
{
Insert(root->lchild,data);
}
else if(data>root->data)
{
Insert(root->rchild,data);
}
}
int main()
{
int n;
while(~scanf("%d",&n))
{
int x;
BinTree root=NULL;
for(int i=0;i<n;i++)
{
scanf("%d",&x);
Insert(root,x);
}
PreOrder(root);
printf("\n");
InOrder(root);
printf("\n");
PostOrder(root);
printf("\n");
}
return 0;
}
21、大整数排序
题目描述
对N个长度最长可达到1000的数进行排序。
输入描述:
输入第一行为一个整数N，(1<=N<=100)。
接下来的N行每行有一个数，数的长度范围为1<=len<=1000。
每个数都是一个正数，并且保证不包含前缀零。
输出描述:
可能有多组测试数据，对于每组数据，将给出的N个数从小到大进行排序，输出排序后的结果，每个数占一行。
示例1
输入
3
11111111111111111111111111111
2222222222222222222222222222222222
33333333
输出
33333333
11111111111111111111111111111
2222222222222222222222222222222222
#include<bits/stdc++.h>
using namespace std;
struct bign
{
int d[1001];
int len;
bign()
{
memset(d,0,sizeof(d));
len=0;
}
}big[101];
bign change(char str[])
{
bign c;
c.len=strlen(str);
for(int i=0;i<c.len;i++)
{
c.d[i]=str[c.len-1-i]-'0';
}
return c;
}
bool cmp(bign a,bign b)
{
if(a.len!=b.len)return a.len<b.len;
else
{
for(int i=a.len-1;i>=0;i--)
{
if(a.d[i]!=b.d[i])
return a.d[i]<b.d[i];
}
}
}
void print(bign a)
{
for(int i=a.len-1;i>=0;i--)
{
printf("%d",a.d[i]);
}
printf("\n");
}
int main()
{
int n;
while(~scanf("%d",&n))
{
char str[1001];
for(int i=0;i<n;i++)
{
scanf("%s",str);
big[i]=change(str);
}
sort(big,big+n,cmp);
for(int i=0;i<n;i++)
{
print(big[i]);
}
}
return 0;
}
22、N阶楼梯上楼问题
题目描述
N阶楼梯上楼问题：一次可以走两阶或一阶，问有多少种上楼方式。（要求采用非递归）
输入描述:
输入包括一个整数N,(1<=N<90)。
输出描述:
可能有多组测试数据，对于每组数据，
输出当楼梯阶数是N时的上楼方式个数。
示例1
输入
4
输出
5
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
int t[90] = {};
while (cin >> n){
for (int i = 0; i < n; i++){
if (i == 0) t[i] = 1;
else if (i == 1) t[i] = 2;
else t[i] = t[i - 1] + t[i - 2];
}
cout << t[n - 1] << endl;
}
return 0;
}
23、a+b
题目描述
计算a+b的和
每行包含两个整数a和b
对于每行输入对应输出一行a和b的和
输入
1 5
输出
6
#include<stdio.h>
int main()
{
int a,b;
while(~scanf("%d %d",&a,&b))
{
printf("%d\n",a+b);
}
return 0;
}
24、回文字符串
题目描述
给出一个长度不超过1000的字符串，判断它是不是回文(顺读，逆读均相同)的。
输入描述:
输入包括一行字符串，其长度不超过1000。
输出描述:
可能有多组测试数据，对于每组数据，如果是回文字符串则输出"Yes!”，否则输出"No!"。
示例1
输入
hellolleh
helloworld
输出
Yes!
No!
#include<bits/stdc++.h>
using namespace std;
bool Judge(char a[])
{
int len=strlen(a);
for(int i=0;i<=len/2;i++)
{
if(a[i]!=a[len-1-i])
{
return false;
}
}
return true;
}
int main()
{
char str[1001];
while(scanf("%s",str)!=EOF)
{
if(Judge(str))
printf("Yes!\n");
else
printf("No!\n");
}
return 0;
}
25、找位置
题目描述
对给定的一个字符串，找出有重复的字符，并给出其位置，如：abcaaAB12ab12 输出：a，1；a，4；a，5；a，10，b，2；b，11，1，8；1，12， 2，9；2，13。
输入描述:
输入包括一个由字母和数字组成的字符串，其长度不超过100。
输出描述:
可能有多组测试数据，对于每组数据，
按照样例输出的格式将字符出现的位置标出。
1、下标从0开始。
2、相同的字母在一行表示出其出现过的位置。
示例1
输入
abcaaAB12ab12
输出
a:0,a:3,a:4,a:9
b:1,b:10
1:7,1:11
2:8,2:12
#include<bits/stdc++.h>
using namespace std;
int main()
{
char str[101];
while(~scanf("%s",str))
{
int loc[101];//处理过的位置标1
memset(loc,0,sizeof(loc));
for(int i=0;i<strlen(str);i++)
{
if(loc[i]==1)continue;
vector<int> v;//里面放下标
v.push_back(i);
for(int j=i+1;j<strlen(str);j++)
{
if(str[i]==str[j])
{
loc[j]=1;
v.push_back(j);
}
}
if(v.size()>1)
{
for(int k=0;k<v.size();k++)
{
printf("%c:%d",str[i],v[k]);
if(k!=v.size()-1)printf(",");
}
printf("\n");
}
}
}
return 0;
}
26、阶乘
题目描述
输入n， 求y1=1!+3!+…m!(m是小于等于n的最大奇数） y2=2!+4!+…p!(p是小于等于n的最大偶数)。
输入描述:
每组输入包括1个整数：n
输出描述:
可能有多组测试数据，对于每组数据，
输出题目要求的y1和y2
示例1
输入
4
输出
7 26
#include<bits/stdc++.h>
using namespace std;
int F(int n)
{
if(n==0)return 1;
else return F(n-1)*n;
}
int main()
{
int n;
while(~scanf("%d",&n))
{
int m,p;
if(n%2==0)
{
p=n;
m=n-1;
}
else
{
m=n;
p=n-1;
}
long long y1=0,y2=0;
for(int i=1;i<=m;i++)
{
if(i%2!=0)
{
y1+=F(i);
}
}
for(int i=2;i<=p;i++)
{
if(i%2==0)
{
y2+=F(i);
}
}
printf("%lld %lld\n",y1,y2);
}
return 0;
}
27、八进制
题目描述
输入一个整数，将其转换成八进制数输出。
输入描述:
输入包括一个整数N(0<=N<=100000)。
输出描述:
可能有多组测试数据，对于每组数据，
输出N的八进制表示数。
示例1
输入
7
8
9
输出
7
10
11
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
//方法一：
//printf("%o\n",n);
/方法二:
//十进制转八进制
stack<int> res;
do
{
res.push(n%8);
n=n/8;
}
while(n!=0);
while(!res.empty())
{
printf("%d",res.top());
res.pop();
}
cout<<endl;
}
return 0;
}
28、最长最短文本
题目描述
输入多行字符串，请按照原文本中的顺序输出其中最短和最长的字符串，如果最短和最长的字符串不止一个，请全部输出。
输入描述:
输入包括多行字符串，字符串的长度len(1<=len<=1000)。
输出描述:
按照原文本中的顺序输出其中最短和最长的字符串，如果最短和最长的字符串不止一个，请全部输出。
示例1
输入
hello
she
sorry
he
输出
he
hello
sorry
#include<bits/stdc++.h>
using namespace std;
bool cmp(string s1,string s2)
{
return s1.size()<s2.size();
}
int main(){
string str;
vector<string> v;
while(getline(cin,str))
{
v.push_back(str);
}
sort(v.begin(),v.end(),cmp);
int Min=v[0].size();
int Max=v[v.size()-1].size();
for(int i=0;i<v.size();i++)
{
if(v[i].size()==Min)
cout<<v[i]<<endl;
}
for(int i=0;i<v.size();i++)
{
if(v[i].size()==Max)
cout<<v[i]<<endl;
}
return 0;
}
29、农夫、羊、菜和狼的故事
题目描述
有一个农夫带一只羊、一筐菜和一只狼过河。如果没有农夫看管，则狼要吃羊，羊要吃菜。但是船很小，只够农夫带一样东西过河。问农夫该如何解此难题？
输入描述:
题目没有任何输入。
输出描述:
题目可能有种解决方法，求出步骤最少的解决方法，
按顺序输出农夫想把羊、菜、狼全部运过河需要哪几个步骤。
如果需要将羊带过河去则输出“sheep_go”。
如果需要将羊带回来则输出“sheep_come”。
如果需要将菜带过河去则输出“vegetable_go”。
如果需要将菜带回来则输出“vegetable_come”。
如果需要将狼带过河去则输出“wolf_go”。
如果需要将狼带回来则输出“wolf_come”。
如果需要空手返回则输出“nothing_come”。
如果需要空手过河则输出“nothing_go”。
每输出一种方案，输出一行“succeed”。
#include<stdio.h>
int main(){
printf("sheep_go\n");
printf("nothing_come\n");
printf("vegetable_go\n");
printf("sheep_come\n");
printf("wolf_go\n");
printf("nothing_come\n");
printf("sheep_go\n");
printf("succeed\n");
return 0;
}
扫一扫
2500
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
