精华内容
下载资源
问答
  • c语言实现链表排序,利用选择排序的思想,可以供大家学习。
  • 因为在以前做过数组的选择排序,所以本来以为链表差不多,但是在实际操作的时候出现了很多问题。 1.首先是怎么交换位置,诚然,利用改变指针的指向可以交换节点,但是我觉得可以通过交换结构体的内容 代码,结构体...

    在实现学生成绩(存入很多类型数据,如学号,成绩,课程号等)排序的时候,要根据正序输出。因为在以前做过数组的选择排序,所以本来以为链表差不多,但是在实际操作的时候出现了很多问题。

    1.选择排序的原理就是在这里插入图片描述

    2.首先是怎么交换位置,诚然,利用改变指针的指向可以交换节点。但是我觉得可以通过交换结构体的内容,而不动节点本身。

    typedef struct student{
        int sno;
        char sname[10];
        char sex;
        char major[10];
    }Student;
    
    typedef struct course{
        int cno1;
        char cname1[20];
        int classHours1;
        int cno2;
        char cname2[20];
        int classHours2;
        int cno3;
        char cname3[20];
        int classHours3;
    }Course;
    
    typedef struct courseGrade{
        int sno;
        int cno1;
        int score1;
        int cno2;
        int score2;
        int cno3;
        int score3;
    }CourseGrade;
    
    
    typedef struct allInformation{
        struct student student;*student;
        struct course course;
        struct courseGrade courseGrade;
    }AllInformation;
    
    typedef struct linknode{
        AllInformation a;
        struct linknode *next;
    }LinkStNode;//重点,只需要交换'a'
    

    3.在初始化指向结构体的指针时需要赋值 ,否则就成为悬空指针,后果不可预知。

    4.第一个for循环对应被比较的指针的移动,第二个for循环对应第二个比较指针的移动。第一个,第二个循环的结束条件都是是pt2!=NULL;

    5.注意,指向结构的指针(最外层的结构名)指向内容时,用**‘->’。下层结构用‘.’** 翻译为“的”。

    6.一个关键点是,pt1的内容和pt2内容的交换。因为基本思路是不交换节点,只交换节点的内容(之所以结构的嵌套也是为了实现这个思路),所以需要一个p存储pt1的内容(如同所有交换数值的操作)。这个时候p不能是指针。
    LinkStNode *p=pt1;//这是错的 LinkStNode p; p.a=pt1->a;//这是对的
    因为,如果将这里将pt1赋值给p,相当于将pt1指针赋值给指针p,pt1变化,p也会变化,所以要把p变为结构体而不是指针。

    因此,此函数如下

    LinkStNode* SortList(LinkStNode* pHeadNode){
        LinkStNode* pt1=NULL;
        LinkStNode* pt2=NULL;
        
        
        
        for(pt1=pHeadNode->next,pt2=pt1->next;
            pt2!=NULL;
            pt1=pt1->next,pt2=pt1->next
            ){
            for(;pt2!=NULL;pt2=pt2->next){if ((pt1->a.student.sno)>(pt2->a.student.sno)){
                LinkStNode p;//LinkStNode*必须初始化时便赋
                p.a=pt1->a;
                pt1->a=pt2->a;
                pt2->a=p.a;}
            }
         
        }
        return pHeadNode;
        }//链表的选择排序
    
    

    还有需求没有实现,任重而道远。

    展开全文
  • C语言单链表实现选择排序

    千次阅读 2019-03-12 12:00:27
    链表实现选择排序有两种方法,一种是交换节点内的数据,比较简单。我这里使用的是第二种方法,交换节点。 #include<stdio.h> #include<stdlib.h> #include<string.h> #...

    链表实现选择排序有两种方法,一种是交换节点内的数据,比较简单。我这里使用的是第二种方法,交换节点。

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<math.h>

    #pragma warning(disable:4996)
    typedef struct Node {
        int data;
        struct Node *next;
    }node;


    int main()
    {
        node *head = malloc(sizeof(node));
        node *p,*q,*min,*r;
        int i;
        head->next = NULL;
        head->data = 0;
        p = head;
        for (i = 0; i < 6; i++)
        {
            q = malloc(sizeof(node));
            scanf("%d", &q->data);
            p->next = q;
            p = q;
        }
        p->next = NULL;
        p = head;
        while (p->next)
        {
            min = p;
            q = p->next;
            while (q->next)
            {
                if (min->next->data > q->next->data)
                    min = q;
                q = q->next;
            }
            if (min != p)
            {
                r = min->next;
                min->next = min->next->next;
                r->next = p->next;
                p->next = r;
                p = p->next;
            }
            else
                p = p->next;
        }
        p = head->next;
        while (p)
        {
            printf("%d\n", p->data);
            p = p->next;
        }
        return 0;
    }

    展开全文
  • 链表排序讲解: head指针指向链表的头结点,是找到整个链表的唯一依据,如果head指针丢失,整个链表就找不到了。 head存储的是第一个节点的...单向链表选择排序图示: ---->[1]---->[3]---->[2]...--...

     

    链表排序讲解:

    head指针指向链表的头结点,是找到整个链表的唯一依据,如果head指针丢失,整个链表就找不到了。

     head存储的是第一个节点的地址,head->next存储的是第二个节点的地址;  任意一个节点p的地址,只能通过它前一个节点的next来求得。

     

    单向链表的选择排序图示: ---->[1]---->[3]---->[2]...---->[n]---->[NULL](原链表)

                                            head   1->next  3->next  2->next   n->next

     选择排序(Selection sort)是一种简单直观的排序算法。

    首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。

    动画演示:http://www.nowamagic.net/librarys/veda/detail/1849

     

    选择排序

    定义的结构体

    struct student
    {  
    char ID[11]; //学生学号
    char name[20];  //学生姓名
     
    struct student *next;  //next 指针 指向 struct  student 类型的变量
    }stu;
    
     

     

    里面的变量均为数组

    那怎么实现结构体中定义(有)数组变量,链表遍历结构体,按照结构体里面变量来排序呢?

    其中对数组比较大小、比较两个字符串的大小来使用的函数是: strcmp()  也就是string compare字符串比较。

    对数组之间的赋值函数是 strcpy()  ==="string copy"

     

     

    升序:

    /***************
    
    函数功能:
    升序排列出勤学生
    返回:指向链表表头的指针
    
    /***************/
    
    
    struct student *sort_message_order(struct student* head) //升序  按照ID顺序
    
    {   
        struct student *Back,*pointer; //p指针指向新的节点 back指针指向链表的尾节点
        struct student  temp; // 定义结构体student别名,typedef也可以定义的结构体别名
        Back=head->next; 
        pointer=head->next; //跳过头结点 指向下一个节点 头结点中没有学生信息 
        while(Back!=NULL) //如果尾节点不为空 就一直遍历下去
        {
            while(pointer->next!=NULL) //如果指向新开辟的结点不为空就一直遍历下去
            {
                pointer=pointer->next; //指向下一个新开辟的结点
                if ( strcmp( Back->ID,pointer->ID)>0  )  //如果back->ID大于pointer->ID就返回大于0的值;后面大于前面的 往后放
                {
                    strcpy(temp.ID,Back->ID);
                    strcpy(temp.name,Back->name);  //把尾节点值赋值给临时temp结构体变量
                    
                    
                    strcpy( Back->ID,pointer->ID);
                    strcpy(Back->name,pointer->name); //把指向的新节点 跟尾节点交换 位置
                    
                    
                    strcpy(pointer->ID,temp.ID);
                    strcpy(pointer->name,temp.name);//将临时temp结构体变量赋值给指向的结构体变量
                    
                }
            }
            Back=Back->next; //指向下一个尾节点
            pointer=Back;  //指向尾节点
        }
        return head;  //返回头结点
        
    }

     

     

    降序:

    /***************
    
    函数功能:
    降序排列出勤学生
    返回:指向链表表头的指针
    
    /***************/
    
    struct student * sort_message_Desc(struct student* head)//Descending降序
    {
        struct student *Back,*pointer; //p总是指向新申请的结点  back总是指向链表的尾节点
        struct student  temp;
        Back=head->next;
        pointer=head->next;//跳过头结点,头结点中没有学生信息
        while(Back!=NULL)
        {
            while(pointer->next!=NULL)
            {
                pointer=pointer->next;
    
                if ( strcmp( Back->ID,pointer->ID)<0  ) // back->ID小于pointer->ID返回负数 把最小的 往后放  降序
                {
                    strcpy(temp.ID,Back->ID);
                    strcpy(temp.name,Back->name);     //把尾节点值赋值给临时temp结构体变量
                    
                    strcpy( Back->ID,pointer->ID);
                    strcpy(Back->name,pointer->name); //指向的新节点 跟尾节点交换 位置
                                
                    strcpy(pointer->ID,temp.ID);
                    strcpy(pointer->name,temp.name);  //将临时temp结构体变量赋值给指向的结构体变量
                }
            }
            Back=Back->next; //指向下一个尾节点
            pointer=Back;   //指向尾节点
        }
        return head;  //返回头结点
    }

     

     

    输出打印链表内容:

    void Print_List(struct student *head)
    {
        struct student* pointer;
        pointer=head->next; //跳过无数据的头结点
        while(pointer!=NULL)
            {  
                printf(" ",pointer->ID);
                printf(" ",pointer->name);
                 
                pointer=pointer->next;//指向下一个节点
            }     
    }

     

     

     

    转载于:https://www.cnblogs.com/zhaocundang/p/4779563.html

    展开全文
  • 本代码实现了单链表的创建(头插法与尾插法)、单链表的遍历、插入节点、删除节点、 判断表空表满、求表长度、选择算法排序等功能
  • 选择排序 { struct Student *f=NULL,*t=NULL, *max, *maxbf=NULL, * p; while (h!= NULL) { for (p = h, max = h; p->next != NULL; p = p-> next) { if (p->next->score > max-> score) { ...
     #include<stdio.h>
     #include<malloc.h>
     #define LEN sizeof(struct Student)
     struct Student                //结构体声明
    {
      long num;
      int score;
      struct Student* next;
     };
     int n; 
    
    struct Student* creat()           //创建单向链表
    {
      struct Student *head=NULL, *p_before, *p_later;
      p_before = p_later = (struct Student*) malloc(LEN);
      scanf_s("%ld%d", &p_before->num, &p_before->score);
      while (p_before->num!=0)
      {
       n++;
       if (n == 1) head = p_before;
       else p_later->next = p_before;
       p_later = p_before;
       p_before = (struct Student*) malloc(LEN);
       scanf_s("%ld%d", &p_before->num, &p_before->score);
      }
      p_later->next = NULL;
      free(p_before);
      return head;
     } 
    
    struct Student* sort(struct Student* list)               //冒泡排序,当初写的是内容交换而不是指针交换,我知道这不是好的做法,但日子一久,当下没时间和热情改了,大家原谅,
    {                                                                            //等有时间了一定改
     struct Student *p, *q;
      int temp1,i;
      long temp2;
      for (p = list, i =1; i < n;i++,p=p->next)
       for (q = p->next;q!= NULL;q=q->next)  
        if (p->score < q->score)
        {
         temp1 = p->score;
         p->score = q->score;
         q->score = temp1;
         temp2 = p->num;
         p->num = q->num;
         q->num = temp2;
        }
        return list;
     } 
    
    struct Student* sort1(struct Student* h)                //插入排序(下边这堆注释是当初写完代码后又分析时加的,这里必须承认,我参考了网上的一些代码。这里大家要是看不      
     {                                                                            //懂或是不想看,就略过吧。还有,这里“结点”写成“节点”了,纠正一下,不好意思
     struct Student *f, *t, *p=NULL, *q;
      f = h->next;                  //f指向旧链的第一个节点,即等待在新链中“安家落户”(插入)的节点
     h->next = NULL;               //将原链的第一个节点单拿出来作为新链(待插入链)的第一个节点,默认此节点是关键值最大的节点
     while (f!=NULL)    //当f=NULL,旧链中的节点都插入到了新链,排序完成
     {
       for (t = f, q = h; (q != NULL && (q->score > t->score)); p = q, q = q->next);//t和f同指,当找到插入位置,f指向旧链的下一个节点时,用t来进行
                                                        //插入操作;q先指向新链的第一个节点,q不断在新链中后移,以找到f(即t)所指节点的插入位置
                                                        //p作为q的前驱,用来完成插入。整个语句的作用是:在新链遍历完(q != NULL)的前提下,在新
                                                        //链中找到第一个关键值比f(即t)所指节点关键值小的节点,毫无疑问,q的前驱,即p(如果有的
                                                        //话)的关键值一大于定f(即t)所指节点关键值(否则q怎么会后移到当前位置呢?);如果没有,
                                                        //那说明当前新链的头节点关键值比f(即t)所指节点关键值小;如果最后q = NULL了,说明当前新
                                                        //链的最后一个节点(此时p正指向它)的关键值都比f(即t)所指节点关键值大。不管哪种情况,f
                                                         //(即t)所指节点都应插在q所指节点前,p所指节点后(如果有的话)
      f = f->next;         //在进行插入操作前,先使f后移
      if (q == h) h = t;   //如果当前新链的头节点关键值比f(即t)所指节点关键值小,需要将f(即t)所指节点插在该头节点前,先让新链头节点指针指向
                           //f(即t)所指节点,作为新链的新的头节点
      else  p->next = t;   //否则,将f(即t)所指节点连在p所指节点后
      t->next = q; //不管if还是else,都需要将f(即t)所指节点连在q所指节点前,如果q=NULL,就是让f(即t)所指节点的next域指向NULL,这显然也是正确的
     }
      return h;  //返回新链(排好序的链)的头节点指针
    } 
    
    struct Student* sort2(struct Student* h)                                                 //选择排序
    {                                                                                                             
      struct Student *f=NULL,*t=NULL, *max, *maxbf=NULL, *p;                 
    
     while (h!=NULL)                                                                                   
      {
       for (p = h, max = h; p->next != NULL; p = p->next)
       {
        if (p->next->score > max->score)
        {
         maxbf = p;
         max = p->next;
        }
       }
       if (f==NULL)
       {
        f = max;
        t = max;
       }
       else
       {
        t->next = max;
        t = max;
       }
       if (max==h)
       {
        h = h->next;
       }
       else
       {
        maxbf->next = max->next;
       }
      }
      t->next = NULL;
      return f;
     } 
    
    struct Student* sort3(struct Student* h)                                            //这是什么排序呢?我也说不好。这是我自己想出来的算                                                                               
     {                                                                                                        //法……大体思想是:先从链表第一个结点开始遍历链表,找出关键值(这里是成绩score)最大的(因为
     struct Student *p, *q, *pt=NULL, *pbf=NULL, *qbf=NULL;              //是从大到小排序)结点和链表中第一个结点交换(利用指针实现);然后,从链表中第二个结点开始遍历链
     for (p = h ; p->next!=NULL; pbf = p, p = p->next)                           //表,找出关键值最大的结点和链表中第二个结点交换……如此操作,直到从链表中最后一个结点开始的那趟
     {                                                                                                      //遍历和操作结束
      for (q = p; q->next != NULL;q=q->next)                                         //代码格式很不好,写这段代码时在下还很渣很渣……粘贴到这里时,就更不好看了……对不起大家了
      { 
    
       if (p->score < q->next->score)
        {
         qbf = q; q = q->next;
         if (p==h && p->next==q)
         {
          h = q; p->next = q->next; q->next = p; p = q;
         }
         else
         {
          if (p == h&&p->next != q)
          {
           h = q; pt = q->next; q->next = p->next, qbf->next = p; p->next = pt; p = q; q = qbf;
          }
          else
          {
           if (p != h && p->next == q)
           {
            pt = q->next; pbf->next = q; q->next = p; p->next = pt; p = q;
           }
           else
           {
            if (p != h && p->next != q)
            {
             pt = q->next; pbf->next = q; q->next = p->next; qbf->next = p; p->next = pt; p = q; q = qbf;
            }
           }
          }
         }
        }
       }
      }
      return h;
     } 
    
    
    
    
    //快排    这里在下也参考了网上的代码,但在下也着实进行了一番改进才编译通过,这里使用了指针的指针,不详细讲了,大家自己分析吧 
    
    struct Student* Link_Quick_Sort(struct Student ** head, struct Student ** end)          //  注意这里函数返回值可以写成void,同时将return语句去掉,
    {                                                                                       //同时,将main函数中(1)(2)两句改为:
     struct Student * big_head=NULL, *big_end=NULL, *small_head=NULL, *small_end=NULL;   //Link_Quick_Sort(&pt, NULL);
      struct Student * big_tail=NULL, *small_tail = NULL;                                 //for (p=pt, i = 1; i <= n; i++, p = p->next)
      int key = (*head)->score;                              //也是可以的。原因是递归是先进后出,后进先出,二第一次调用时传的是&pt(见main函数中
     struct Student * traversal = (*head)->next;            //第(1)句),故当整个函数结束后,pt的值已修改,且指向排好序的链表的头结点。
     (*head)->next = NULL;                                  
      struct Student *p = NULL;
      while (traversal != NULL)
      {
       if (traversal->score > key)
       {
        if (big_head == NULL) { big_head = traversal; big_tail = traversal; }
        else{ big_tail->next = traversal; big_tail = traversal; }
        traversal = traversal->next;
        big_tail->next = NULL;
       }
       else
       {
        if (small_head == NULL) { small_head = traversal; small_tail = traversal; }
        else{ small_tail->next = traversal; small_tail = traversal; }
        traversal = traversal->next;
        small_tail->next = NULL;
       }
      }
       big_end = big_tail; small_end = small_tail;
       if (big_head != NULL && big_head->next != NULL){ Link_Quick_Sort(&big_head, &big_end); }
       if (small_head != NULL && small_head->next != NULL){ Link_Quick_Sort(&small_head, &small_end); }
       if (big_end != NULL&&small_head != NULL)
       {
        big_end->next = (*head);
        (*head)->next = small_head;
        (*head) = big_head; 
        if (end == NULL){ end = &p; }
        (*end) = small_end;
       }
       else if (big_end!=NULL)
       {
        big_end->next = (*head); 
        if (end == NULL){  end = &p; }
        (*end) = (*head); 
        (*head) = big_head;
       }
       else if (small_head!=NULL)
       {
        (*head)->next = small_head; 
        if (end == NULL){ end = &p; }
        (*end) = small_end;
       }
       return (*head);
     } 
    
    void main()                                                   //用main函数来测试
    {
      printf("请依次输入学生的学和姓名\n");
      printf("学号和姓名间以空格隔开\n");
      printf("输入0 0结束\n");
      struct Student* pt,*p;
      struct Student* creat();
      struct Student* sort();               //这里调用的是冒泡排序,要想调用其它排序,在这里改一下函数调用就可以了
     pt=creat();
      int i;
      for ( p=pt,i = 1; i <=n; i++,p=p->next)
       printf("num=%ld score=%d\n", p->num, p->score);
      printf("排序后:\n");
         p=Link_Quick_Sort(&pt, NULL);     //(1)
      for ( i = 1; i <= n; i++, p = p->next)//(2)
       printf("第%d名: num=%ld score=%d\n",i, p->num, p->score);
     } 
    
    代码已经过测试,在VS2013上成功运行! 
    
    发此文有两大目的: 
    
    1.和大家交流经验,供需要的人参考。 
    
    2.在下菜鸟,代码中难免有不妥之处,恳求大神批评指正。您的批评就是在下提高的起点,对于您的批评,在下将不胜感激! 

     

    转载于:https://www.cnblogs.com/zpcdbky/p/4107360.html

    展开全文
  • 采用C语言实现链表的创建、排序和输出,并提供了两种排序的方式可供选择!!亲测可以运行!
  • 课程设计:c语言链表

    2020-06-05 19:47:58
    目录 ...9)实现链表排序的功能函数。 9 10)实现链表文件读取的功能函数 10 11)实现链表文件存储的功能函数。 11 12)实现菜单选择的功能函数。 11 (四)系统演示及使用说明 12 1).菜单选项 12 2
  • 选择排序C语言实现

    2015-01-11 00:14:59
    数组和链表选择排序
  • C语言实现链表(二)

    2017-05-23 17:02:13
    如下是单向链表的具体实现,主要包括:创建链表、增加结点(头插法,尾插法)、遍历结点、删除结点、排序(插入排序、选择排序、冒泡排序),最后是主函数的验证。 在此先说下我的插入排序(交换指针)的思路:如图 首先...
  • 前言 如果你没有扎实的数据结构的功底,不知道链表与队列、哈希表与二叉查找树使用等。不妨可以考虑从排序算法入手。 字符串排序 ...现在来实现读入字符串,并排序字符串: #include <stdio....
  • 选择排序C语言

    2019-12-23 17:58:49
    选择排序C语言)直接选择排序算法思想程序数组实现链表实现二元选择排序算法思想程序 直接选择排序 算法思想 见:3. 选择排序—简单选择排序(Simple Selection Sort) 程序 数组实现 void swap(int *s1, int *s2...
  • 这里使用插入排序法,因为插入排序法涉及有序区域的后移,所以比较适合使用链表进行做。因为单链表没有prev的默认指针,所以不方便使用快速排序法。综合选择了插入排序 算法草稿 代码实现 int insertSortList...
  • C语言使用指针实现选择法和冒泡法对数字排序 前言 刚学到指针章节,遇到的习题大多是将以前写过的代码用指针的方法再写一次,不过说实话,很多写起来并不是我想像的那简单,而且觉得没啥必要,但是据说到链表指针...
  • 单向链表实现 #include <stdio.h> #include <malloc.h> typedef int DATA; struct SNode { DATA data; SNode* pNext; }; SNode* g_pHead = NULL; void AddHead(DATA data) { SNode* p = (SNode*)...
  • 选择单链表来完成所有操作,便于插入和删除,不利于排序。 程序模块 共11个模块,分别是主函数模块实现操作指令和10个子函数模块,分别是主菜单界面、新建联系人、浏览所有联系人、修改联系人信息、删除联系人、查找...
  • PTA(Basic Level) 1025:反转链表C语言实现) 分析: 最开始的思路是用两个数组,一个数组存入初始状态,另一个数组存储按后继结点排好序的结点。但是测试点5超时了,并且测试点6答案错误,翻看了几篇大家的总结,...
  • 将k个列表的元素依次整合在一个列表中,然后利用简单选择排序排除即可。 void Sort1(struct ListNode *list){ if(list->next==NULL) return; struct ListNode *p=list->next,*q; struct ListNode *...
  • 1.3 选择排序算法 1.4 简单排序算法的复杂性 2 快速排序算法 2.1 算法基本思想及实现 2.2 算法的性能 2.3 随机快速排序算法 2.4 非递归快速排序算法 2.5 三数取中划分算法 2.6 三划分快速排序算法 3 合并排序算法 ...
  • 在上一篇文章中,我们说了时间复杂度为 O(n2)的几个排序算法,冒泡排序、插入排序、选择排序,在理解上和实现上都没有太难的地方,这里在实现的时候,没有再自己实现数组或链表,而是使用了c语言自带的数组进行实现...
  • 这里我给大家做了4种排序算法的实现,分别是:冒泡排序、选择排序、直接插入排序、快速排序。其中冒泡和选择是用链式结构来实现的,因此我这里先定义了链表的基本结构和创建操作。 #include <stdio.h> #...
  • 在VS2017中,用c语言实现链表的初始化,遍历输出,判断空,计算长度,插入,删除,选择排序 以及关于狭义,广义算法,泛型的理解 #include<stdio.h> #include<windows.h> //链表的定义:n个结点离散分配...
  • 编程实现将给定的一组整数采用选择排序法按由小到大的顺序排序。要求: 1) 编写函数create()根据已知整数数组构造一个单链表,假设结点只有一个整数数据域。 2) 编写函数sort()采用选择排序方法对已知链表进行排序...
  • 插入排序、冒泡排序、选择排序、快速排序、希尔排序、堆排序、归并排序、计数排序、桶排序、基数排序 二、插入排序 原理:新建一个数组或者链表,将要排序的数据逐个比对,插入新的数组或者链表里面 void sort(int *...
  • 基础:C语言知识,特别强调:指针和链表的知识.txt 学生信息系统_流程图_粗糙.png 提示:阅读代码可以从head.c或main.c开始;运行程序从main.c开始,登陆账号在userData.txt中设置.txt 效果图1_登陆账号.png 效果图2...
  • 此次实现的排序算法分别是冒泡排序,选择排序,插入排序,希尔排序,快速排序,堆排序,归并排序,基数排序。下面分别对这几种算法进行分析(均是由小到大排序): 冒泡排序 void maopao(int arr[]) { int i,j...
  • 程序实现功能: 用户输入两个多项式,计算机先把输入的多项式进行排序、合并同类项、删除0项,然后输出经过处理后的多项式。之后,用户可以选择对两个多项式进行或加或减或乘的操作。 存储多项式使用的方法是链表...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 165
精华内容 66
关键字:

c语言链表实现选择排序

c语言 订阅