zzulioj：指针结构体 题解_void largesttow(int a[],int n,int *pfirst,int *pse

1158又是排序（指针专题）
题目描述
将输入的四个整数按由大到小的顺序输出。
请你定义一个四个数排序的函数psort，psort的四个参数为要排序的四个整数变量的地址，请你按照从大到小的顺序把四个数分别放到四个指针所指向的变量里，不要在函数内输入输出任何内容。请务必使用函数实现四个数的排序。
void psort( int *pa, int *pb,int *pc,int *pd)
{
//实现四个数的排序，并分别放到四个指针所指向的变量里。
}

注意：本题如果采用C/C++提交时，至少要编写psort()函数和main()函数两个函数,并提交完整的程序代码。
输入
输入4个整数，用空格隔开。
输出
输出排序后的4个整数，由空格隔开。输出占一行。
样例输入 Copy
4 3 5 2
样例输出 Copy
5 4 3 2

#include <stdio.h>
#include <stdlib.h>
void psort( int *pa, int *pb,int *pc,int *pd);
int main()
{
    int a,b,c,d;
    scanf("%d%d%d%d",&a,&b,&c,&d);
    psort(&a,&b,&c,&d);
    printf("%d %d %d %d",d,c,b,a);
    return 0;
}
void psort( int *pa, int *pb,int *pc,int *pd)
{
    int a;
    if(*pa>*pb)//4个数两两比较得到*pa<*pb<*pc<*pd就行了；
    {
        a=*pa;
        *pa=*pb;
        *pb=a;
    }
    if(*pa>*pc)
    {
        a=*pa;
        *pa=*pc;
        *pc=a;
    }
    if(*pa>*pd)
    {
        a=*pa;
        *pa=*pd;
        *pd=a;
    }
    if(*pb>*pc)
    {
        a=*pb;
        *pb=*pc;
        *pc=a;
    }
    if(*pb>*pd)
    {
        a=*pb;
        *pb=*pd;
        *pd=a;
    }
    if(*pc>*pd)
    {
        a=*pc;
        *pc=*pd;
        *pd=a;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

1159最大的两个数（指针专题）
题目描述
求n个整数中的最大的两个元素。要求定义一个函数LargestTow()，求数组a的最大的两个元素，分别存入形参指针pfirst和psecond所指存储单元，函数原型如下：
void LargestTow(int a[],int n,int *pfirst,int *psecond)
{
/*数组a有n个元素，将数组中的最大值存入形参指针pfirst所指内存单元，将数组中第二大的值存入形参指针psecond所指内存单元。 */
}
输入
输入有两行，输入第一行是一个整数n，1<n<=1000；第二行是n个整数，由空格隔开。
输出
输出两个整数，表示数组中最大的两个值。输出占一行。
样例输入 Copy
5
6 3 4 9 8
样例输出 Copy
9 8

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
void LargestTow(int a[],int n,int *pfirst,int *psecond);
int main()
{
    int str[1005],n,i,x,y;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    scanf("%d",&str[i]);
    LargestTow(str,n,&x,&y);
    printf("%d %d",x,y);
    return 0;
}
void LargestTow(int a[],int n,int *pfirst,int *psecond)
{
      int i,q,m,b;//找出最大的两个数，这两个数可能一样大！！！
      *pfirst=INT_MIN,*psecond=INT_MIN;
      for(i=0;i<n;i++)//找出最大的数；
      {
          if(a[i]>*pfirst)
          {
              *pfirst=a[i];
              q=i;
          }
      }
      for(i=0;i<n;i++)//找出第二大的数；
      {
          if(a[i]>*psecond&&i!=q)//i!=q是用来排除最大的数的；
          {
              *psecond=a[i];
          }
      }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

1160矩阵的最大值（指针专题）
题目描述
找出一个2×3的整数矩阵中的最大值及其行下标和列下标，要求调用函数FindMax(int p[][3], int m, int n, int *pRow, int *pCol)实现，行下标和列下标在形参中以指针的形式返回。
void FindMax(int p[][3], int m, int n, int *pRow, int pCol){
//在mn矩阵p中查找最大值，将其行下标存入pRow所指内存单元，将其列下标存入pCol所指内存单元
}

输入
输入2行3列整数，共6个。

输出
输出3个整数，矩阵中的最大值及其行下标和列下标，数据之间用空格隔开。测试数据保证最大值唯一。

样例输入 Copy
100 3 6
0 87 65
样例输出 Copy
100 0 0

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
int main()
{
    int str[2][3],i,j,a,b,max=INT_MIN;//本题没有使用指针
    for(i=0;i<2;i++)
    for(j=0;j<3;j++)
    {
       scanf("%d",&str[i][j]);
       if(str[i][j]>max)//找出最大的数，并记录其行下标和列下标；
       {
           max=str[i][j];
           a=i,b=j;
       }
    }
    printf("%d %d %d",max,a,b);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1162循环移动（指针专题）
题目描述
有n个整数，使前面各数顺序向后移动k个位置，移出的数再从开头移入。输出移动后的数组元素。
题目没有告诉你n的范围，希望你读入n之后用malloc()函数动态申请内存空间，不要提前定义数组的大小。不要偷懒哦。
另外要求定义并使用函数ringShift()
void ringShift(int *a, int n, int k)
{
//循环移动后的数值仍然存入数组a中
}

输入
输入分3行，第一行是一个整数n，第二行是n个整数，用空格隔开。第三行是一个整数k。

输出
输出n个整数，由空格隔开。输出占一行。

样例输入 Copy
6
1 2 3 4 5 6
2
样例输出 Copy
5 6 1 2 3 4

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<limits.h>
void ringShift(int *a, int n, int k);
int main()
{
    int n,i,k;
    scanf("%d",&n);
    int a[n];
    for(i=0;i<n;i++)
    scanf("%d",&a[i]);
    scanf("%d",&k);
    ringShift(a,n,k);
    for(i=0;i<n;i++)
    printf("%d ",a[i]);
    return 0;
}
void ringShift(int *a, int n, int k)
{
    int t,i,x;
    while(k--)//循环后移k次；
    {
      t=a[n-1];//先将最后一位存入t；
      for(i=n-1;i>0;i--)
    {
       a[i]=a[i-1];//将除最后一位以外的数向后移动1次；
    }
     a[0]=t;//将t赋给a[0];
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

1800少水群多刷题
题目描述

输入
多实例，读取到文件尾结束。

每个实例输入一个正整数n

输出
对每个实例:输出n行“年轻人要少水群多刷题！”（不要输出引号）

每个实例后面输出一个空行。

样例输入 Copy
1
2
样例输出 Copy
年轻人要少水群多刷题！

年轻人要少水群多刷题！
年轻人要少水群多刷题！

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
int main()
{
    int n,i;
    while(scanf("%d",&n)!=EOF)//没有结束条件的多实例用EOF结束；
    {
        for(i=1;i<=n;i++)
        {
        printf("年轻人要少水群多刷题！\n");
        }
        printf("\n");//别忘了空行；
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1604字母o的三角形
题目描述
输入正整数n<=20,输出一个n层的三角形。

输入
输入一个正整数n。

输出
输出用小写字母o组成的三角形。

样例输入 Copy
5
样例输出 Copy

提示
注意，每行最后一个字母后面没有空格

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
int main()
{
    int n,max,i,j,o;
    scanf("%d",&n);
    for(i=1;i<=n;i++)//此循环用来控制行；
    {
        for(j=n-i;j>0;j--)//控制空格的输出；
        {
         printf(" ");
        }
        for(o=2*i-1;o>0;o--)//控制o的输出；
        {
          printf("o");
        }
        printf("\n");
    }
 
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

1165实数的小数部分（指针专题）
题目描述
读入一个实数，输出该实数的小数部分，小数部分若多余的末尾0，请去掉。如输入111111.12345678912345678900
则输出0.123456789123456789。若去掉末尾0之后小数部分为0，则输出“No decimal part”。注意该实数的位数不超过100位。
请定义并使用如下函数。
char *decimal(char *p)
{
将字符串p表示的实数的自小数点开始的小数部分存入一个字符串，并由函数返回，若p为“123.456”，则返回的字符串为“.456”。若小数部分为0,返回空指针NULL。
}

输入
输入一个实数。不超过100位。

输出
输出小数部分，输出占一行。

样例输入 Copy
111111.12345678900012345678900
样例输出 Copy
0.123456789000123456789

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
int main()
{
    char str[105]={0};
    int len,i,q=0,p,sum=0,l;
    scanf("%s",str);
    len=strlen(str);
    for(i=0;i<len;i++)
    {
        if(q==1)
        {
          if(str[i]=='0')//统计小数点后0的个数；
                sum++;
        }
        if(str[i]=='.')//判断小数点的位置；
        {
           q=1;
           p=i;
        }
    }
    if(sum==len-p-1||q==0)//小数点后0的个数等于小数点后总位数或没有小数点执行该项；
    {
      printf("No decimal part");
      return 0;//直接结束此程序；
    }
    if(q==1)//如果有小数点；	
    printf("0");//先输出零；
    if(sum!=len-p-1)//如果小数点后0的个数不等于小数点后总位数
    {
       if(str[len-1]=='0'&&q==1)//如果有尾数0，执行下一步；
       for(i=len-1;i>=0;i--)//统计尾数0的个数；
    {
        if(str[i]=='0')
            l++;
        if(str[i]!='0')
            break;
    }
      for(i=p;i<len-l;i++)//从小数点开始输出且到尾数0截止；
    {
      printf("%c",str[i]);
    }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

1167逆转数（指针专题）
题目描述
任意给你一个整数，这个数可能很大（最长不超过100位），你能求出它的逆转数吗？
逆转数定义如下：
1.一个末尾没有0的整数，它的逆转数就是各位数字逆序输出；
2.一个负数的逆转数仍是负数；
3.一个末尾有0的整数，它的逆转数如同下例：
reverse (1200) = 2100
reverse (-56) = -65
要求定义并使用如下函数：
void reverse(char *str)
{
//函数求出str的逆转数并存入str。
}

输入
输入一个长整数str，不超过100位，输入的整数不含前导0。

输出
输出str的逆转数。输出占一行。

样例输入 Copy
-123456789000
样例输出 Copy
-987654321000

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void reverse(char *str);
int main()
{
    char str[105];
    int len,i;
    scanf("%s",str);
    len=strlen(str);
    reverse(str);
    return 0;
}
void reverse(char *str)
{
   int i,q,p,len,sum=0;
   len=strlen(str);
   if(str[len-1]=='0')//如果有尾数0执行下一步；
   for(i=len-1;i>=0;i--)//统计尾数0个数；
   {
      if(str[i]=='0')
        sum++;
      if(str[i]!='0')
        break;
   }
   if(str[0]=='-')//如果该数为负数执行这一步；
   {
       printf("-");//先输出负号；
       for(i=len-sum-1;i>=1;i--)//i=1停止；
       printf("%c",str[i]);
       for(i=1;i<=sum;i++)//输出尾数0；
       printf("0");
   }
   else//如果该数不为负数执行这一步；
   {
     for(i=len-sum-1;i>=0;i--)//i=0停止；
     printf("%c",str[i]);
     for(i=1;i<=sum;i++)//输出尾数0；
     printf("0");
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

1169大整数（指针专题）
题目描述
输入3个非负大整数，位数不超过100位，按从小到大的顺序输出这三个整数。要求定义并使用如下函数比较两个大整数的大小。
int cmp(char *a,char *b)
{
//若大整数a大于b，返回1；
//若a小于b，返回-1；
// 若a与b相等，返回0
}
输入
输入有3行，每行输入一个大整数，位数不超过100位，输入不含前导0。
输出
输出3行，即排序后的3个大整数。
样例输入 Copy
1234567890123456789
99999999999999
111111111111111
样例输出 Copy
99999999999999
111111111111111
1234567890123456789

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int cmp(char *a,char *b);
int main()
{
    char a[105],b[105],c[105],m[105];
    int len0,len1,len2,i;
    scanf("%s",a);
    scanf("%s",b);
    scanf("%s",c);
    len0=strlen(a);
    len1=strlen(b);
    len2=strlen(c);
    if(cmp(a,b)==1)
    {
      strcpy(m,a);//a字符串和b字符串交换；(strcpy()的作用C语言课本172页自查)
      strcpy(a,b);
      strcpy(b,m);
    }
    if(cmp(a,c)==1)
    {
      strcpy(m,a);
      strcpy(a,c);
      strcpy(c,m);
    }
    if(cmp(b,c)==1)
    {
      strcpy(m,b);
      strcpy(b,c);
      strcpy(c,m);
    }
    printf("%s\n%s\n%s",a,b,c);
    return 0;
}
int cmp(char *a,char *b)
{
  int len1,len2,i;
  len1=strlen(a);
  len2=strlen(b);
  if(len1>len2)//先比较位数，位数大的该整数就大；
  return 1;
  if(len1<len2)//先比较位数，位数小的该整数就小；
  return -1;
  if(len1==len2)//位数相同执行下一步；
  {
      for(i=0;i<len1;i++)
      {
         if(a[i]>b[i])//判断每一位的大小；
            return 1;
         if(a[i]<b[i])
            return -1;
      }
      return 0;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

1176 查找最大字符串（指针专题）
题目描述
从键盘上输入多个字符串（每个串不超过5个字符且没有空格），用”*****”作为串输入结束的标记。从所输入的若干字符串中，找出一个最大的串，并输出该串。要求最大串的查找通过调用编写的函数实现
void find(char *name[], int n, int *p)
{
//在包含n个字符串的二维字符数组name中，查找值最大的字符串，将其下标存入指针p所指内存单元
}

输入
一行输入一个字符串，输入多行

输出
输出一个字符串，单独占一行。

样例输入 Copy
zzzdf
fdsg
adff
rtrt

---

样例输出 Copy
zzzdf

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    char a[6],b[6]="*****",max[6]={0};//先清空max数组(清不清都对，个人习惯)；
    while(gets(a),strcmp(a,b)!=0)//如果输入'*****'结束循环；
    {
         if(strcmp(a,max)>0)//用strcmp()函数比较字符串大小；
            strcpy(max,a);//将大的复制给max；
    }
    puts(max);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

1166实数取整（指针专题）
题目描述
读入一个实数，输出实数的整数部分。注意该实数的位数不超过100位。输入的整数部分可能含有不必要的前导0，输出时应去掉，当然，若整数部分为0，则该0不能去掉。如输入0023.56732，输出应为23，而不是0023；0.123对应的输出应为0。当然输入也可能不含小数部分。
要求定义并使用rounding()函数，原型如下：
char *rounding(char *p)
{
//将字符串p表示的实数取整后生成新的字符串，并由函数返回
}

输入
输入一个实数.

输出
输出整数部分。

样例输入 Copy
0012345678900.56789
样例输出 Copy
12345678900

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
int main()
{
    char str[105]={0};
    int len,i,q=0,p,sum=0,l;
    scanf("%s",str);
    len=strlen(str);
    p=len;
    if(str[0]=='0')//判断是否有前导0；
        q=1;
    for(i=0;i<len;i++)//用p变量记住小数点的位置；
    {
        if(str[i]=='.')
           p=i;
    if(q==1)//如果有前导0，统计前导0的个数；（sum初值为0）
    {
        if(str[i]!='0')
            q=0;
        if(str[i]=='0')
            sum++;
    }
    }
      for(i=sum;i<p;i++)//从除去前导0的第一位开始输出，到小数点停止；
    {
      printf("%c",str[i]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

1183平面点排序（一）（结构体专题）
题目描述
平面上有n个点，坐标均为整数。请按与坐标原点（0,0）距离的远近将所有点排序输出。可以自己写排序函数，也可以用qsort库函数排序。

输入
输入有两行，第一行是整数n（1<=n<=10)，接下来有n行，每行一对整数（每对整数对应一个点）。

输出
输出排序后的所有点，格式为(u,v)，每个点后有一个空格。测试数据保证每个点到原点的距离都不同。

样例输入 Copy
4
1 3
2 5
1 4
4 2
样例输出 Copy
(1,3) (1,4) (4,2) (2,5)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    int n,i,j,sum,o,t;
    scanf("%d",&n);
    int a[n],b[n],c[n],d[n];
    for(i=0;i<n;i++)
    {
       scanf("%d %d",&a[i],&b[i]);
       c[i]=a[i]*a[i]+b[i]*b[i];//记录该点到（0,0）的距离的平方；
       d[i]=i;//d[i]记录每个点顺序下标；
    }
    for(j=0;j<n-1;j++)//冒泡排序法对距离进行排序；
    for(i=1;i<n-j;i++)
    {
        if(c[i-1]>c[i])
        {
            t=c[i-1];
            c[i-1]=c[i];
            c[i]=t;
            t=d[i-1];//按距离交换下标使最短距离的下标存入d[0]，最长的存入d[n-1];
            d[i-1]=d[i];
            d[i]=t;
        }
    }
    for(i=0;i<n;i++)
    {
        o=d[i];//按距离从短到长的点的下标输出点的坐标；
        printf("(%d,%d) ",a[o],b[o]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

1702按身高站队
题目描述

输入n个学生的姓名和身高，按身高从小到大的顺序输出所有姓名。
输入

输入第一行为一个整数n（n<10），接下来的n行，每行包含一个姓名和身高，用空格隔开，姓名为长度不超过20的字符串，不含空格，身高为一个整数值。
为降低难度，输入数据保证没有任何两个人身高相同。
输出

输出n行，每行一个姓名，按身高从低到高的顺序输出。
样例输入 Copy
3
liming 182
wangling 170
zhangliang 190
样例输出 Copy
wangling
liming
zhangliang

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    int n,i,j,sum,o,t;
    scanf("%d",&n);
    int b[n],c[n],d[n];
    char a[n][21];
    for(i=0;i<n;i++)
    {
       scanf("%s %d",a[i],&b[i]);//a[i]存名字，b[i]存身高；
       d[i]=i;//d[i]记录每个人对应的下标；
    }
    for(j=0;j<n-1;j++)//冒泡排序法对身高进行排序；
    for(i=1;i<n-j;i++)
    {
        if(b[i-1]>b[i])
        {
            t=b[i-1];
            b[i-1]=b[i];
            b[i]=t;
            t=d[i-1];//按身高交换下标使最低的人的下标存入d[0]，最高的存入d[n-1];
            d[i-1]=d[i];
            d[i]=t;
        }
    }
    for(i=0;i<n;i++)
    {
        o=d[i];//按身高从高到低的人的下标输出名字；
        printf("%s\n",a[o]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

1184平面点排序（二）（结构体专题）
题目描述
平面上有n个点，坐标均为整数。横坐标相同时按纵坐标排序，否则按横坐标排序。本题要求用结构体存储坐标，再进行排序。先升序排序输出，再降序排序输出，可以自己写排序函数，也可以用qsort库函数排序。

输入
第一行是整数n(1<=n<=100)，表示接下来有n行，每行两个整数，表示平面上一个点的坐标。

输出
输出有两行，即排序后的点，格式为(u,v)，每个点后有一个空格。第一行升序排序结果，第二行降序排序结果。

样例输入 Copy
4
1 3
2 5
1 4
4 1

样例输出 Copy
(1,3) (1,4) (2,5) (4,1)
(4,1) (2,5) (1,4) (1,3)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    int n,i,j,sum,o,t;
    scanf("%d",&n);
    int a[n],b[n];
    for(i=0;i<n;i++)
    {
       scanf("%d %d",&a[i],&b[i]);//a[i]存每个点的横坐标b[i]存每个点的纵坐标；
    }
    for(j=0;j<n-1;j++)//冒泡排序法对点进行排序；
    for(i=1;i<n-j;i++)
    {
        if(a[i-1]>a[i])//比较横坐标，并交换坐标，将最小的坐标存入a[0]b[0]；最大的存入a[n-1]b[n-1];
        {
            t=a[i-1];
            a[i-1]=a[i];
            a[i]=t;
            t=b[i-1];
            b[i-1]=b[i];
            b[i]=t;
        }
        if(a[i-1]==a[i])//横坐标相同的情况下对纵坐标进行比大小；
        {
            if(b[i-1]>b[i])//横坐标相同的情况下交换纵坐标就行了；
        {
            t=b[i-1];
            b[i-1]=b[i];
            b[i]=t;
        }
        }
    }
    for(i=0;i<n;i++)//正序输出；
    {
        printf("(%d,%d) ",a[i],b[i]);
    }
    printf("\n");
    for(i=n-1;i>=0;i--)//逆序输出；
    {
        printf("(%d,%d) ",a[i],b[i]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45