SCAU程序设计在线实训平台_实验_高级语言程序设计_教材习题_第九章

18060 删除空格 ★

Description

用指针方法解决，输入一个字符串，删除字符串中所有空格后，输出字符串

#include 

void removeSpace(char *s)
{
_______________________
}

int main()
{
    char s[81];
    gets(s);
    removeSpace(s);
    printf("%s", s);
    return 0;
}

输入格式

一行字符，以换行回车结束，最多不超过80个字符

输出格式

删除所有空格后输出

输入样例

abc 456

输出样例

abc456

#include 

void removeSpace(char *s)
{
    int i=0;
    while(s[i]!='\0'){
        if(s[i]==' '){
            for(int j=i; s[j]!='\0'; j++){
                s[j]=s[j+1];
            }
        }
        else i++;	//只有不是空格才能+1，防止多个空格并列
    }
}

int main()
{
    char s[81];
    gets(s);
    removeSpace(s);
    printf("%s", s);
    return 0;
}

系统标程

$block1$
    int i=0,j=0;
    while(s[j]!='\0')
    {
        if(s[j]==' ') j++;
        else
            s[i++]=s[j++];
    }
    s[i]='\0';
$end1$

标程很巧妙，使用了两个下标，注意辨析 i++ 和 ++i 的区别

18061 数的交换 ★★

Description

输入10个整数，把其中最小的数与第一个数交换，最大的数与最后一个数交换。使用3个函数解决问题：
(1) 输入10个整数的函数
(2) 进行交换处理的函数
(3) 输出10个数的函数

#include 

void input(int a[])
{
    _______________________
}

void swap(int a[])
{
    _______________________
}

void display(int a[])
{
    int i;
    for(i=0; i<10; i++)
        printf("%d\n", a[i]);
}

int main()
{
    int a[10];
    input(a);
    printf("input done\n");
    swap(a);
    printf("swap done\n");
    display(a);
    printf("display done\n");
    return 0;
}

输入格式

输入10个整数

输出格式

输出结果，一行一个数字

输入样例

2 1 3 4 5 6 7 8 9 0

输出样例

input done
swap done
0
1
3
4
5
6
7
8
2
9
display done

代码实现

#include 

void input(int a[]) //输入10个整数的函数
{
    for(int i=0; i<10; i++){
       scanf("%d",&a[i]);
    }
}

void swap(int a[]) //进行交换处理的函数
{
    int max=0,min=999,tmp;
    for(int i=0; i<10; i++){
       if(a[i]>max)max=i;
       if(a[i]<min)min=i;		//牛逼，天天写bug
    }
    tmp=a[0];
    a[0]=a[max];
    a[max]=tmp;
    tmp=a[9];
    a[9]=a[min];
    a[min]=tmp;
}

void display(int a[])
{
    int i;
    for(i=0; i<10; i++)
        printf("%d\n", a[i]);
}

int main()
{
    int a[10];
    input(a);
    printf("input done\n");
    swap(a);
    printf("swap done\n");
    display(a);
    printf("display done\n");
    return 0;
}

系统标程

$block1$
    int i;
    for(i=0; i<10; i++)
        scanf("%d", &a[i]);
$end1$
$block2$
    int temp,mini,maxi;
    int i;
    mini=0;
    for(i=1; i<10; i++)
        if(a[mini]>a[i])
            mini=i;
    temp=a[mini];a[mini]=a[0];a[0]=temp;
    maxi=0;
    for(i=1; i<10; i++)
        if(a[maxi]<a[i])
            maxi=i;
    temp=a[maxi];a[maxi]=a[9];a[9]=temp;
$end2$

看了标程发现这题OJ误判了，写了一堆BUG居然过了，震惊，OJ应该只判断一次

18062 二维数组每行中的最大值 ★★★

Description

输入一个4*4的二维整型数组，使用指针变量查找并输出二维整型数组中每一行的最大值。

#include  

