精华内容
下载资源
问答
  • 两个有序单链表归并为一个有序单链表//定义节点 struct ListNode { int m_nValue; ListNode* m_pNext; } ; ListNode* Merge(ListNode* pHead1,ListNode* pHead2) { if(pHead1 == NULL) return pHead2; if...

    两个有序单链表归并为一个有序单链表

    c代码:

    //定义节点
    struct ListNode
    {
        int m_nValue;
        ListNode* m_pNext;
     } ;
     ListNode* Merge(ListNode* pHead1,ListNode* pHead2)
     {
        if(pHead1 == NULL)
        return pHead2;
        if(pHead2 == NULL)
        return pHead1;
    
        ListNode* pMergedHead = NULL;
        if(pHead1->m_nValue<pHead2->m_nValue)
        {
            pMergedHead = pHead1;
            pMergedHead->m_pNext = Merge(pHead1->m_pNext,pHead2);//递归建立
         }
         else
         {
            pMergedHead = pHead2;
            pMergedHead->m_pNext = Merge(pHead1,pHead2->m_pNext);
         }
         return pMergedHead;
     } 
    展开全文
  • void MergeListR(LNode *A,LNode *B,LNode* &C)//采用尾插法建表的链表归并 算法 (A,B为递增链表,C要求为单调不减链表) {  LNode *r=NULL;   LNode *p=A->next;  LNode *q=B->next;  C=A;  C->...
    #include<stdio.h>
    #include<stdlib.h>


    typedef struct LNode
    {
      int data;
      struct LNode *next;;
    }LNode;
        
    void InitList(LNode *&L)
    {
         L=(LNode*)malloc(sizeof(LNode));
         L->next=NULL;
    }
        
    void  CreateListR(LNode *&L,int a[],int n)
    {
          int i;
          LNode *r=L,*s=NULL;
          for(i=0;i<n;i++)
          {
            s=(LNode*)malloc(sizeof(LNode));
            s->data=a[i];
            r->next=s;
            r=s;
          }
          r->next=NULL;
    }


    void VisitList(LNode *L)
    {
         LNode *s=L->next;
         while(NULL!=s)
         {
           printf("%d\n",s->data);
           s=s->next;
         }
    }


    void ListDelete(LNode *&L,int elem)
    {
         
         LNode *s=L;
         LNode *q=NULL;
         while(s->next!=NULL) 
         {
           if(s->next->data==elem)
           {
            q=s->next;
            s->next=q->next;
            free(q);
            return ;
           }
           s=s->next;
         }
    }


    void MergeListR(LNode *A,LNode *B,LNode* &C)//采用尾插法建表的链表归并 算法 (A,B为递增链表,C要求为单调不减链表)
    {
         LNode *r=NULL; 
         LNode *p=A->next;
         LNode *q=B->next;
         C=A;
         C->next=NULL;
         r=C;
         free(B);
         //B=NULL;
        
         while(p!=NULL && q!=NULL)
         {
           if(p->data <= q->data)
           {
             r->next=p;
             
             r=p;
             p=p->next;
           }
           else
           {
               r->next=q;
              
               r=q;
                q=q->next;
           }
           r->next=NULL;
         }
         
         if(NULL==p)
         {
           r->next=q;
           
         }
         else
         {
              r->next=p;
         } 
         
    }


    int main(void)
    {
        const int N=5;
        
        int a[N]={2,3,4,5,6};
        int b[N]={2,4,7,8,9};
        LNode *L,*S,*T;
        InitList(L);
        InitList(S);
        CreateListR(L,a,N);
        CreateListR(S,b,N);
        VisitList(L);
        putchar(10);
        VisitList(S);
        MergeListR(L,S,T);
        VisitList(T); 
        
        
        system("pause");
        return 0;
    }
    展开全文
  • SDUT_有序单链表归并

    2018-03-12 10:02:19
    有序链表的归并Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit StatisticProblem Description分别输入两个有序的整数序列(分别包含M和N个数据),建立两个有序的单链表,将这两个有序单链表合并成为一个大...

    数据结构实验之链表四:有序链表的归并

    Time Limit: 1000 ms  Memory Limit: 65536 KiB

    Problem Description

    分别输入两个有序的整数序列(分别包含M和N个数据),建立两个有序的单链表,将这两个有序单链表合并成为一个大的有序单链表,并依次输出合并后的单链表数据。

    Input

    第一行输入M与N的值; 
    第二行依次输入M个有序的整数;
    第三行依次输入N个有序的整数。

    Output

    输出合并后的单链表所包含的M+N个有序的整数。

    Sample Input

    6 5
    1 23 26 45 66 99
    14 21 28 50 100

    Sample Output

    1 14 21 23 26 28 45 50 66 99 100

    Hint

    不得使用数组!

    Source

    #include<stdlib.h>
    #include<stdio.h>
    typedef struct node{
    	int data;
    	struct node *next;
    }node;
    void createlist(node *&h,int n){
    	node *s,*r;
    	h=(node*)malloc(sizeof(node));
    	h->next=NULL;
    	r=h;
    	for(int i=0;i<n;i++){
    		int a;
    		scanf("%d",&a);
    		s=(node*)malloc(sizeof(node));
    		s->data=a;
    		r->next=s;
    		r=r->next;
    	}
    	r->next=NULL;
    }
    void printlist(node *h){
    	node *r;
    	r=h->next;
    	while(r){
    		printf("%d ",r->data);
    		r=r->next;
    	}
    }
    node* merge(node *h1,node *h2){
    	node *head,*r,*r1,*r2;
    	head=h1; 
    	r=head;
    	r1=h1->next;
    	r2=h2->next;
    	free(h2);
    	while(r1&&r2){
    		if((r1->data)<=(r2->data)){
    			r->next=r1;
    			r=r->next;
    			r1=r1->next;
    		}
    		else{
    			r->next=r2;
    			r=r->next;
    			r2=r2->next;
    		}
    	}
    	if(r1){
    		r->next=r1;
    	}
    	else{
    		r->next=r2;
    	}
    	return head;
    }
    int main(){
    	int m,n;
    	node *h1,*h2,*head;
    	scanf("%d%d",&m,&n);
    	createlist(h1,m);
    	createlist(h2,n);	
    	head=merge(h1,h2);
    	printlist(head);
    	return 0;
    }

    展开全文
  • 使用VC++6.0下实现的两个有序单链表归并
  • #include #include #define N 8 typedef struct list { char c; ... struct list *next;...====C语言将两个递增有序单链表归并为一个降序的单链表,求大侠帮忙看看 程序运行时最后报错,为什么呢? */
  • "归并后的线性链表是:" ) ; K = MergeList ( L , S ) ; PrintList ( K ) ; printf ( "逆置后的线性表是:" ) ; InvertLinkList ( K ) ; PrintList ( K ) ; system ( "pause" ) ; return ...

    数据结构课后题:2.22

    #include<stdio.h>
    #include<stdlib.h>
    #define TRUE 1
    #define FALSE 0
    #define ERROR 0
    #define OVERFLOW 0
    #define OK 1
    typedef  int  ElemType;
    typedef  int  Status;
    typedef struct LNode {
     ElemType data;//数据域
     struct LNode *next;//指针域
    }LNode, *LinkList;
    
    
    LinkList  CreateList_L_Tail(int n)
    {//尾插法建立单链表
     LinkList L;
     LNode *p, *r;
     L = (LinkList)malloc(sizeof(LNode));//创建头结点
     r = L;//r始终指向尾节点,开始时指向头结点
     for (int i = n; i > 0; i--)
     {//循环建立数据节点
      p = (LinkList)malloc(sizeof(LNode));//生成新结点
      scanf_s("%d", &p->data);//创建数据节点*p,输入元素的值
      r->next = p;//将*p插入到*r之后
      r = p;
     }
     r->next = NULL;
     return L;
    }
    
    
    void PrintList(LinkList L)
    {
     LNode* p;
     p = L->next;
     while (p != NULL)
     {
      printf("%5d", p->data);
      p = p->next;
     }
     printf("\n");
    }
    
    
    LinkList MergeList(LinkList a, LinkList b)
    {
     LNode *pa, *pb, *pc, *pan, *pbn;
     pa = a->next;
     pb = b->next;
     pc = a;
     pc->next = NULL;
     while (pa&&pb)
     {
      if (pa->data < pb->data)//pa所指的结点连到pc,pa指针后移
      {
       pan = pa->next;
       pa->next = pc->next;
       pc->next = pa;
       pa = pan;
      }
      else//pb所指的结点链到pc,pb指针后移
      {
       pbn = pb->next;
       pb->next = pc->next;
       pc->next = pb;
       pb = pbn;
      }
     }
     while (pa)
     {
      pan = pa->next;
      pa->next = pc->next;
      pc->next = pa;
      pa = pan;
     }
     while (pb)
     {
      pbn = pb->next;
      pb->next = pc->next;
      pc->next = pb;
      pb = pbn;
     }
     free(pb);
     return pc;
    }
    
    
    void InvertLinkList(LinkList L)
    {//就地逆置单链表L
     LNode*p, *pn;
     p = L->next;
     if (!p || !p->next)
      return ERROR;
     pn = p->next;//pn指向p的直接后继结点
     p->next = NULL;//令首元结点的指针域为空
     while (pn)
     {
      p = pn;
      pn = pn->next;//指针后移
      p->next = L->next;
      L->next = p;//插入结点之后
     }
    }
    
    
    int main()
    {
     int n;
     LinkList L, S, K;
     printf("输入第一个要建立的顺序链表的元素个数:");
     scanf_s("%d", &n);
     printf("输入顺序链表的元素(尾插法创建单链表):");
     L = CreateList_L_Tail(n);
     printf("顺序表中元素是:");
     PrintList(L);
     printf("输入第二个要建立的顺序链表的元素个数:");
     scanf_s("%d", &n);
     printf("输入顺序链表的元素(尾插法创建单链表):");
     S = CreateList_L_Tail(n);
     printf("顺序表中元素是:");
     PrintList(S);
     printf("归并后的线性链表是:");
     K = MergeList(L, S);
     PrintList(K);
     printf("逆置后的线性表是:");
     InvertLinkList(K);
     PrintList(K);
     system("pause");
     return 0;
    }

    在这里插入图片描述

    展开全文
  • 文章目录C语言 两个递增单链表归并为一个递减单链表的实现与思路思路``如果对你有帮助,点个赞呗``实现代码结构体功能函数运行截图``欢迎大家在评论区赐教,谢谢`` C语言 两个递增单链表归并为一个递减单链表的实现与...
  • 算法思想:归并两个有序链表可以采取头插法,或者尾插法,逆序排列,就选择了尾插法,详见代码 void MargeLinkList(LinkList &q,LinkList &p){ if(q->next==NULL&&p->next==NULL) return...
  • #include &lt;iostream&gt; #include &lt;stdlib.h&gt; using namespace std; typedef struct LNode ...LNode * createLinkList() //构造带头结点的链表 ,尾插法,构造的节点要有序 ...
  • 实现两个有序单链表的合并。要求:随机创建两个单链表,实现单链表的排序,再对两个有序单链表进行合并。 ================================= 源代码 #include  using namespace std; template  class...
  • 两个有序链表合并成一个有序链表----两种方法
  • printf("请输入第一个有序单链表:\n"); Init_Linklist(&L0); Create_Linklist(&L0); /*单链表L1的初始化*/ printf("请输入第一个有序单链表:\n"); Init_Linklist(&L1); Create_Linklist(&L1); /*...
  • 两个有序单链表的合并(二路归并)

    千次阅读 2019-01-12 18:54:39
    pa,pb,pc分别作为La,Lb,Lc的工作指针,pa,pb初始化分别指向两个有序链表的第一个元素,pc初始化指向La。从第一个指针开始比较,哪个元素小,就接在Lc后面,如果两个元素相当,就把一个链表接在后面,删除另一个...
  • 有序单链表归并运算。

    千次阅读 2016-05-15 11:31:50
    采用单链表结构编程实现:两个有序单链表归并运算。 #include #define ERROR 0 #define OK 1 #include using namespace std; typedef int ElemType; typedef int Status; typedef struct LNode { ...
  • 【剑指offer】两个有序单链表的合并

    千次阅读 2018-08-22 23:17:49
    给定两个有序单链表,合并为一个有序单链表 思路 由题目可以得出大概题意 而这里算法的思想跟归并排序是一样的,都是对两个待归并的线性表分别设置1个指针,比较这两个当前指针的大小,将小的结点加入到...
  • C递归实现合并两个有序单链表 发现力扣上有简洁的解法 https://leetcode-cn.com/problems/merge-two-sorted-lists/comments/ /** * Definition for singly-linked list. * struct ListNode { * int val; * ...
  • void MergeList(LinkList &A,LinkList &B) { LNode *r,*pa=A->next,*pb=B->next; A->next=NULL; while(pa&&pb) { if(pa->data<=pb->data) { ... else.
  • 现有无头结点有序单链表pHead1和无头结点有序单链表pHead2,要求将两个链表合并后依然有序。 如: pHead1 为 1 3 5 7 9   pHead2 为 2 4 6 8 10  合并后 为1 2 3 4 5 6 7 8 9 问题解决: (1)递归实现 ...
  • 1.让两个指针p.q 先指向两个单链表的首结点。并定义尾指针r,和s 2.建立L3的头结点,并将r指向L3的尾结点 3.通过while循环判断 3.1如果p->data < q->data,则复制p结点得到s结点,然后将s结点链接到 L3的末尾...
  • 其实没有那么难,亏我还想了好几天,花费了我好长的时间,不过只要理解了链表头和指针变量的关系,基本就OK了。...next就是一空的数据域,程序要系统开辟的空间用来存储数据的,首先,p1,p2,head,等...
  • /*链表*/ #include typedef struct node {  int data; ... struct node *next;.../*后插法创建单链表*/ void hou_create(Listlink *head,int n) {  int i;  Listlink p,q;  *head=(Listlin
  • 17.合并两个有序单链表 输入两个递增排序的链表,合并这两个链表并使新链表中的结点仍然是按照递增排序的。 样例 输入:1->3->5 , 2->4->5 输出:1->2->3->4->5->5 思路 遇到将两个...
  • 合并两个有序单链表

    2020-08-23 15:32:04
    rp=1&ru=%2Fta%2Fcoding-interviews&qru=%2Fta%2Fcoding-interviews%2...输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。 二、代码实现 /* public clas..
  • 两个有序单链表,要求合并后依然有序。 时间复杂度O(m+n),m和n分别是两个链表的长度。 public class MergeTwoList { /** * 循环 * @param n1 * @param n2 * @return */ public static Node ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,681
精华内容 2,272
关键字:

两个有序单链表的归并