广工 AnyviewC C语言习题第十、十一章

最新推荐文章于 2025-04-08 17:44:03 发布

囧到没边际

最新推荐文章于 2025-04-08 17:44:03 发布

阅读量2.9k

点赞数 3

分类专栏： AnyviewC 文章标签： C 广工

本文链接：https://blog.youkuaiyun.com/qq_34844814/article/details/85464771

版权

AnyviewC 专栏收录该内容

10 篇文章

订阅专栏

Anyview 第十、十一章

第十章

10.011 请编写一个函数func(char s[], char t[], int n)，

由数组s中长度为n的字符序列构造其逆序列，并存储在数组t中。
例如，由给定字符序列s=“are”求得逆序列t=“era”；由s=“time”
求得t=“emit”。

void func(char s[], char t[], int n) 
/* 数组s的前n个元素存放给定的字符序列，
   数组t的前n个元素存放s的逆序列。
   注意：数组的下标从0开始。
*/
{
    for (int i=0;i<n;++i)
    {
        int j=n;
        t[j-1-i]=s[i];
    }
}

10.015 对长度为n的字符串s1，除首、尾字符外，将其余字符

按ASCII码降序排列，组合成一个新的字符串s2。

要求实现函数：

void func(char *s1, char *s2, int n); 
/* s1为字符串的起始地址，
   s2为新字符串的起始地址，
   n为字符串的长度。
   要求：s1串不能发生改变，
         s2串存放新的字符串。
*/
{
    int  i,j;
    strcpy(s2,s1);
    for (i=1;i<n-1;i++)
    {
        for (j=2;j<n-i;j++)
        {
            if (s2[j]>s2[j-1])
            {
                char t=s2[j];
                s2[j]=s2[j-1];
                s2[j-1]=t;
            }
        }
    } 
}

10.016 对字符串s1，除首、尾字符外，将其余字符

按ASCII码降序排列，组合成一个新的字符串s2。

要求实现函数：

