链表的归并

归并两个递增序列链表为一个递减有序链表 归并两个递增序列链表为一个递减有序链表 时限:1000ms 内存限制:10000K  总时限:3000ms 描述 假设有两个按元素值递增有序排列的线性表a和b,均以单链表作为存储结构,请编程实现将表a和表b归并成一个按元素值递减有序排列的线性表c(注意:非严格递减,也就是说本题中的数据有可能相等),并要求利用原表的结点空间构造c表。   输入 第一行先输入两个小于100的正整数m,n, 阅读详情

有两个按元素递增有序排列的链表L1和L2,编写一个程序将L1表和L2表归并成一个按元素递增有序的链表L3。要求:

  1链表中允许有相同的元素,只要L1,L2,L3单调不减即可;

  2要利用原表空间(即L1表和L2表)的节点空间构造表L3;

分析:

考虑将表2的元素一个个插入到表1的相应位置上构成新表;

首先,创建两个链表(很简单,这里就不细讲了):

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

归并后要将结果打印出来,当然少不了打印函数了:

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

void print(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

void print(node*p)

{

     printf("%d/n",p->item);

        if(p->next==NULL)

        {

            return;

        }

        print(p->next);

}

设计归并函数:combine()

现在考虑:

处理两个链表的节点的关系,那么表1和表2每个都至少都应该有一个指针:这里分别为p和q1:

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

combine(node*l1,node*l2);

void print(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

 

 combine(node*l1,node*l2)

{

       node*p,*q1,*l3,*q2;

          p=l1;

          q1=l2;

         }

void print(node*p)

{

     printf("%d/n",p->item);

        if(p->next==NULL)

        {

            return;

        }

        print(p->next);

}

将表2从头遍历到尾,每访问一个元素i,就在表1中从头开始找,找到的第一个比i大的元素,就把i插入到它的前面;

为了完成插入,指向表2的元素的指针q1后面要紧跟一个指针q2,因为q1指向的节点接入表1后从q1指向的节点开始就不能遍历表2了,有了q2才能继续向下遍历表2;

   遍历表2,在表1中搜索,一共需要两个循环。由前面的分析知这两个循环应该是嵌套的,由于在表1的搜索不一定是全部走完的,一定的情况下要退出,所以搜索表1的循环嵌套在里层:每循环一次相应的指针顺着链表下移一位,(注意内层循环每次结束后p指针要复位!)

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

combine(node*l1,node*l2);

void print(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

 

combine(node*l1,node*l2)

{

       node*p,*q1,*q2;

          p=l1;

          q1=l2;

          q2=q1->next;

      

            while(q2!=NULL)

                     {

                             while(p!=NULL)

                                   { 

                  p=p->next;

                                   }

p=l1;    //注意,p别忘复位!

                           q1=q2;

                        q2=q2->next;

                     }

}

 

void print(node*p)

{

     printf("%d/n",p->item);

        if(p->next==NULL)

        {

            return;

        }

        print(p->next);

}

要实现插入,q1指向的元素只能插在p指针指向的元素的下一个,所以在搜索表1的时候加入这么一个退出条件(找到比q1所指元素还大的元素):符合条件的时候退出里层循环并且将q1指向的元素插入p指向的元素的下一个元素:

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

combine(node*l1,node*l2);

void insert(node*q1,node*p);

void print(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

 

combine(node*l1,node*l2)

{

       node*p,*q1,*q2;

          p=l1;

          q1=l2;

          q2=q1->next;

        

     

            while(q2!=NULL)

                     {

                             while(p!=NULL)

                                   {   if(p->next->item>=q1->item)

                                   {

                               insert(q1,p);

                               break;

                                   }

                  p=p->next;

                                   }

                   p=l1;

                           q1=q2;

                        q2=q2->next;

                     }

             

}

void insert(node*q1,node*p)

{

      

}

 

void print(node*p)

{

     printf("%d/n",p->item);

        if(p->next==NULL)

        {

            return;

        }

        print(p->next);

}

 

设计插入函数insert():

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

combine(node*l1,node*l2);

void insert(node*q1,node*p);

void print(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

 

node* combine(node*l1,node*l2)

{

       node*p,*q1,*q2;

          p=l1;

          q1=l2;

          q2=q1->next;

        

            while(q2!=NULL)

                     {

                             while(p!=NULL)

                                   {   if((p->next->item>=q1->item)||(p->next==NULL))

                                   {

                               insert(q1,p);

                               break;

                                   }

                  p=p->next;

                                   }

                    p=l1;

                           q1=q2;

                        q2=q2->next;

                     }

                     return l3;

}

void insert(node*q1,node*p)

{

       node*turn;

      

       turn=p->next;

          p->next=q1;

          q1->next=turn;

         

      

}

 

void print(node*p)

{

     printf("%d/n",p->item);

        if(p->next==NULL)

        {

            return;

        }

        print(p->next);

}

有一种特殊情况:如果表1中所有元素都比q1指向的元素小,那么这个元素就会被插在表1的最后,还好这可以在同一个inser函数里面实现,加一个判断分支即可;

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

node* combine(node*l1,node*l2);

void insert(node*q1,node*p);

void print(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

 

node* combine(node*l1,node*l2)

{

       node*p,*q1,*l3,*q2;

          p=l1;

          q1=l2;

          q2=q1->next;

          l3=l1;

       if(p->item>=q1->item)

          {  

              l3=q1;

                 q1->next=p;

                 q1=q2;

                 q2=q2->next;

          }

            while(q2!=NULL)

                     {

                             while(p!=NULL)

                                   {   if((p->next->item>=q1->item)||(p->next==NULL))

                                   {

                               insert(q1,p);

                               break;

                                   }

                  p=p->next;

                                   }

                 p=l1;

                           q1=q2;

                        q2=q2->next;

                     }

                     return l3;

}

void insert(node*q1,node*p)

{

       node*turn;

       if(p->next!=NULL)

       {

       turn=p->next;

          p->next=q1;

          q1->next=turn;

          }

       else

       {

       p->next=q1;

       q1->next=NULL;

       }

}

 

void print(node*p)

{

     printf("%d/n",p->item);

        if(p->next==NULL)

        {

            return;

        }

        print(p->next);

}

 

还有一种特殊情况:如果表1第一个元素就比q1指向的元素大,那么就要插在表1的第一个位置,这样表1的表头就变了,所以最后归并后链表的头结点地址不一定是原来表1的头结点地址;

  由题意,这种特殊情况只有在q1指向表2的第一个元素时可能出现,所以他可以单独抽出来排除而不必置于循环中,若存在这种情况,那么表头就变了,所以combine函数应该返回归并后链表的头结点:

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

node* combine(node*l1,node*l2);

void insert(node*q1,node*p);

void print(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

 

node* combine(node*l1,node*l2)

{

       node*p,*q1,*l3,*q2;

          p=l1;

          q1=l2;

          q2=q1->next;

          l3=l1;

       if(p->item>=q1->item)

          {  

              l3=q1;

                 q1->next=p;

                 q1=q2;

                 q2=q2->next;

          }

            while(q2!=NULL)

                     {

                             while(p!=NULL)

                                   {   if((p->next->item>=q1->item)||(p->next==NULL))

                                   {

                               insert(q1,p);

                               break;

                                   }

                  p=p->next;

                                   }

                  p=l1;

                           q1=q2;

                        q2=q2->next;

                     }

                     return l3;

}

void insert(node*q1,node*p)

{

       node*turn;

       if(p->next!=NULL)

       {

       turn=p->next;

          p->next=q1;

          q1->next=turn;

          }

       else

       {

       p->next=q1;

       q1->next=NULL;

       }

}

 

void print(node*p)

{

     printf("%d/n",p->item);

        if(p->next==NULL)

        {

            return;

        }

        print(p->next);

}

漏了什么?没错,如果以q2指向空节点为循环结束条件,那么表2的最后一个节点就不会插入表1了。这里只要在最后另外单独加一个while循环即可

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

node* combine(node*l1,node*l2);

void insert(node*q1,node*p);

void print(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

 

node* combine(node*l1,node*l2)

{

       node*p,*q1,*l3,*q2;

          p=l1;

          q1=l2;

          q2=q1->next;

          l3=l1;

       if(p->item>=q1->item)

          {  

              l3=q1;

                 q1->next=p;

                 q1=q2;

                 q2=q2->next;

          }

            while(q2!=NULL)

                     {

                             while(p!=NULL)

                                   {   if((p->next==NULL)||(p->next->item>=q1->item))

                                   {

                               insert(q1,p);

                               break;

                                   }

                  p=p->next;

                                   }

                                   p=l1;

                           q1=q2;

                        q2=q2->next;

                     }

          while(p!=NULL)

                {

                   if((p->next==NULL)||(p->next->item>=q1->item))

                                   {

                               insert(q1,p);

                               break;

                                   }

                      p=p->next;

                }

                     return l3;

}

void insert(node*q1,node*p)

{

       node*turn;

       if(p->next!=NULL)

       {

       turn=p->next;

          p->next=q1;

          q1->next=turn;

          }

       else

       {

       p->next=q1;

       q1->next=NULL;

       }

}

 

void print(node*p)

{

     printf("%d/n",p->item);

        if(p->next==NULL)

        {

            return;

        }

        print(p->next);

}

代码清单:

#include<stdio.h>

#include<stdlib.h>

typedef struct node

{

     int item;

        node*next;

}node;

void create(node*p);

node* combine(node*l1,node*l2);

void insert(node*q1,node*p);

void print(node*p);

main()

{

       int m;

         node*l1,*l2,*l3;

               l1=(node*)malloc(sizeof(node));

         printf("Please enter the first number of list1:/n");

               scanf("%d",&m);

               l1->item=m;

               create(l1);

        

               l2=(node*)malloc(sizeof(node));

               printf("Please enter the first number of list2:/n");

               scanf("%d",&m);

               l2->item=m;

               create(l2);

         l3=combine(l1,l2);

               print(l3);

 

}

void create(node*p)

{

       int i;

       printf("Please enter a number:/n");

       scanf("%d",&i);

       if(i==-1)

       {

              p->next=NULL;

              return;}

              else

              {

    p->next=(node*)malloc(sizeof(node));

       p->next->item=i;

       create(p->next);

              }

}

 

node* combine(node*l1,node*l2)

{

       node*p,*q1,*l3,*q2;

          p=l1;

          q1=l2;

          q2=q1->next;

          l3=l1;

       if(p->item>=q1->item)

          {  

              l3=q1;

                 q1->next=p;

                 q1=q2;

                 q2=q2->next;

          }

            while(q2!=NULL)

                     {

                             while(p!=NULL)

                                   {   if((p->next==NULL)||(p->next->item>=q1->item))

                                   {

                               insert(q1,p);

                               break;

                                   }

                  p=p->next;

                                   }

                                   p=l1;

                           q1=q2;

                        q2=q2->next;

                     }

          while(p!=NULL)

                {

                   if((p->next==NULL)||(p->next->item>=q1->item))

                                   {

                               insert(q1,p);

                               break;

                                   }

                      p=p->next;

                }

                     return l3;

}

void insert(node*q1,node*p)

{

       node*turn;

       if(p->next!=NULL)

       {

       turn=p->next;

          p->next=q1;

          q1->next=turn;

          }

       else

       {

       p->next=q1;

       q1->next=NULL;

       }

}

 

void print(node*p)

{

     printf("%d/n",p->item);

        if(p->next==NULL)

        {

            return;

        }

        print(p->next);

}

高效链表排序-归并算法 排序算法应该是最基础的了,快速、归并、选择、堆排序等等对于数组而言可以随机访问,那么对于链表呢,比如快排,两个指针分别网后往前走,而没有前驱指针的单向链表,无法完成这样的操作,当然了可以采用快慢指针的方式,在提交leetcode的时候,发现快排是会超时的。那么对于链表而言,可以采取一种怎么样的高效排序算法呢归并排序分而治之,分别拍好前后两个部分,然后合并两个有序链表,在合适不过,并且由于链表自带属性 阅读详情

相关推荐

链表归并的操作,将两个链表合并成一个链表

用于数据结构中链表的归并操作,可以将连个链表的数据类型的数据合并成一个链表

链表的归并排序

链表的归并 主要有2种方法。 自顶向下的递归法 自底向上的非递归法 在讨论具体的归并排序前,必须清楚以下几个问题! 如何找到链表中点? ----------------------------->快慢指针法. public Link find_Mid(Link head) { Link fast = head; Link slow = he...

weixin_39657557的博客 1547

Unity 2022.3.3 LTS + Visual Studio 2022:手把手教你复刻《吸血鬼幸存者》核心战斗(附完整项目源码)

本文详细介绍了如何使用Unity 2022.3.3 LTS和Visual Studio 2022从零构建《吸血鬼幸存者》式战斗系统。通过图文开发教程,涵盖对象池优化、ECS架构雏形、2D物理碰撞控制等关键技术,帮助开发者高效复刻这款热门游戏的自动攻击与海量刷怪机制。

weixin_30721077的博客 460

链表的归并(21.6.2)

题目描述: 假设有两个按元素值递增有序排列的线性表,均以单链表形式存储,编写一个算法将这两个单链表归并成一个按元素值递减次序排列的单链表,并要求利用原来两个单链表的结点存放归并后的单链表。 算法思路: 两个链表已经是有序排列,所以合并时只需要从第一个结点开始比较,将小的结点接到新的链表中,同时后移工作指针。新的链表按递减次序排列,所以建立新的链表时2要采用头插法建立。当比较结束时,可能会有一个链表非空,此时用头插法将剩下的结点依次插入新的节点即可。 代码如下: void MergeList(LinkList

Bzdjsmz的博客 941

吹气压力传感器US6310 US6330调试

更换压力传感器, 从US6310 更换为US6330。 6310有一个准备好引脚,AD转换完成后会给MCU一个脉冲 而6330就没有这个功能,6330这个引脚是用来选择SPI还是I2C接口的。(6330没有复位引脚,内部有POR功能) 因此在实现上是有根本区别的, 其它方面使用的命令也不一样, 6310 A8 A9两条命令,一个命令模块醒来,一个命令模块休眠, 6330只有一条命令AA, 命令模块开始转换。 针对这2个模块作为2种处理方法, 1. 6310,可以设置一...

明天乌儿会歌唱 2027

【数学基础】基于欧拉角表达的旋转顺序

欧拉角旋转顺序

FalschxMico 1385

链表排序:归并排序 - C语言实现

【代码】链表排序:归并排序。

weixin_50577609的博客 1294

FPGA实战:手把手教你用Verilog实现Modbus CRC16校验(附完整代码)

本文详细介绍了在FPGA中实现Modbus RTU协议CRC16校验模块的完整实战方案。针对硬件设计中的时序、资源与性能挑战,文章从算法原理出发,提供了清晰的Verilog模块接口、状态机设计、查表ROM实现及优化策略,并附带了完整的可综合代码与测试平台,帮助工程师高效构建稳定可靠的工业通信系统。

weixin_29164185的博客 434

链表的常用归并操作

链表归并

qq_46412936的博客 381

uniapp - 热更新提示:WGT安装包中manifest.json文件不存在 | unexpected EOF!报错详细解决,完美搞定WGT安装包中WWW目录下manifest.json不存在问题

uniapp,安卓android,苹果ios,热更新,热更新code:-1202报错,,WGT热更新报错,uniapp热更新wgt出现报错manifest.json文件不存,uniapp安卓苹果软件热更新时出现错误unexpected EOF!如何解决,怎么解决热更新wgt报错,app新版本下载安装报错WGT安装包中manifest.json文件不存在,WGT安装包中WWW目录下manifest.json不存在,uniapp热更新报错安装失败[-1201]:WGT/WGTU文件格式错误,uniapp-wgt

✅ 精选推荐文章 1万+

手把手教你完成YOLOv8 PyQt5和PySide6目标检测界面搭建,前台系统+后台管理系统开发实战,可用于大论文凑工作量或毕设必备,全网最详细教程

目标检测是计算机视觉中的重要任务,广泛应用于安防监控、自动驾驶、智能家居等领域。YOLO系列模型由于其高效的检测速度和较高的准确率,成为目标检测任务的首选算法之一。本项目结合 YOLOv8 与 PyQt5,构建了一个图形化界面,便于用户进行目标检测的操作和展示,实现对图片、视频和摄像头的实时目标检测,不仅可以用于大论文的工作量展示,还可以作为毕业设计。支持目标检测、目标分割等模型进来检测

在职AI算法工程师,擅长计算机视觉,YOLO目标检测、分割等,擅长web、pyqt界面可视化,好内容持续更新中,来这里跟大家一起学习,共同进步 1万+

算法实验室-13-基于链表的归并

基于链表的归并 归并的思想还是很简单的,要完成一个归并,还是需要一个归并框架 重新来总结一遍归并的过程 描述为:通过递归将一长串数据二分到原子级,然后排序,合并 基于这样的原理,我们可以对链表的归并先做一个初步的归并框架 ...

qq_37080133的博客 303

静态时序分析—set_sense

set_sense 常见用法

m0_61544122的博客 1万+

链表的归并操作

我们将两个有序的数据集合合并成一个有序的数据集合的方法称为归并 链表的归并操作: 代码如下: #include<stdio.h> #include<malloc.h> #include<string.h> typedef struct _STU//定义一个结构体 { int id; char name[32]; int score; struct _...

bareheadedman的博客 1085

【深度学习|语义分割之UNet】如何使用ResNet50 作为 U-Net 网络的骨干网络(backbone)并使用预训练的 ResNet50 模型。附代码及解读。

【深度学习|语义分割之UNet】如何使用ResNet50 作为 U-Net 网络的骨干网络(backbone)并使用预训练的 ResNet50 模型。附代码及解读。

985小水博的摸鱼日常 3091

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

链表归并

//有两个数值按顺序排列的链表 1,链表 2,将链表1和2归并 成链表 3。#define N 64 typedef struct _list_{ int data; struct _list_ *next; }LinkNode, *Linklist; Linklist cread_linklist(int size); //创建链表头结点 Linklist cread_

azure_2009的专栏 750

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

链表排序-归并

链表排序,可以插入排序,我就不写了。 实现归并排序 归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。   归并操作的工作原理如下: 第一步:申请空间,使其大...

少说,多做。 3427

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

有序链表的归并(数据结构)

有序链表的归并(数据结构) 链表的归并我也是思考了很久,原来有一次写的代码思路是:让第二条链表中的结点一个个往第一条链表里面插,但是辛辛苦苦写了一个小时,最终插入部分的代码还是错误的。 因为我把这个问题弄复杂了。 其实链表的归并完全可以很简单,高效的思路是:将第一条链表头置空拿出来,然后将两条链表作为元素一个个拆出来连上去,这样就只需比较两个链...

Move on 3455

归并两个递增链表至递减链表

#include<stdio.h> #include<stdlib.h> #include<string.h> #define flag 0 typedef int DataType; typedef struct Node { DataType data; struct Node *next; }LNode,*L...

233

链表的归并排序与链表数组的归并排序

链表的归并排序 就是排序找中点,然后中点位置后一个为null,切断链表,也就是分而治之每次分割一半,一直往后分割,直到只剩下一个节点,或者没有节点停止。 public class ListNode{ int val; ListNode next; public ListNode(int x){ this.val = x; ...

AaronCao 346

有序链表的归并

数据结构实验之链表四:有序链表的归并 Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Discuss Problem Description 分别输入两个有序的整数序列(分别包含M和N个数据),建立两个有序的单链表,将这两个有序单链表合并成为一个大的有序单链表,并依次输出合并后的单链表数据。 Input 第一行输入M与N的值...

爱敲代码的小赤佬 521

对链表进行归并排序

题干:对一个链表进行归并排序。 对于数组,归并排序的思想是先将数据分成两部份,分别排序。然后再对已经排好序的两个数组归并。其中在对两部份数组排序时进行递归,最后得到的即是排好序的数组。 对于链表,归并的思想也是如此。需要解决的问题有两个,第一个是如何将链表平均分成两部份。 第二个是将两个有序链表合并成一个有序链表。 解决了这两个问题,归并排序链表就迎仞而解了。 对于第一个问题,可以采用快慢指针的方...

wh义华的专栏 1524

单链表的归并算法思路总结

刚在练习的时候需要将两个递增有序的单链表进行归并处理,之前碰到这种问题,心里总是有些害怕,害怕自己不能完全考虑到所有的情况,怕自己想不明白里面的流程,怕自己做不到。。。但是,我慢慢理解并深以为然的是:越动手去做,越得心应手。好像应了那句,越努力越幸运。很多情况下,生活中的其他场景里,我能够很自然,自信的去思考,去行动,但是对应到程序世界里来,就有些畏手畏脚。明明背后的逻辑,需要的领域知识,自己全都能

Bing's Blog 4805
上一篇: 图的创建与操作
peterlinux
博客等级 码龄17年 1粉丝 8原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值