C高级第三次作业

最新推荐文章于 2022-10-25 20:19:00 发布
最新推荐文章于 2022-10-25 20:19:00 发布
阅读量131 收藏
点赞数
原文链接：http://www.cnblogs.com/chenxidream/p/8778302.html
版权

C高级第三次作业（1）

6-1 输出月份英文名

1343996-20180410124241579-506274529.png
1343996-20180410124314015-300361103.png
1343996-20180410124339309-1585030053.png

1.设计思路

（1）算法：
第一步：定义整型变量n，字符指针s，输入一个数赋给n。
第二步：调用函数getmonth将值赋给s。
第三步：在函数getmonth中使用switch—case语句来实现，返回月份的英文名。
第四步：在主函数中如果s==NULL就输出wrong input，否则输出s。
（2）流程图：

2.实验代码：

char *getmonth( int n ){
    char *a;
    switch(n){
        case 1:strcpy(a,"January");break;
        case 2:strcpy(a,"February");break;
        case 3:strcpy(a,"March");break;
        case 4:strcpy(a,"April");break;
        case 5:strcpy(a,"May");break;
        case 6:strcpy(a,"June");break;
        case 7:strcpy(a,"July");break;
        case 8:strcpy(a,"August");break;
        case 9:strcpy(a,"September");break;
        case 10:strcpy(a,"October");break;
        case 11:strcpy(a,"November");break;
        case 12:strcpy(a,"December");break;
        default:strcpy(a,"NULL");
    }
    return(a);
}

1343996-20180409213306070-928119850.png

修改后的代码

char *getmonth( int n ){
    switch(n){
        case 1:return "January";
        case 2:return "February";
        case 3:return "March";
        case 4:return "April";
        case 5:return "May";
        case 6:return "June";
        case 7:return "July";
        case 8:return "August";
        case 9:return "Septemer";
        case 10:return "October";
        case 11:return "November";
        case 12:return "December";
        default:return NULL;
    }
}

1343996-20180411192354149-2141899918.png

3.本题调试过程碰到问题及解决办法：

问题1：部分正确
错误的原因：没有声明string函数库，无法调用strcpy函数。
修正方法：自己想不出来在网上搜解题思路，自己重新写。

6-2 查找星期

1343996-20180410124422069-590172160.png
1343996-20180410124455204-1258081593.png
1343996-20180410124512799-107969550.png

1.设计思路：