void func(char *s1, char *s2); 
/* s1为字符串的起始地址，
   s2为新字符串的起始地址，
   注意：字符串尾字符之后跟随着一个结束符‘\0’，
         即ASCII码为0的字符，结束符不属于字符串。
   要求：s1串不能发生改变，
         s2串存放新的字符串。
*/
{
    int  i,j;
    int n=strlen(s1);
    strcpy(s2,s1);
    for (i=1;i<n-1;i++)
    {
        for (j=2;j<n-i;j++)
        {
            if (s2[j]>s2[j-1])
            {
                char t=s2[j];
                s2[j]=s2[j-1];
                s2[j-1]=t;
            }
        }
}

/**********

10.018 以字符串s第m(>=0)个字符开始的所有字符，

按升序的次序构成字符串t。
**********/

void substr(char *s, int m, char *t)
/* s为字符串的起始地址，
   m>=0，
   t为新字符串的起始地址，
   注意：字符串尾字符之后跟随着一个结束符‘\0’，
         即ASCII码为0的字符，结束符不属于字符串。
   要求：s串不能发生改变，
         t串存放新的字符串。
*/
{
   char *p=s+m;
    while (*p!='\0')
    {
    	*t=*p;
    	p++;
	}
}

10.033 编写函数，计算年份year中第yearday天相应的月和日。例如，

调用函数month_day(2000,61,&m,&d)之后，m=3，d=1，即2000年的第
61天是3月1日。

要求实现函数：
int month_day(int year, int yearday, int pmonth, int pday)
/ year是年，
yearday是天数，
若year和yearday合理，
则pmonth和*pday是计算得出的月和日，函数返回1；
否则，函数返回0。
*/

int month_day(int year, int yearday, int *pmonth, int *pday) 
/* year是年，
   yearday是天数，
   若year和yearday合理，
   则*pmonth和*pday是计算得出的月和日，函数返回1；
   否则，函数返回0。
*/
{
     int month[12]={31,28,31,30,31,30,31,31,30,31,30,31}; 
    int i,z,y,flag=0;
    int *p1,*p2;
    
    if (year>0 && yearday>0)
    {
        if ((year%4==0 && year %100 !=0) || (year%400==0))
        {
            flag=1;
        }
        
        if (flag)
        {
            month[1]+=1;
            if (yearday>366)
                return 0;
        }
        else
        {
            if (yearday>365)
                return 0;
        }
        
        i=0,z=0;
        y=yearday;
        while (y>0)
        {
            y-=month[i];
            i++;
            z++;
        }
        y+=month[i-1];
        
        if (y==0)
        {
            z-=1;
            y=month[z-1];
        }
        *pmonth=z;
        *pday=y;
        return 1;
    }
    return 0;
}

10.044 请编写一个函数func，通过略去非数字字符，将字符串s转换为

一个整数(不得调用C语言提供的将字符串转换为整数的函数)。

要求实现函数：

long func(char *s) 
/* s是一个数字字符串的地址，
   函数返回值为由s含有的数字字符转换得到的数（包含正负数情况） 
*/
{
    long sum=0;
  	int e=0,i,j=1;
    char *t=s;
    while (*s!='\0')
    {
    	if (*s>='0' && *s<='9')
    	{
    		if (e>0)
				j=10;
			else
				j=1;	
    		sum=sum*j+*s-'0';
        	
        	e++;
    	}
    	s++;
    }
    
    if (*t=='-')
    sum=-sum;
    return sum;
}

10.105 请编写一个函数findmax(int []s, int n)，返回数组s中n(>0)个整数

中的最大值。注意：要求在函数中采用指针（而不是下标）来处理数组元素。int findmax(int s[], int n)

int findmax(int s[], int n)    
/* 返回s中n(>0)个整数的最大值。
   注意：要求在函数中采用指针（而不是下标）来处理数组元素。
*/
{

}

第十一章

11.033 链表L存储了多个人的信息。写一函数，求这些人中年龄最大

（即出生日期最小）者的名字。
结构体类型定义如下：

    struct date{int year; int month; int day;}; //日期结构体类型
    struct studentNode    //链表结点的结构体类型
    {  char name[10];     //人名
       struct date birth; //出生日期
       struct studentNode *next
    };

char *oldest(struct studentNode *L)
/* 若L是空表，则返回空指针null
   否则返回表中年龄最大者的名字
 */
{
    struct studentNode *p;
   struct studentNode *max;
   char *n;
   
   max=L;
   if (NULL==L) return NULL;
   p=L->next;
   while (p)
   {
        if (max->birth.year > p->birth.year)
            max=p;
        else if(max->birth.year == p->birth.year)
        {
            if (max->birth.month > p->birth.month)
                max= p;
            else if(max->birth.month == p->birth.month)
            {
               if (max->birth.day > p->birth.day)
                    max= p;
            }
        }                                                            
        p=p->next;
   }
   return max->name;
}

11.073 课程链表结点的结构体类型定义如下：

    struct courseNode   //课程链表结点的结构体类型
    {  int   cID;       //课程号，取值0~99
       char  name[10];  //课程名
       float credit;    //学分，取值0~5
       int   semester;  //学期，取值1~8
       struct courseNode *next;
    };

  结构体链表Lc存储了各学期多门课程的信息。写一函数，
  求学期s的总学分。
 */

float creditSum(struct courseNode *Lc, int s)
/* 若Lc是空表，则返回0;
   否则返回学期s的总学分
 */
{
    struct courseNode *p;
   float sum=0.0;
   if (NULL==Lc) return 0.0;
   p=Lc;
   while (p)
   {
        if (p->semester==s)
            sum+=p->credit;
        p=p->next;
   }
   return sum;
}

11.173 课程链表结点的结构体类型定义如下：

    struct courseNode   //课程链表结点的结构体类型
    {  int   cID;       //课程号，取值0~99
       char  name[10];  //课程名
       float credit;    //学分，取值0~5
       int   semester;  //学期，取值1~8
       struct courseNode *next;
    };
    ```
  结构体链表Lc存储了多门课程的信息。写一函数，将课程号
  为c的课程的学分修改为t。
 */

struct courseNode *creditChange(struct courseNode *Lc, int c, float t)
/* 若课程c不存在，则修改不成功，返回null;
   否则修改该课程的学分为t，返回指向该课程结点的指针。
 */
{
    struct courseNode *p;
    int flag=0;
    if (NULL==Lc) return NULL;
    if (c==Lc->cID)
    {
        p=Lc;
        p->credit=t;
        return p;
    }
    p=Lc->next;
    while (Lc->next)
    {
        if (Lc->next->cID==c)
        {
            p=Lc->next;
            p->credit=t;
            flag++;
        }
            
        Lc=Lc->next;
    }
    if (flag)
        return p;
    else
        return NULL;    
}

11.183 课程链表结点的结构体类型定义如下：

    struct courseNode   //课程链表结点的结构体类型
    {  int   cID;       //课程号，取值0~99
       char  name[10];  //课程名
       float credit;    //学分，取值0~5
       int   semester;  //学期，取值1~8
       struct courseNode *next;
    };

结构体链表Lc存储了多门课程的信息。写一函数，将课程号为c的课程结点删除。

要求实现下列函数：

struct courseNode *deleteCourse(struct courseNode **Lc, int c)
/* 若在链表Lc中课程c不存在，则删除不成功，返回null;
   否则从链表Lc中删除该课程结点，并返回指向该课程结点的指针。
 */
{
    struct courseNode*p;
    p=*Lc;
    while (p!=NULL)
    {
        if (p->next->cID==c)
        {
            struct courseNode*t=p->next;
           p->next=p->next->next;
           return t;
        }
        if (p->next==NULL)
        {
            if (p->cID==c)
            {               
               Lc[0]=NULL;
               return p;
            }
        }
        p=p->next;
    }
    return NULL;
}