void find(int a[][4]) 
{ 
    int (*p)[4], *q, *max; 
    for(_______________________) 
    { 
        max=*p; 
        for(_______________________) 
        { 
_______________________ 
        } 
        printf("%d\n", *max); 
    } 
} 

int main() 
{ 
    int a[4][4],i,j; 
    for(i=0; i<4; i++) 
        for(j=0; j<4; j++) 
            scanf("%d", &a[i][j]); 
    find(a); 
    return 0; 
} 

输入格式

4*4的整数矩阵

输出格式

每行最大值，一行一个

输入样例

1 2 3 4
8 7 6 5
1 1 1 1
2 2 2 2

输出样例

4
8
1
2

代码实现

#include 

void find(int a[][4])
{
    int (*p)[4], *q, *max;
    for(p=a;p<a+4;p++)          //每行首地址，这里的a是一行4个变量的地址集合
    {
        max=*p;                 //p为当前行4个地址集合，*p取到的是第一个元素的地址
        for(q=*p;q<*p+4;q++)    //q为当前行第一个元素地址，每次加一访问到每个元素
        {
            if(*q>*max){        //如果元素值>擂主值 
                max=q;          //将该元素的地址赋值给max
            }
        }
        printf("%d\n", *max);   //输出max
    }
}

int main()
{
    int a[4][4],i,j;
    for(i=0; i<4; i++)
        for(j=0; j<4; j++)
            scanf("%d", &a[i][j]);
    find(a);
    return 0;
}

二维数组的指针需强化

18063 圈中的游戏 ★★★★

Description

有n个人围成一圈，从第1个人开始报数1、2、3，每报到3的人退出圈子。编程使用链表找出最后留下的人。

输入格式

输入一个数n，1000000>=n>0

输出格式

输出最后留下的人的编号

输入样例

3

输出样例

2

代码实现

#include 
#include 
typedef struct people
{
    int id;              //数据域
    struct people *next;  //指针域
} LinkList;


int main()
{
    int n, i;
    scanf("%d", &n);
    LinkList *head, *node, *end;         //定义头节点，普通节点，尾部节点；
    head = (LinkList *)malloc(sizeof(LinkList));    //分配空间
    head->id = 1;   //头节点
    head->next = NULL;
    end = head;          //空链表头等于尾部

    for (i = 2; i <= n; ++i){  //创建普通节点

        node = (LinkList *)malloc(sizeof(LinkList));
        node->id = i;      //对应ID
        end->next = node;    //第一次运行时此处r为头节点地址，所以将p的指针域指向第一个s
        end = end->next;    //将r向后移
    }

    end->next = head;    //本题特殊的地方，因为题目是个圈，所以要回到开头！！


    int num = 0;
    while (n > 1){     //循环到只剩一个人
        if (head->id != 0){     //如果头节点不等于0

            num++;      //报数号

            if (num % 3 == 0){  //如果报到3
                n--;
                head->id = 0;  //将id设为0表示已经踢出，这里是网上一个人的方法
            }

            head = head->next;  //下一个
        }

        else head = head->next;     //如果头节点为0则跳过，不用报数
    }

    while (!head->id)head = head->next;      //如果id为0则是已经被踢出的

    printf("%d", head->id);
    return 0;
}

系统标程

#include 
int c[1000000];

int main()
{
    int i, j, n, pre, cur;
    scanf("%d", &n);
    if(n==1) printf("1\n");
    else
    {
        for(i=0; i<n-1; i++) c[i]=i+1;
        c[n-1]=0;
        cur=n-1;
        for(i=0; i<n-1; i++)
        {
            for(j=0; j<3; j++)
            {
                pre = cur;
                cur=c[cur];
            }
            c[pre]=c[cur];
        }
        printf("%d", pre+1);
    }
    return 0;
}

…看完标程，脑瘫竟是我自己

18064 链表的有序合并

Description

已知有两个链表a和b，结点类型相同，均包括一个int类型的数据。编程把两个链表合并成一个，结点按升序排列。

#include "stdio.h"
#include "malloc.h"
#define LEN sizeof(struct DATA)