（1）算法：
第一步：定义整型变量i，字符数组s[MAXS],输入一个字符串赋给s。
第二步：调用函数getindex，n=getindex的返回值。
第三步：在getindex函数中，定义整型变量a=-1，i=0，字符指针数组*week[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"},定义字符型指向指针的指针**p=week在for循环中i为循环变量，条件为i<7,如果strcmp(s,week[i])==0，就执行a=i，然后跳出这个循环，执行完for循环最后返回a。
第四步：在主函数中如果n==-1，就执行wrong input!，否则就输出n的值
（2）流程图：
1343996-20180412193933233-1009553151.png

2.实验代码

int getindex( char *s ){
    int a=-1,i;
    char *week[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
    char **p=week;
    for(i=0;i<7;i++){
        if(strcmp(s,*(p+i))==0){
            a=i;
            break;
        }
    }
    return a;
}

3.本题调试过程碰到问题及解决办法：

1343996-20180409220321980-1853552130.png

6-3 计算最长的字符串长度

1343996-20180410131519405-1665845227.png
1343996-20180410131537390-755241113.png
1343996-20180410131550680-513323577.png

1.设计思路：

（1）算法：
第一步：常量MAXN 10，MAXS 20，定义整型变量i，n，字符指针数组string[MAXN] = {NULL}，输入一个数赋给n。
第二步：借助for循环i=0；条件为i<n;在for循环中动态分配内存大小为20字节，输入一个字符串赋给string[i]。
第三步：调用max_len函数，将函数max_len的返回值输出。
第四步：在函数max_len中，定义整型变量i，count=0，j，整型数组q[20]={0};借助for循环求出(*(s+i)）中的字符串的长度，将值赋给q[i];
第五步：count=q[0],借助for循环找到q[i]的最大值赋给count，最后返回count的值。
（2）流程图
1343996-20180410140839649-3973384.png

2.实验代码：

int max_len( char *s[], int n ){
    int i,count=0,j,q[20]={0};
    for(i=0;i<n;i++){
        for(j=0;*(*(s+i)+j)!='\0';j++){
        }
        q[i]=j;
    }
    count=q[0];
    for(i=0;i<n;i++){
        if(q[i]>count){
            count=q[i];
        }
    }
    return count;
}

3.本题调试过程碰到问题及解决办法：

1343996-20180410131436855-1922066702.png

6-4 指定位置输出字符串

1.设计思路

（1）算法：
第一步：定义字符数组str[10],字符变量ch_start, ch_end，字符型指针变量p，
第二步：独树一格字符串给str，读入两个字符分别赋给ch_start, ch_end，
第三步：调用函数match，将函数的返回值赋给p。
第四步：在函数match中定义整型变量i，j，字符型指针q=NULL，i=0，借助for循环条件为(s+i)!='\0'，在for循环中如果(s+i)==ch1，定义字符型指针a=&s[i]，j=i，借助for循环条件为((s+j)!=ch2)&&((s+j)!='\0')，输出字符(s+j)，执行完第二个for循环判断如果(s+j)!='\0'，就输出字符(s+j)，并且换行，返回a的地址，执行完第一个for循环直到条件不满足，就换行并且返回q的地址。
第五步：输出字符串p。
（2）流程图：

2.实验代码：

char *match( char *s, char ch1, char ch2 ){
    int i,j;
    char *q=s;
    for(i=0;*(s+i)!='\0';i++){
        if(*(s+i)==ch1){
            for(j=i;*(s+j)!=ch2;j++){
                *(q)=*(s+j);
                q++;
            }
            *q=ch2;
        }
    }
    *q='\0';
    printf("%s\n",q);
}

1343996-20180411200809708-1884898079.png
修改后的代码：

char *match( char *s, char ch1, char ch2 ){
    int i,j;
    char *q=NULL;
    for(i=0;*(s+i)!='\0';i++){
        if(*(s+i)==ch1){
        char *a=  &s[i];
            for(j=i;(*(s+j)!=ch2)&&(*(s+j)!='\0');j++){
                printf("%c",*(s+j));
            }
                        if(*(s+j)!='\0')
            printf("%c",*(s+j));
            printf("\n");
            return a;
        }
    }
    printf("\n");
    return q;
}

1343996-20180412195454323-1965064230.png
在修改后的代码：

char *match( char *s, char ch1, char ch2 ){
    int i,j;
    char *q=NULL;
    for(i=0;*(s+i)!='\0';i++){
        if(*(s+i)==ch1){
          char *a=  &s[i];
            for(j=i;(*(s+j)!=ch2)&&(*(s+j)!='\0');j++){
                printf("%c",*(s+j));
            }
            if(*(s+j)!='\0')
            printf("%c",*(s+j));
            printf("\n");
            return a;
        }
    }
    printf("\n");
    return s+i;
}

1343996-20180413195432557-782226210.png

3.本题调试过程碰到问题及解决办法：

错误信息1：段错误
错误原因：自己没有读懂题意就写代码，一方面自己最后只是输出两个字符之间的所有字符，另一方面当函数找不到时返回得值不值空指针，代码不能满足所有的测试点。
改正方法：在一开始就定义指针为空指针，当找到的的话就重新定义一个指针，他的值为ch1的地址，输出在两个字符之间的所有字符，输出完换行并且返回指针变量，没有找到，就换行并且返回空指针。
错误信息2：部分正确有一个测试点错误
错误原因：在最后的返回值返回的是空指针原来返回的是q空指针
改正方法：将返回值改成s+i
码云代码存放：
1343996-20180414125330574-754594410.png

C高级第三次作业（2）

6-1 奇数值结点链表

1343996-20180422091238913-419459584.png
1343996-20180422091303549-365529526.png
1343996-20180422091322205-175690926.png
1343996-20180422091336409-2047803750.png

1.设计思路

（1）算法：
第一步：声明结构体类型，整型变量data，结构体指针变量next
第二步：在主函数中，定义结构体指针变量L，Odd，调用函数readlist将函数的返回值给L，调用函数getodd，将函数的返回值给Odd，
第三步：在readlist函数中，定义结构体指针变量head=NULL,p=NULL,q=NULL，整型数data，对p，q动态分配内存类型强制转化为结构体指针，大小为sizeof（struct ListNode），读入一个书给p->data，使用while语句条件为p->data！=-1，在循环语句中如果head==NULL，head=p，否则q->next=p，在if语句结束之后q=p，在对p动态分配内存类型强制转化为结构体指针，大小为sizeof（struct ListNode），读入一个数给p->data，在执行完while语句后q->next=NULL，返回head。
第四步：在getodd函数中，定义结构体指针变量head=NULL,q=NULL,p,w=NULL,head1=NULL，如果L！=NULL就执行for循环，for循环条件1为head=L，条件2为head！=NULL，条件3为head=head->next，在for循环中如果head->data%2!=0执行head1=head，否则执行p->next=head，在if语句之后p=head，如果head->data%2!=0不满足，就执行如果q==NULL，q=head,否则w->next=head，在if语句之后执行w=head，执行完for循环后p->next=NULL，如果w！=NULL执行w->next=NULL。最后L=q。在第一个if不满足时返回NULL，在最后返回head1.
第五步：两次调用函数printlist，将奇数和偶数的链表分别打印出来。
（2）流程图：
2.实验代码：

struct ListNode *readlist(){
    struct ListNode *head=NULL,*p=NULL,*q=NULL;
    int data;
    p=q=(struct ListNode *)malloc(sizeof(struct ListNode));
    scanf("%d",&p->data);
    while(p->data!=-1){
        if(head==NULL){
            head=p;
        }else{
            q->next=p;
        }
        q=p;
        p=(struct ListNode *)malloc(sizeof(struct ListNode));
        scanf("%d",&p->data);
    }
    return head;
}
struct ListNode *getodd( struct ListNode **L ){
    struct ListNode *head=NULL,*q=NULL,*p,*w=NULL,*head1=NULL;
        if(*L!=NULL){
            for(head=*L;head!=NULL;head=head->next){
                if(head->data%2!=0){
                    if(head1==NULL){
                        head1=head;p=head1;
                    }else{
                        e->next=p;
                    }
                    for(q=*L;q->data%2==0&&q->next!=NULL;q=q->next){
                        w=q;
                    }
                    if(q->data%2!=0){
                        if(q=*L){
                            *L=q->next;
                        }else{
                            w->next=q->next;
                        }
                    }//
                }       
            }
            w->next=NULL;
        }else{
            return NULL;
        }
        e->next=NULL;
    return head1;
}

1343996-20180422095209977-1488731344.png
修改后的代码：

struct ListNode *readlist(){
    struct ListNode *head=NULL,*p=NULL,*q=NULL;
    int data;
    p=q=(struct ListNode *)malloc(sizeof(struct ListNode));
    scanf("%d",&p->data);
    while(p->data!=-1){
        if(head==NULL){
            head=p;
        }else{
            q->next=p;
        }
        q=p;
        p=(struct ListNode *)malloc(sizeof(struct ListNode));
        scanf("%d",&p->data);
    }
    q->next=NULL; 
    return(head);
}
struct ListNode *getodd( struct ListNode **L ){
    struct ListNode *head=NULL,*q=NULL,*p,*w=NULL,*head1=NULL;
        if(*L!=NULL){
            for(head=*L;head!=NULL;head=head->next){
                if(head->data%2!=0){
                    if(head1==NULL){
                        head1=head;
                    }else{
                        p->next=head;
                    }
                    p=head;
                }else{
                    if(q==NULL){
                        q=head;w=q;
                    }else{
                        w->next=head;
                    }
                }
            }
            p->next=NULL;
            if(w!=NULL)
            w->next=NULL;
            *L=q;
        }else{
            return NULL;
        }
        return(head1);
    }

1343996-20180422095326396-470656916.png
再次修改

struct ListNode *readlist(){
    struct ListNode *head=NULL,*p=NULL,*q=NULL;
    int data;
    p=q=(struct ListNode *)malloc(sizeof(struct ListNode));
    scanf("%d",&p->data);
    while(p->data!=-1){
        if(head==NULL){
            head=p;
        }else{
            q->next=p;
        }
        q=p;
        p=(struct ListNode *)malloc(sizeof(struct ListNode));
        scanf("%d",&p->data);
    }
    q->next=NULL; 
    return(head);
}
struct ListNode *getodd( struct ListNode **L ){
    struct ListNode *head=NULL,*q=NULL,*p,*w=NULL,*head1=NULL;
        if(*L!=NULL){
            for(head=*L;head!=NULL;head=head->next){
                if(head->data%2!=0){
                    if(head1==NULL){
                        head1=head;
                    }else{
                        p->next=head;
                    }
                    p=head;
                }else{
                    if(q==NULL){
                        q=head;
                    }else{
                        w->next=head;
                    }
                    w=head;
                }
            }
            p->next=NULL;
            if(w!=NULL)
            w->next=NULL;
            *L=q;
        }else{
            return NULL;
        }
        return(head1);
    }

1343996-20180422095434034-2067303231.png

3.本题调试过程碰到问题及解决办法:

错误信息1：1343996-20180422095209977-1488731344.png
错误的原因：调试的过程中知道1在建立链表时没将最后一个节点的值赋值为NULL。2.p的地址一直都是head1的起始地址，没有将p的地址变化
修改方法在建立链表的函数中最后加上p->next=NULL，在getodd函数中p=head。
错误信息2.1343996-20180422095326396-470656916.png
错误原因：同样的问题w的地址一直都是q的起始地址没有叫它改变，
改正方法：使w=head。

6-2 学生成绩链表处理

1343996-20180421093325274-238773544.png
1343996-20180421093344415-1800545242.png
1343996-20180421093403582-52271086.png
1343996-20180421093417452-545879044.png

1.设计思路

（1）算法
第一步：声明结构体类型，整型数num，字符数组name[20],整型数score结构体指针变量next，
第二步：主函数中，定义整型min_score，结构体指针变量p，head=NULL，调用函数creatlist，将creatlist的返回值赋给head，
第三步在creatlist函数中，定义结构体指针变量head,p=NULL,q=NULL，对p和q动态分配内存类型强制转化为结构体指针，大小为sizeof（struct stud_node），读入一个数赋给p->num，使用while循环条件为p->num！=0，在循环体中，读入一个字符串和整型数字给p->name和p->score，如果head==NULL，head=p，否则q->next=p。if语句结束执行q=p 在对p动态分配内存类型强制转化为结构体指针，大小为sizeof（struct stud_node），，读入一个数赋给p->num，当while天剑不满足时执行q->next=NULL，返回head给主函数
第四步：在主函数中输入一个数给min_score，调用函数deletelist，将函数的返回值给head，
第五步：定义结构体指针变量p,q,*w，使用if语句，条件为head！=NULL，借助for循环条件1为w=head，条件2为w！=NULL条件3为w=w->next，在循环体中借助if语句条件为w->score<min_score,借助for循环条件1为p=head条件2为min_score<=p->score&&p->next!=NULL条件3为p=p->next，在循环体中执行q=p。直到结束使用if语句条件min_score>p->score，在判断语句中使用if语句条件为p==head执行head=p->next否则执行q->next=p->next，在第一个if语句不满足时返回NULL，最后返回head
第六步：打印链表head，

（2）.流程图：
1343996-20180421093648187-438375877.png

2.实验代码

struct stud_node *createlist(){
    struct stud_node *head=NULL,*p=NULL,*q=NULL;
    p=q=(struct stud_node *)malloc(sizeof(struct stud_node));
    int num;
    char name[20];
    int score;
    scanf("%d",&p->num);
    while(p->num!=0){
        scanf("%s %d",p->name,&p->score);
        if(head==NULL){
            head=p;
        }else{
            q->next=p;
        }
        q=p;
    p=(struct stud_node *)malloc(sizeof(struct stud_node));
    scanf("%d",&p->num);
    }
    q->next=NULL; 
    return (head);
}
struct stud_node *deletelist( struct stud_node *head, int min_score ){
    struct stud_node *p,*q,*w;
    int i;
    if(p!=NULL){
        for(w=head;w!=NULL;w=w->next){
            p=head;
            while(min_score<=p->score&&p->next!=NULL){
                q=p;p=p->next;
            }
            if(min_score>p->score){
                if(p==head){
                    head=p->next;
                }else{
                    q->next=p->next;
                }
            }
        }
    }
    return (head);
}

1343996-20180421082646282-1759461329.png
修改后的代码

struct stud_node *createlist(){
    struct stud_node *head=NULL,*p=NULL,*q=NULL;
    p=q=(struct stud_node *)malloc(sizeof(struct stud_node));
    scanf("%d",&p->num);
    while(p->num!=0){
        scanf("%s %d",p->name,&p->score);
        if(head==NULL){
            head=p;
        }else{
            q->next=p;
        }
        q=p;
    p=(struct stud_node *)malloc(sizeof(struct stud_node));
    scanf("%d",&p->num);
    }
    q->next=NULL; 
    return (head);
}
struct stud_node *deletelist( struct stud_node *head, int min_score ){
    struct stud_node *p,*q,*w; 
    if(head!=NULL){
            for(w=head;w!=NULL;w=w->next){
                if(w->score<min_score){
                    for(p=head;min_score<=p->score&&p->next!=NULL;p=p->next){
                        q=p;
                    }
                    if(min_score>p->score){
                    if(p==head){
                        head=p->next;
                    }else{
                        q->next=p->next;
                    }
                }       
            }
        }
        return (head);
    }
    else{
     return NULL;
    }
    
}

1343996-20180421082804683-47159143.png

3.本题调试过程碰到问题及解决办法:

错误信息11343996-20180421082646282-1759461329.png
错误原因：只删除一个不满足条件的节点。
改正方法，使用for循环每找到一个不满足条件的就执行一次删除操作。

6-3 链表拼接

1.设计思路：

（1）算法：自己的思路有问题；
（2）流程图

2.实验代码：

struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2){
    struct ListNode *head,*p,*q;
    int a[10],i=0;
    for(p=list1;p!=NULL;p=p->next){
        a[i++]=p->data;
    }
    for(p=list2;p!=NULL;p=p->next){
        a[i++]=p->data;
    }
    int j,n,k,temp;
    n=i;
    for(i=0;i<n-1;i++){
        k=i;
        for(j=i;j<n;j++){
            if(a[j]<a[k]){
                j=k;
            }
        }
        if(k!=i){
            temp=a[i];a[i]=a[k];a[k]=temp;
        }
    }
    for(i=0;i<n;i++){
        p->data=a[i];
        if(head==NULL){
            head=p;
        }else{
            q->next=p;
        }
        q=p;
    }
    q->next=NULL;
    return head;
}

1343996-20180422120510166-1286753990.png

3.本题调试过程碰到问题及解决办法:

错误信息1：1343996-20180422120616443-23015887.png

错误原因：考虑不全面
改正方法：不会。

博客上的题目

1343996-20180422134733697-217899640.png
实验代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
long *zhishu(long *p,int a,int b);
void print(long *p,int a,int b);
int main()
{
    int a=201,b=3936,i,j;
    long n[a*b],*p;
    for(i=0;i<a;i++){
        for(j=0;j<b;j++){
            n[(i+1)*(j+1)]=(i+1)*(j+1);
        }
    }
    p=zhishu(n,a,b);
    print(p,a,b);
    return 0;
 } 
 long *zhishu(long *p,int a,int b){
    int i,j,c=2,d=0;
    long *q=p;
    j=a*b;
    for(i=0;i<j&&c<=sqrt(a*b);i++){
        d=0;
        if(*(q+i)!=1){
            if(*(q+i)%c!=0){
                q[d++]=*(q+i);
                }
            }
        j=d;
        c=q[0];
    }
    return q;
 }
 void print(long *p,int a,int b){
    int i;
    for(i=0;*(p+i)<=a*b;i++){
        if((i+1)%5!=0){
            printf("%ld ",*(p+i));
         }else{
            printf("%ld\n",*(p+i));
         }
     }
 }

运行出错，不会写
修改后的代码：

#include <stdio.h>
#include <stdlib.h>
#define N 20
#define M 39 
void delete(int s[N][M],int x); 
int main()
{
    int i,j,a[N][M],num=1;
    for(i=0;i<N;i++){
        for(j=0;j<M;j++){
            a[i][j]=num;
            num++;
        }
    }                       //创建一个二维数组，元素从1 到N*M 
    a[0][0]=0;                //a[0][0]=1不是质数，将它赋值为0 
    for(i=0;i<N;i++){
        for(j=0;j<M;j++){
            if(a[i][j]!=0){
                delete(a,a[i][j]);  //调用函数进行筛选法 ，每调用函数一次数组a，a的值都会发生变化，不是质数的元素赋值为0 
            }
        }
    }
    for(i=0;i<N;i++){
        for(j=0;j<M;j++){
            if(a[i][j]!=0){
                printf("%d\t",a[i][j]);
            }
        }
    }                         //将所有的指数（数组中不为0的数）输出 
    return 0;
 } 
 void delete(int s[N][M],int x){
    int i,j;
    for(i=0;i<N;i++){
        for(j=0;j<M;j++){
            if(i!=0||j!=0){          //跳过a[0][0], 
                if(s[i][j]%x==0&&s[i][j]!=x){
                    s[i][j]=0;//将所有的能被想整除的数赋值为0 
                 }
             }
         }
     }
 }

1343996-20180426195204845-494261460.png

反思：

1.在做题之前好好读题，要读懂题的意思
2.不要固定自己的思维，一种方法不可以，可以换个方法。
3.当出现问题的时候，不要抱怨，自暴自弃，要多想一想

1343996-20180422204136575-1755675715.png
1343996-20180422204648916-1217159890.png
代码存放：
git
评论我的博客同学：
姜健https://i.cnblogs.com/EditPosts.aspx?postid=8778302
陆文奇：https://i.cnblogs.com/EditPosts.aspx?postid=8778302
党睿：https://i.cnblogs.com/EditPosts.aspx?postid=8778302
辛静瑶：https://i.cnblogs.com/EditPosts.aspx?postid=8778302
我所评论的同学：
姜健：http://www.cnblogs.com/jj990519/p/8763063.html
袁中：http://www.cnblogs.com/2719610441qqcom/p/8762037.html
王姝雯：http://www.cnblogs.com/phsudie/p/8759331.html
党睿：http://www.cnblogs.com/dangrui/p/8797836.html
辛静瑶：http://www.cnblogs.com/X-JY/p/8761685.html
知识点总结：
char name[]={"Follow me","BASIC"，......}
指针数组相当于二维数组；
name ——>二维数组的首元素的地址 =name[0]——>行指针——>第0行首元素的地址/第0个字符串的起始地址
name[1]——>行指针——>第一行首元素的地址 /第一个字符串的起始地址
name——>列指针——>第0行第0列元素的地址/指向第0个字符串的第0个字符的地址
*（name+1）——>列指针——>第一行第0列元素的地址/指向第一个字符串的第0个字符的地址。

（name+i）+n ==>第i行第n列元素的地址
((name+i）+n)==>第i行第n列元素的值 例如 ((name+1）+1)=‘A’
链表其实就是结构递归定义，有一个头指针变量，还有表尾，表尾的地址部分放一个NULL表示链表结束。
形式
struct student{
int num；
float score；
......
struct student next; //最主要的
}；
在链表中要使用动态分配内存
malloc函数，malloc函数的返回值是一个分配域的起始地址
在链表中形式为：p=（struct student *）malloc（sizeof struct student ）；
对链表的操作：建立动态链表、输出、插入、删除；
建立链表的函数：

struct student *creat（void）{
    struct student *head=NULL，*p=NULL，*q=NULL;
    p=q=(struct student *)malloc(sizeof(struct student));
    scanf("%d",&p->num);
    while(p->num!=0){
        if(head==NULL)head=p;
            else q->next=p;
            q=p;
         p=(struct student *)malloc(sizeof(struct student));
        scanf("%d",&p->num);
    }
    q->next=NULL;
    return(head);
}

输出链表：

void print(struct student *head){
    struct student *p;
    for(p=head;p!=NULL;p=p->next）{
            printf("%d %f ...."p->num,p->score,.....);
        }
}

删除节点：

struct student *deleatstruct student *head,int num）{
    struct student *p,*q;
    if(head!=NULL){
        for(p=head;p->next!=NULL&&p->num!=num;p=p->next){
            q=p;
        }
        if(p->num==num){
                if(p==head)head=p->next;
                    else q->next=p->next;
            }
    }else{
    printf("没有找到"）；
    }
     return(head);
}

插入节点：

struct student *insert（struct student *head，struct student *stud）{
    struct student *p,*q;
    if(head!=NULL){
        for(p=head;p->num!=stud->num&&p->next!=NULL;p=p->head){
            q=p;
        }
        if(p->num==stud->num){
            if(p==head){head=stud;stud->next=p;}
            else{q->next=stud;stud->next=p;}
        }else{p->next=stud;stud->next=NULL}
    }  
return(head);  
}

转载于:https://www.cnblogs.com/chenxidream/p/8778302.html

weixin_30648587
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第三次作业
qq_43869731的博客
11-08 185
第三次作业 第一题：统计 this.txt 文件中字母（‘a’-‘z’)、大写字母（ ‘A’-‘Z’）、数字(0-9)、其他字符的个数。 import os File = open(r"D:\soft\jupyter\MyWork\this.txt") File2 = open(r"D:\soft\jupyter\MyWork\record.txt","w") sort = {} ...
牛客网成绩排序c语言,成绩排序
weixin_39905226的博客
05-18 272
11STL用着就是方便！#include#include#includeusing namespace std;struct student{int num;int score;};bool cmp(const student& a,const student b){if(a.scorereturn true;else if(a.score==b.score&&a.numr...
成绩排序
yafeile的博客
03-23 115
题目要求如下: 求解思路: 为了实现对学生与成绩的组合,可以使用C中的结构体进行数据存储 其中num表示学号,score表示成绩 使用排序算法对数组进行排序 输出排序后的结果 其中排序使用C库标准函数qsort,其函数原型为: void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*)) 该函数最后1个参数为1个函数指针,其形参为const void*。我们将其转换为对应的类型
奇数值结点链表
zxc0074869的博客
03-25 709
本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下： struct ListNode { int data; ListNode *next; }; 函数接口定义： struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L ); 函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单
6-5 奇数值结点链表 (20分)
weixin_45773503的博客
01-02 3425
6-5 奇数值结点链表 (20分)本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下： struct ListNode { int data; ListNode *next; }; 函数接口定义： struct ListNode *readlist(); struct ListNode *getodd( struct ListNode *...
奇数值结点链表 (20 分)
JJJ's blog
05-01 3607
本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下： struct ListNode { int data; ListNode *next; }; 函数接口定义： struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L ...
贵州大学高级语言第三次作业平时作业
a9010064的博客
10-25 1203
1.X侦探收到了一封匿名信，信封没有透露任何寄信人的信息，内容上也完全看不懂，仿佛是一堆乱码，但是在经过十分之一微秒的思考之后，他发现了其中的奥妙，啊！他发现如果把所有字符后移三位就可以得出本来的意思，例如：dwr后移三位可得gzu，如果是x,y,z则循环后移变成a,b,c，但是信件内容太多了，希望你能帮他。猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。第二天早晨又将剩下的桃子吃掉一半，又多吃了一个。例如，6的因子为1、2、3，而6=1+2+3，因此6是“完数”。1、 求出它是几位数；
c语言第九次作业.zip
11-19
第九次作业可能是针对学习者在C语言课程中关于某个特定主题的练习，旨在巩固和深化他们对C语言的理解。 在C语言的学习过程中，有几个核心知识点是必不可少的： 1. **基本语法**：包括变量定义、数据类型（如int, ...
北航程序设计语言原理作业 第五次作业
05-04
### 北航程序设计语言原理作业第五次作业分析 本次作业是关于北航程序设计语言原理课程中的一个实践任务，其核心目标在于让学生理解和运用并发编程技术，将一个原本顺序执行的问题改造成能够并行处理的形式。这不仅...
第三次高级机器学习作业（强化学习）.zip
04-16
在这个“第三次高级机器学习作业（强化学习）”中，我们可以预期涵盖一系列关键概念和技术。 首先，强化学习的基础是马尔可夫决策过程（MDP）。MDP模型包括状态空间、动作空间、转移概率、奖励函数和折扣因子。理解...
SIGS-嵌入式高级应用 第7次作业：ADC&DAC+源代码+文档说明
12-17
SIGS-嵌入式高级应用 第7次作业：ADC&DAC+源代码+文档说明 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的课程设计，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心...
6-7 奇数值结点链表 （20 分）
matthew_leung的博客
11-08 9211
6-7 奇数值结点链表 （20 分） 本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下： struct ListNode { int data; ListNode *next; }; 函数接口定义： struct ListNode *readlist(); struct ListNode *getodd( ...
习题11-7 奇数值结点链表（20 分）提问
pinguo的博客
07-23 9911
本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下： struct ListNode { int data; ListNode *next; }; 函数接口定义： struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L ...
PTA习题11-7 奇数值结点链表（20 分） 改进版
Albert_Albert_Albert的博客
08-24 3755
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define N 20 typedef struct ListNode{ int Data; ListNode *Next; }ListNode; ListNode *readlist(); ListNode *getodd(ListNode **L); void printl...
6-5 奇数值结点链表 (20 分)
weixin_43301333的博客
10-20 3905
本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下： struct ListNode { int data; ListNode *next; }; 函数接口定义： struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L ); 函...
C语言入门：奇数值节点链表
Rivival_S 的博客
08-13 4390
奇数值节点链表：输入若干个正整数（输入-1为结束标志）建立一个单向链表，头指针为L，将链表L中奇数值的节点重新组成一个新的链表NEW，并输出新建链表的信息。试编写相应程序。 #include #include struct a { //结构a的定义 int n; struct a *next; } A; struct a *creat() //建立链
Awesome_mixins-0.4-py2-none-any.whl.zip
最新发布
09-05
Awesome_mixins-0.4-py2-none-any.whl.zip
北邮高级语言程序设计：第三次阶段作业精选题目及解析
本次提供的文档是北京邮电大学高级语言程序设计课程的第三次阶段作业，涵盖了多项关于面向对象编程的概念和语法。以下是部分题目及知识点的详细解析： 1. 问题涉及的知识点是类的成员修饰符，其中"C. static"选项...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值