链表 | 将两个递增链表合并为一个递减链表

王道P38T13

主代码:

LinkList merge_desc(LinkList &A,LinkList &B){
    LNode* C=new LNode;
    C->next=NULL;
    LNode *Ap=A->next,*Bp=B->next,*t,*r;
    while(Ap!=NULL && Bp!=NULL){
        if(Ap->data < Bp->data){    //选择Ap
            t=Ap;
            Ap=Ap->next;
        }else{
            t=Bp;
            Bp=Bp->next;
        }
        t->next=C->next;
        C->next=t;
    }
    if(Ap!=NULL)
        r=Ap;
    else
        r=Bp;
    while(r!=NULL){
        t=r;
        r=r->next;
        t->next=C->next;
        C->next=t;
    }
    return C;
}

完整代码:

#include <cstdio>
#include <stdlib.h>

using namespace std;

typedef struct LNode{
    int data;
    struct LNode* next=NULL;
    LNode(){    }
    LNode(int x){
        data=x;
    }
}LNode;

typedef LNode* LinkList;

LinkList  build_list(int * arr,int n){
    int i;
    LinkList L=new LNode;
    LinkList pre=L;
    for(i=0;i<n;i++){
        LinkList p=new LNode(arr[i]);
        pre->next=p;
        pre=p;
    }
    return L;
}

void show_list(LinkList& L){
    LinkList p=L->next;
    while(p){
        printf("%d ",p->data);
        p=p->next;
    }
    puts("");
}

LinkList merge_desc(LinkList &A,LinkList &B){
    LNode* C=new LNode;
    C->next=NULL;
    LNode *Ap=A->next,*Bp=B->next,*t,*r;
    while(Ap!=NULL && Bp!=NULL){
        if(Ap->data < Bp->data){    //选择Ap
            t=Ap;
            Ap=Ap->next;
        }else{
            t=Bp;
            Bp=Bp->next;
        }
        t->next=C->next;
        C->next=t;
    }
    if(Ap!=NULL)
        r=Ap;
    else
        r=Bp;
    while(r!=NULL){
        t=r;
        r=r->next;
        t->next=C->next;
        C->next=t;
    }
    return C;
}

int main(){
    int A_arr[5]={1,2,3,5,9};
    int B_arr[5]={0,2,2,6,9};
    LinkList A=build_list(A_arr,5);
    LinkList B=build_list(B_arr,5);
    show_list(A);
    show_list(B);
    LinkList C=merge_desc(A,B);
    show_list(C);
}
 

注意:

(1)这段代码是我在白纸上手写,然后上机验证的。上机验证发现,小于符号 错写为了 大于符号:

    while(Ap!=NULL && Bp!=NULL){
        if(Ap->data < Bp->data){    //选择Ap
            t=Ap;
            Ap=Ap->next;
        }else{
            t=Bp;
            Bp=Bp->next;
        }
        t->next=C->next;
        C->next=t;
    }

最后合并的元素应该单调递减,所以用尾插法应该每次选择最小的元素进行尾插。

(2)我在白纸书写紫色代码时,if和else语句块都写了,验证时发现可以简写到公共语句块末尾。

原文地址:https://www.cnblogs.com/TQCAI/p/8451965.html

时间: 2024-10-06 14:21:58

链表 | 将两个递增链表合并为一个递减链表的相关文章

C语言将两个整数数组合并为一个数组

下面给定两个排序号的整数数组,将他们合并为一个数组并重新排序. #include <stdio.h> #define NMAX 10 void printIntArray(int a[], int n); void merge(int c[], int *nc, int a[], int na, int b[], int nb); int main(void) { int x[NMAX] = {1,3,5,6,7}; // 第一个排序好的数组 int y[NMAX] = {2,3,4}; //

88. Merge Sorted Array【leetcode】算法,java将两个有序数组合并到一个数组中

88. Merge Sorted Array Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array. Note:You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2. The n

将两个有序链表合并为一个新链表

#include <iostream> #include <stdio.h> typedef struct _Node { int value; struct _Node *next; }Node; Node *MergeList(Node *listA, Node *listB); void PrintList(Node *head); int main() { Node lista, nodea, listb, nodeb, nodec; lista.value = 2; no

两个有序数组合并为一个有序数组

突然想到了这个算法,记得以前看过,但是没写,怕自己会写不出这个算法,于是就把它用JAVA写出来,呵呵. 思想:先依次比较两个数组,按照小的就传入新的数组.当这次比较完之后可能有一个数组的长度很长,留下一些数组,然后在新数组的末尾插入即可. 代码: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 class ArraySort{ //两个有序数组

通用静态库的生成,使用lipo将两个.a文件合并成一个

百度地图.支付宝用到过将2个.a文件合并 通用静态库的生成 打开命令行 (终端) 输入: lipo -create 然后依次把两个.a文件拖到终端窗口, 命令行会变成这样: lipo -create /Library/SDKs/CorePlotSDK/iphoneos.sdk/usr/lib/libCorePlot.a /Library/SDKs/CorePlotSDK/iphonesimulator.sdk/usr/lib/libCorePlot.a 然后接着输入 -output 目标文件路径

Python版将两个有序数组合并为一个有序数组

第一种思路,把两个数组合为一个数组然后再排序,问题又回归到冒泡和快排了,没有用到两个数组的有序性.(不好) 第二种思路,循环比较两个有序数组头位元素的大小,并把头元素放到新数组中,从老数组中删掉,直到其中一个数组长度为0.然后再把不为空的老数组中剩下的部分加到新数组的结尾.(好) 第二种思路的排序算法与测试代码如下: def merge_sort(a, b): ret = [] while len(a)>0 and len(b)>0: if a[0] <= b[0]: ret.appen

将两个有序数组合并为一个有序数组

原文地址:https://www.cnblogs.com/cjsblog/p/10015422.html

队列链表实现以及有序表的合并

#include<iostream> #include<algorithm> using namespace std; typedef struct Node{ int data; Node *next; }LNode, *LinkList; void Creat(LinkList &L){ L = new Node; L->next = NULL; cout << "你已经成功创建了一个队列" << endl; } voi

经典算法——合并K个有序链表

一.题目要求: 将K个有序链表合并为一个有序链表 二.实现方法: 方法一:利用最小堆方法 用一个大小为K的最小堆(用优先队列+自定义降序实现)(优先队列就是大顶堆,队头元素最大,自定义为降序后,就变成小顶堆,队头元素最小),先把K个链表的头结点放入堆中,每次取堆顶元素,然后将堆顶元素所在链表的下一个结点加入堆中. 整体测试代码: #include <vector> #include <iostream> #include<queue> #include<set&g