struct DATA
{
     long num;
     struct DATA *next;
};

struct DATA *create(int n)
{
     struct DATA *head=NULL,*p1=NULL,*p2=NULL;
     int i;
     for(i=1;i<=n;i++)
     {  p1=(struct DATA *)malloc(LEN);
        scanf("%ld",&p1->num);
        p1->next=NULL;
        if(i==1) head=p1;
        else p2->next=p1;
        p2=p1;
      }
      return(head);
}

struct DATA *merge(struct DATA *head, struct DATA *head2)
{
    _______________________
    return head;
}

struct DATA *insert(struct DATA *head, struct DATA *d)
{
    _______________________
    return head;
}

struct DATA *sort(struct DATA *head) 
{ 
    _______________________
    return head;
} 

void print(struct DATA *head)
{
    struct DATA *p;
    p=head;
    while(p!=NULL)
    {
        printf("%ld",p->num);
        p=p->next;
        printf("\n");
    }
}

main()
{
    struct DATA *head, *head2;
    int n;
    long del_num;
    scanf("%d",&n);
    head=create(n);
    scanf("%d",&n);
    head2=create(n);
    head = merge(head, head2);
    head = sort(head);
    print(head);
}

输入格式

第一行一个数n，表示第一个列表的数据个数
每二行为n个数
第三行为一个数m
第四行为m个数

输出格式

输出合并后的有序的数据，一行一个数

输入样例

2
4 8
3
9 1 5

输出样例

1
4
5
8
9

代码实现

#include "stdio.h"
#include "malloc.h"
#define LEN sizeof(struct DATA)

struct DATA
{
     long num;
     struct DATA *next;
};

struct DATA *create(int n)
{
     struct DATA *head=NULL,*p1=NULL,*p2=NULL;
     int i;
     for(i=1;i<=n;i++)
     {  p1=(struct DATA *)malloc(LEN);
        scanf("%ld",&p1->num);
        p1->next=NULL;
        if(i==1) head=p1;
        else p2->next=p1;
        p2=p1;
      }
      return(head);
}

struct DATA *merge(struct DATA *head, struct DATA *head2)   //合并
{
    struct DATA *tmp;
    tmp=head;
    while(tmp->next!=NULL)tmp=tmp->next;
    tmp->next=head2;
    return head;
}

struct DATA *insert(struct DATA *head, struct DATA *d)  //插入
{
    struct DATA *old,*element,*tmp;
    old = head;
    element = d;

    if(head==NULL){     //若被插入的链表为空
        head=element;
        element->next=NULL;
    }

    else{
        while((element->num > old->num) && (old->next != NULL)){    //循环到找到比要插入元素大的位置
            tmp=old;    //前驱
            old=old->next;  //向后推进
        }

        if(element->num <= old->num){       //中间

                if(head==old)head=element;      //第一个

                else tmp->next=element;     //遍历到的元素的前驱元素指向插入元素

                element->next=old;      //要插入元素的下一个等于当前遍历到的元素
        }

        else{
            old->next=element;element->next=NULL; //最后一个
        }
    }


    return head;
}

struct DATA *sort(struct DATA *head)    //排序
{
    struct DATA *p1,*p2;

    p2=head;p1=head;

    p2=p2->next;

    p1->next=NULL;

    p1=p2;

    while(p2->next!=NULL)

    {

      p2=p2->next;

      p1->next=NULL;

      head=insert(head,p1);

      p1=p2;

    }

    head=insert(head,p1);
    return head;
}

void print(struct DATA *head)
{
    struct DATA *p;
    p=head;
    while(p!=NULL)
    {
        printf("%ld",p->num);
        p=p->next;
        printf("\n");
    }
}

main()
{
    struct DATA *head, *head2;
    int n;
    long del_num;
    scanf("%d",&n);
    head=create(n);
    scanf("%d",&n);
    head2=create(n);
    head = merge(head, head2);
    head = sort(head);
    print(head);
}

参考标程

本文加入了题目难度，五星满星