链接:https://www.nowcoder.com/ta/hust-kaoyan
这里不做详细说明了,可以练练手,代码有的写的并不一定是最优解,仅供参考
矩阵转置
/***
题目描述
输入一个N*N的矩阵,将其转置后输出。要求:不得使用任何其他数组(就地逆置)。
输入描述:
输入的第一行包括一个整数N,(1<=N<=100),代表矩阵的维数。
接下来的N行每行有N个整数,分别代表矩阵的元素。
输出描述:
可能有多组测试数据,对于每组数据,将输入的矩阵转置后输出。
示例1
输入
3
1 2 3
4 5 6
7 8 9
输出
1 4 7
2 5 8
3 6 9
***/
#include
#include
using namespace std;
int main()
{
int ant[105][105];
int n;
while(scanf("%d",&n)!=EOF)
{
for(int i=0;i
统计单词
/***
题目描述
编一个程序,读入用户输入的,以“.”结尾的一行文字,统计一共有多少个单词,并分别输出每个单词含有多少个字符。 (凡是以一个或多个空格隔开的部分就为一个单词)
输入描述:
输入包括1行字符串,以“.”结束,字符串中包含多个单词,单词之间以一个或多个空格隔开。
输出描述:
可能有多组测试数据,对于每组数据,
输出字符串中每个单词包含的字母的个数。
示例1
输入
hello how are you.
输出
5 3 3 3
****/
#include
#include
#include
#include
using namespace std;
int main()
{
char str[1000007];
while(gets(str))
{
int len = strlen(str);
int cnt = 0;
if (str[len-1]!='.') continue;
for(int i=0;i 0)
printf("%d",cnt);
printf("\n");
break;
}
if (str[i]==' ')
{
if (cnt > 0)
printf("%d ",cnt);
cnt=0;
}
else cnt++;
}
}
return 0;
}
IP地址
/***
题目描述
输入一个ip地址串,判断是否合法。
输入描述:
输入的第一行包括一个整数n(1<=n<=500),代表下面会出现的IP地址的个数。
接下来的n行每行有一个IP地址,IP地址的形式为a.b.c.d,其中a、b、c、d都是整数。
输出描述:
可能有多组测试数据,对于每组数据,如果IP地址合法则输出"Yes!”,否则输出"No!”。
合法的IP地址为:
a、b、c、d都是0-255的整数。
示例1
输入
2
255.255.255.255
512.12.2.3
输出
Yes!
No!
***/
#include
#include
#include
#include
using namespace std;
int main()
{
int n;
scanf("%d",&n);
while(n--)
{
char str[25];
scanf("%s",str);
//cout<<"str = "<255){bo = false; break;}
ans = 0;
}
else if(str[i] >= '0' and str[i] <= '9')
{
ans = ans * 10 + str[i] - '0';
}
}
if(bo and (ans<0 or ans>255)) bo = false;
if (bo) printf(" Yes!\n"); else printf("No!\n"); } } * #include
int main()
{
int ip[4];
int n;
while (scanf("%d", &n) != EOF)
{
for (int i = 0; i < n; i++)
{
scanf("%d.%d.%d.%d", &ip[0], &ip[1], &ip[2], &ip[3]);
bool flag = true;
for (int j = 0; j < 4; j++)
{
if (ip[j] < 0 || ip[j] > 255)
{
flag = false;
break;
}
}
if (flag)
printf("Yes!\n");
else
printf("No!\n");
}
}
return 0;
}
*/
二叉排序树
/**
题目描述
二叉排序树,也称为二叉查找树。可以是一颗空树,也可以是一颗具有如下特性的非空二叉树:
1. 若左子树非空,则左子树上所有节点关键字值均不大于根节点的关键字值;
2. 若右子树非空,则右子树上所有节点关键字值均不小于根节点的关键字值;
3. 左、右子树本身也是一颗二叉排序树。
现在给你N个关键字值各不相同的节点,要求你按顺序插入一个初始为空树的二叉排序树中,
每次插入后成功后,求相应的父亲节点的关键字值,如果没有父亲节点,则输出-1。
输入描述:
输入包含多组测试数据,每组测试数据两行。
第一行,一个数字N(N<=100),表示待插入的节点数。
第二行,N个互不相同的正整数,表示要顺序插入节点的关键字值,这些值不超过10^8。
输出描述:
输出共N行,每次插入节点后,该节点对应的父亲节点的关键字值。
示例1
输入
5
2 5 1 3 4
输出
-1
2
2
5
3
**/
#include
#include
#include
#include
using namespace std;
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};
void createTree(TreeNode* &node,int num,int parent)
{
if(node == NULL)
{
printf("%d\n",parent);
node = new TreeNode(num);
}
else
{
if(num > node->val)
{
createTree(node->left,num,node->val);
}
else
{
createTree(node->right,num,node->val);
}
}
}
void destory(TreeNode* &node)
{
if(node)
{
destory(node->left);
destory(node->right);
delete node;
}
}
int main()
{
int n,num;
while(scanf("%d",&n)!=EOF)
{
TreeNode *root = NULL;//初始化(否则会变成悬垂指针)
for(int i=0;i
字符串连接
/**
题目描述
不借用任何字符串库函数实现无冗余地接受两个字符串,然后把它们无冗余的连接起来。
输入描述:
每一行包括两个字符串,长度不超过100。
输出描述:
可能有多组测试数据,对于每组数据,
不借用任何字符串库函数实现无冗余地接受两个字符串,然后把它们无冗余的连接起来。
输出连接后的字符串。
示例1
输入
abc def
输出
abcdef
**/
//无冗余...没理解
#include
#include
#include
#include
using namespace std;
int main()
{
string str1,str2;
while(cin>>str1>>str2)
cout<
a+b
输入包括两个数a和b,其中a和b的位数不超过1000位。
可能有多组测试数据,对于每组数据, 输出a+b的值。
2 6 10000000000000000000 10000000000000000000000000000000
8 10000000000010000000000000000000
写了一个大数模板,大数加法,大数减法,大数乘法和大数除法,这里是写好后代入的。虽然看起来有点麻烦,但是模板是可以重复利用的。哈~完善之后再发详细的。
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define System 1000000 //
class BigNumber{
public:
string x,y;
int op; //运算 1:+; -1:-; 2:*; -2:/
int posx,posy;
int oop;//符号位 1: + ; -1: - ;
int opx,opy;// 先取x,y的符号
int dim; //进位
BigNumber(string xx,string yy):
x(xx), y(yy), op(1), posx(0),posy(0),oop(1),opx(1),opy(1),dim(0) {}
BigNumber(string xx,string yy,int ope):
x(xx), y(yy), op(ope), posx(0),posy(0),oop(1),opx(1),opy(1),dim(0) {}
vector res;
vector remainder;//余数
string subX,subY;
bool SwapXY()
{
if(x.size()>0 and y.size()>0)//x,y 非空
{
//cout<<"S: operate: ans = "< |y|
{
if ( opx < 0 ) // -x + y = -(x-y)
{
oop = -1;
op = -1;
}
}
}
else if(op == -1) // -
{// -x - y || x - y
if(lenX < lenY || (lenX == lenY && subX < subY)) // |x| < |y|
{
oop = -1; // x - y = - (y - x) || -x - y = -(y+x)
if (opx < 0) op = 1;
subX.swap(subY);
}
else if(lenX == lenY && subX == subY) // |x| == |-y|
{
if (opx > 0)
{
oop = 1;
res.push_back(0); // x - y = 0
return false;
}
else // -x -y = -(x+y) ; -5 - 5 = -(5+5) = -10
{
oop = -1;
op = 1;
}
}
else //|x| > |y|
{
if(opx < 0) // -x -y = -(x+y) ; -10 - 5 = -(10+5) = -15
{
oop = -1;
op = 1;
}
}
}
else if(op == 2 || op == -2)
{
if(opx * opy < 0) { oop = -1;} //一正一负
else { oop = 1;}//两正数,两负数
if(op == -2 && lenX == lenY && subX == subY) // |x| == |-y|
{
res.push_back(1); // x - y = 0
return false;
}
}
//cout<<" L: subX="< arr(X.size()+Y.size()) ;// 位数K = x + y;
res.resize(X.size()+Y.size()); //重划定大小
vector::iterator it;
for(int i = 0;i < X.size();i++)
{
for(int j = 0;j < Y.size();j++)
{
res[i+j] += (*(ritX+i) - '0') * (*(ritY+j) - '0');//从左到右 相乘 相加
}
}
for(it = res.begin();it < res.end();++it)
{
*it = (*it) + dim;
dim = (*it) / 10;
*it = (*it) % 10;
}
/*
int p = 0;
for(it = arr.begin();it Y)
{
solveXY(sub_X,Y,0,ans);
}
else if(sub_X == Y)
{
res.push_back(1);
ans.clear();
}
else //sub_X < Y
{
ans = sub_X;
}
//cout<<"Second: sub_X = "< Y
{
//cout<<"Divide_Subtract: "<= 0;i--)
{
if(rem[i]-'0' == 0) { dy++; continue; }
else break;
}
rem = rem.substr(0,sm-dy);
//cout<<"处理余数 :";
d++;
for(int i = rem.length()-1;i >= 0;i--)
{
//cout<>str1>>str2)
{
BigNumber bn(str1,str2);
//cout<::reverse_iterator it = bn.res.rbegin() ; it != bn.res.rend(); ++it)
cout<< *it;
cout<
排序
/**
题目描述
对输入的n个数进行排序并输出。
输入描述:
输入的第一行包括一个整数n(1<=n<=100)。
接下来的一行包括n个整数。
输出描述:
可能有多组测试数据,对于每组数据,将排序后的n个整数输出,每个数后面都有一个空格。
每组测试数据的结果占一行。
示例1
输入
4
1 4 3 2
输出
1 2 3 4
**/
#include
#include
#include
#include
#include
#include
using namespace std;
#define MAXN 105
int main()
{
int N;
while(scanf("%d",&N) != EOF)
{
vector arr;
for(int i=0;i::iterator iter;
sort(arr.begin(),arr.end());
for(iter = arr.begin();iter < arr.end();iter++)
{
cout<<*iter<<" ";
}
cout<
有空再补一个快排手写的。
特殊排序
/**
题目描述
输入一系列整数,将其中最大的数挑出,并将剩下的数进行排序。
输入描述:
输入第一行包括1个整数N,1<=N<=1000,代表输入数据的个数。
接下来的一行有N个整数。
输出描述:
可能有多组测试数据,对于每组数据,
第一行输出一个整数,代表N个整数中的最大值,并将此值从数组中去除,将剩下的数进行排序。
第二行将排序的结果输出。
示例1
输入
4
1 3 4 2
输出
4
1 2 3
**/
#include
#include
#include
#include
#include
#include
using namespace std;
#define MAXN 105
int main()
{
int N;
while(scanf("%d",&N) != EOF)
{
vector arr;
for(int i=0;i::iterator iter = arr.end();
sort(arr.begin(),arr.end());
cout<<*(iter-1)<
二叉树遍历
/***
题目描述
二叉树的前序、中序、后序遍历的定义:
前序遍历:对任一子树,先访问跟,然后遍历其左子树,最后遍历其右子树;
中序遍历:对任一子树,先遍历其左子树,然后访问根,最后遍历其右子树;
后序遍历:对任一子树,先遍历其左子树,然后遍历其右子树,最后访问根。
给定一棵二叉树的前序遍历和中序遍历,求其后序遍历(提示:给定前序遍历与中序遍历能够唯一确定后序遍历)。
输入描述:
两个字符串,其长度n均小于等于26。
第一行为前序遍历,第二行为中序遍历。
二叉树中的结点名称以大写字母表示:A,B,C....最多26个结点。
输出描述:
输入样例可能有多组,对于每组测试样例,
输出一行,为后序遍历的字符串。
示例1
输入
ABC
BAC
FDXEAG
XDEFAG
输出
BCA
XEDGAF
**/
// http://blog.csdn.net/u010579068/article/details/48416491
#include
#include
#include
#include
#include
using namespace std;
struct TreeNode{
TreeNode *left;
TreeNode *right;
char val;
TreeNode(char x):
val(x), left(NULL), right(NULL) {
}
}*root;
string preTree,midTree;
TreeNode *Create(string::iterator pTree, string::iterator mTree,int len)
{
TreeNode *node;
for(int i=0;ileft = Create(pTree+1,mTree,i); //左 XDE
node->right = Create(pTree+i+1,mTree+i+1,len-i-1); //右 AG
return node;
}
}
return NULL; //退出条件
}
void PrintTree(TreeNode *head)
{
if(head == NULL) return ;
PrintTree(head->left);
PrintTree(head->right);
if(head == root)//最后一个
cout<val<val;
}
void destory(TreeNode* &node)
{
if(node)
{
destory(node->left);
destory(node->right);
delete(node);
}
}
int main()
{
while(cin>>preTree>>midTree)
{
//前序定根,中序定左右
if(preTree.size() == midTree.size())
{
root = Create(preTree.begin(),midTree.begin(),midTree.size());
PrintTree(root);
destory(root);
}
}
return 0;
}
奇偶校验
/***
题目描述
输入一个字符串,然后对每个字符进行奇校验,最后输出校验后的二进制数(如'3',输出:10110011)。
输入描述:
输入包括一个字符串,字符串长度不超过100。
输出描述:
可能有多组测试数据,对于每组数据,
对于字符串中的每一个字符,输出按题目进行奇偶校验后的数,每个字符校验的结果占一行。
示例1
输入
3
3a
输出
10110011
10110011
01100001
**/
/**思想就是:转为2进制后1的个数为偶数最高位要补1,注意ascii码最大就是127*/
#include
#include
#include
#include
#include
using namespace std;
int main()
{
char c;
bitset<8> bit;
while(cin>>c)
{
if(c == ' ' || c == '\n') continue;
bit = c;//转ASCII码,
//printf("%d\n",c);
if((bit.count()&1) == 0) bit.set(7);//偶数位,最高位变1
cout<
最大的两个数
/**
题目描述
输入一个四行五列的矩阵,找出每列最大的两个数。
输入描述:
输入第一行包括一个整数n(1<=n<=1000),接下来有n个四行每行包括五个整数。代表一个四行五列的矩阵,矩阵元素全部是整数。
输出描述:
可能有多组测试数据,对于每组数据,按照样例输出的格式将每列最大的两个数输出,如果最大的两个数中的一个数在这一列中有多个相同的值,则行值取行值小的那一个。
输出时要保留原矩阵的行列顺序,即在原矩阵中行值小的,在输出矩阵中的行值依然小。
示例1
输入
2
1 2 4 9 8
-1 4 9 8 8
12 9 8 7 0
7 8 9 7 0
1 8 4 9 8
-1 4 9 8 8
12 9 8 7 0
7 8 9 7 0
输出
12 9 9 9 8
7 8 9 8 8
12 8 9 9 8
7 9 9 8 8
**/
/**解:最关键是每列最大两个数的行顺序不变,还有个坑最后换行前有空格**/
#include
#include
#include
using namespace std;
#define row 4
#define column 5
void solve(int &x1,int &x2,int x)
{
if(x1 > x2)
{
if(x >= x1) x2 = x;
else if(x > x2 && x < x1) x2 = x;
}
else if(x1 == x2)
{
if(x > x1) x2 = x;
}
else // x1 < x2
{
if(x >= x2) {x1 = x2; x2 = x;}
else if(x > x1 && x < x2) {x1 = x2; x2 = x;}
}
}
int main()
{
int n;
while(cin>>n)
{
for(int t=0;t S;
for(int i=0;i>ans[i][j];
if(i<2) res[i][j] = ans[i][j];
}
}
for(int j=0;j
成绩排序
/***
题目描述
有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
#include
#include
#include
#include
#include
using namespace std;
struct Info{
string name;
int age;
int grade;
Info(string N,int x,int y):
name(N), age(x),grade(y) {
}
};
bool comp (Info A,Info B)
{
if(A.grade == B.grade)
{
if(A.name == B.name)
{
return A.age < B.age;
}
return A.name < B.name;
}
return A.grade < B.grade;
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
vector arr;
string str;
int a,g;
for(int i=0;i>str>>a>>g;
Info in(str,a,g);
arr.push_back(in);
}
sort(arr.begin(),arr.end(),comp);
for(vector::iterator iter = arr.begin();iter
遍历链表
/**
题目描述
建立一个升序链表并遍历输出。
输入描述:
输入的每个案例中第一行包括1个整数:n(1<=n<=1000),接下来的一行包括n个整数。
输出描述:
可能有多组测试数据,对于每组数据,
将n个整数建立升序链表,之后遍历链表并输出。
示例1
输入
4
3 5 7 9
输出
3 5 7 9
**/
//感觉这题是要考链表的排序吗?O((n+1)n/2) = O(n^2)
#include
#include
#include
#include
using namespace std;
struct LNode{
LNode *next;
int data;
LNode(int x):
data(x), next(NULL){
}
};
void Insert_LNode(LNode * &head,int num)
{
LNode *pre = head;
LNode *p = pre->next;
LNode *L = new LNode(num);
//if(p == NULL){ pre->next = L; return ;}
while(p)
{
if(p->data < num)
{
pre = pre -> next;
p = p -> next;
}
else break;
}
//cout<data< next = L;
pre -> next -> next = p;
}
void Print_LNode(LNode * head)
{
while(head)
{
if(head->next == NULL) cout<data<data<<" ";
head = head -> next;
}
}
void Clear_LNode(LNode* &node)
{
if(node)
{
Clear_LNode(node->next);
delete(node);
}
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
LNode *root = new LNode(INT_MIN); //#include
int num;
for(int i=0;inext);
Clear_LNode(root);
}
return 0;
}
守形数
/**
题目描述
守形数是这样一种整数,它的平方的低位部分等于它本身。
比如25的平方是625,低位部分是25,因此25是一个守形数。 编一个程序,判断N是否为守形数。
输入描述:
输入包括1个整数N,2<=N<100。
输出描述:
可能有多组测试数据,对于每组数据,
输出"Yes!”表示N是守形数。
输出"No!”表示N不是守形数。
示例1
输入
25
4
输出
Yes!
No!
**/
#include
#include
#include
using namespace std;
int main()
{
int N;
while(scanf("%d",&N)!=EOF)
{
if(N*N%100 == N || N*N%10 == N) printf("Yes!\n"); //其实只有5,6,25和76
else printf("No!\n");
}
return 0;
}
矩阵最大值
/**
题目描述
编写一个程序输入一个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
#include
#include
#include
using namespace std;
#define MAXN 105
int main()
{
int arr[MAXN][MAXN];
int m,n;
while(scanf("%d%d",&m,&n)!=EOF)
{
for(int i=0;i
最小年龄的3个职工
/**
题目描述
职工有职工号,姓名,年龄.输入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
#include
#include
#include
#include
#include
using namespace std;
struct StaffInfo{
int staffID;
string name;
int age;
StaffInfo(int id,string n,int old):
staffID(id), name(n), age(old) {
}
};
bool comp (StaffInfo A,StaffInfo B)
{
if(A.age == B.age)
{
if(A.staffID == B.staffID)
{
return A.name < B.name;
}
return A.staffID < B.staffID;
}
return A.age < B.age;
}
int main()
{
int N;
while(scanf("%d",&N)!=EOF)
{
int age,id;
string name;
vector arr;
for(int i=0;i>id>>name>>age;
StaffInfo info(id,name,age);
arr.push_back(info);
}
sort(arr.begin(),arr.end(),comp);
for(int i=0;i
对称矩阵
/**
题目描述
输入一个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!
**/
//对称矩阵,貌似只要考虑 arr[i][j] == ar[j][i],有时候不能想太多啊....
#include
#include
using namespace std;
int main()
{
int N; //1<=N<=100
while(scanf("%d",&N)!=EOF)
{
int arr[N][N];
for(int i=0;i
A+B
/****
给定两个整数A和B,其表示形式是:从个位开始,每三位数用逗号","隔开。 现在请计算A+B的结果,并以正常形式输出。
输入描述:
输入包含多组数据数据,每组数据占一行,由两个整数A和B组成(-10^9 < A,B < 10^9)。
输出描述:
请计算A+B的结果,并以正常形式输出,每组数据占一行。
输入例子:
-234,567,890 123,456,789
1,234 2,345,678
输出例子:
-111111101
2346912
*******/
#include
#include
#include
#include
#include
using namespace std;
#define LL long long
LL changeLL(char (&x)[20])
{
int op = 1; //+
int len = strlen(x);
LL xi = 0;
for(int i=0;i
打印日期
/**
题目描述
给出年分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
#include
using namespace std;
int monthDay[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
int main()
{
int year,day;
while(scanf("%d%d",&year,&day)!=EOF)
{
if(year%4==0&&year%100!=0 || year%400==0) monthDay[2] = 29;
else monthDay[2] = 28;
int month = 1;
for(;month<13;month++)
{
if(day <= monthDay[month]) break;
day -= monthDay[month];
}
printf("%04d-%02d-%02d\n",year,month,day);
}
return 0;
}
二叉树排序
/**
题目描述
输入一系列整数,建立二叉排序数,并进行前序,中序,后序遍历。
输入描述:
输入第一行包括一个整数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
#include
#include
#include
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int v):
val(v), left(NULL), right(NULL) {
}
};
void createTree(TreeNode * &p,int num)
{
if(p==NULL) {p = new TreeNode(num); return;}
if(p->val > num) createTree(p->left,num);
else if(p->val < num) createTree(p->right,num);
else return ;
}
//前序遍历 :根左右
void PreorderTraversal(TreeNode *p)
{
if(p==NULL) return;
printf("%d ",p->val);
PreorderTraversal(p->left);
PreorderTraversal(p->right);
}
//中序遍历 :左根右
void InorderTraversal(TreeNode *p)
{
if(p==NULL) return;
InorderTraversal(p->left);
printf("%d ",p->val);
InorderTraversal(p->right);
}
//后序遍历 :左右根
void PostorderTraversal(TreeNode *p)
{
if(p==NULL) return;
PostorderTraversal(p->left);
PostorderTraversal(p->right);
printf("%d ",p->val);
}
void destoryTree(TreeNode * &p)
{
if(p == NULL) return;
destoryTree(p->left);
destoryTree(p->right);
delete p;
}
void PrintTree(TreeNode * &p)
{
PreorderTraversal(p); //前序遍历
cout<
大整数排序
/**
题目描述
对N个长度最长可达到1000的数进行排序。
输入描述:
输入第一行为一个整数N,(1<=N<=100)。
接下来的N行每行有一个数,数的长度范围为1<=len<=1000。
每个数都是一个正数,并且保证不包含前缀零。
输出描述:
可能有多组测试数据,对于每组数据,将给出的N个数从小到大进行排序,输出排序后的结果,每个数占一行。
示例1
输入
3
11111111111111111111111111111
2222222222222222222222222222222222
33333333
输出
33333333
11111111111111111111111111111
2222222222222222222222222222222222
**/
//不用处理负数和前导0...
#include
#include
#include
#include
#include
using namespace std;
#define MAXN 105
bool comp(string a,string b)
{
if(a.size() == b.size()) return a < b;
return a.size() < b.size();
}
int main()
{
int N;
while(cin>>N)
{
string str[MAXN];
for(int i=0;i>str[i];
}
sort(str,str+N,comp);
for(int i=0;i
N阶楼梯上楼问题
/**
题目描述
N阶楼梯上楼问题:一次可以走两阶或一阶,问有多少种上楼方式。(要求采用非递归)
输入描述:
输入包括一个整数N,(1<=N<90)。
输出描述:
可能有多组测试数据,对于每组数据,
输出当楼梯阶数是N时的上楼方式个数。
示例1
输入
4
输出
5
**/
//打表
#include
#include
using namespace std;
#define MAXN 90
long long arr[MAXN];
void init()
{
arr[1] = 1;
arr[2] = 2;
for(int i=3;i
a+b
/**
题目描述
计算a+b的和
每行包行两个整数a和b
对于每行输入对应输出一行a和b的和
输入
1 5
输出
6
**/
#include
#include
#include
#include
#include
using namespace std;
#define LL long long
LL changeLL(char (&x)[20])
{
int op = 1; //+
int len = strlen(x);
LL xi = 0;
for(int i=0;i
回文字符串
/***
题目描述
给出一个长度不超过1000的字符串,判断它是不是回文(顺读,逆读均相同)的。
输入描述:
输入包括一行字符串,其长度不超过1000。
输出描述:
可能有多组测试数据,对于每组数据,如果是回文字符串则输出"Yes!”,否则输出"No!"。
示例1
输入
hellolleh
helloworld
输出
Yes!
No!
**/
#include
#include
#include
#include
using namespace std;
int main()
{
string str;
while(cin>>str)
{
int str_size = str.size();
if(str_size == 0) continue;
if(str_size == 1) printf("Yes!\n");
bool bo = true;
for(int i=0,j=str_size-1;i
找位置
/**
题目描述
对给定的一个字符串,找出有重复的字符,并给出其位置,
如: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
***/
//hush or 暴力
#include
#include
#include
#include
#include
#include
阶乘
/**
题目描述
输入n, 求y1=1!+3!+...m!(m是小于等于n的最大奇数) y2=2!+4!+...p!(p是小于等于n的最大偶数)。
输入描述:
每组输入包括1个整数:n
输出描述:
可能有多组测试数据,对于每组数据,
输出题目要求的y1和y2
示例1
输入
4
输出
7 26
**/
//题目没有说N的范围,简直了。不过考察的重点应该是那个等式,可以O(n)来做
#include
#include
#include
#include
#include
using namespace std;
int main()
{
int N; //N<=20
while(scanf("%d",&N)!=EOF)
{
long long y1 = 0,y2 = 0;
long long factorial = 1;
for(int i=1;i<=N;i++)
{
factorial *= i;
if(i&1) y1 += factorial; //奇数
else { y2 += factorial; } //偶数
}
cout<
/**
题目描述
输入一个整数,将其转换成八进制数输出。
输入描述:
输入包括一个整数N(0<=N<=100000)。
输出描述:
可能有多组测试数据,对于每组数据,
输出N的八进制表示数。
示例1
输入
7
8
9
输出
7
10
11
**/
//题目原来意思可能是要我们模拟进制转换吧....
#include
#include
using namespace std;
int main()
{
int N;
while(scanf("%d",&N)!=EOF)
{
printf("%o\n",N);
}
return 0;
}