PAT A1161 Merging Linked Lists

最新推荐文章于 2024-06-12 20:44:27 发布

疯疯癫癫才自由

最新推荐文章于 2024-06-12 20:44:27 发布

阅读量490

点赞数 1

分类专栏： # PAT甲级题解文章标签： PAT甲级 c++

本文链接：https://blog.csdn.net/qq_51825761/article/details/130938922

版权

PAT甲级题解专栏收录该内容

65 篇文章 0 订阅

订阅专栏

1161 Merging Linked Lists

分数 25

作者陈越

单位浙江大学

Given two singly linked lists L1=a1→a2→⋯→an−1→an and L2=b1→b2→⋯→bm−1→bm. If n≥2m, you are supposed to reverse and merge the shorter one into the longer one to obtain a list like a1→a2→bm→a3→a4→bm−1⋯. For example, given one list being 6→7 and the other one 1→2→3→4→5, you must output 1→2→7→3→4→6→5.

Input Specification:

Each input file contains one test case. For each case, the first line contains the two addresses of the first nodes of L1 and L2, plus a positive N (≤105) which is the total number of nodes given. The address of a node is a 5-digit nonnegative integer, and NULL is represented by -1.

Then N lines follow, each describes a node in the format:

Address Data Next

where Address is the position of the node, Data is a positive integer no more than 105, and Next is the position of the next node. It is guaranteed that no list is empty, and the longer list is at least twice as long as the shorter one.

Output Specification:

For each case, output in order the resulting linked list. Each node occupies a line, and is printed in the same format as in the input.

Sample Input:

00100 01000 7
02233 2 34891
00100 6 00001
34891 3 10086
01000 1 02233
00033 5 -1
10086 4 00033
00001 7 -1

Sample Output:

01000 1 02233
02233 2 00001
00001 7 34891
34891 3 10086
10086 4 00100
00100 6 00033
00033 5 -1

将链表节点用静态数组存储，每个结点用一个结构体来存储，输入所有
* 节点后，将两个链表的结点分别用两个vector来存储；最后输出即可，
* 但是要注意每个结点的next值，因为是两个链表穿插输出，所以每个结点
* 的next值要注意一下；

/**
 * 将链表节点用静态数组存储，每个结点用一个结构体来存储，输入所有
 * 节点后，将两个链表的结点分别用两个vector来存储；最后输出即可，
 * 但是要注意每个结点的next值，因为是两个链表穿插输出，所以每个结点
 * 的next值要注意一下；
*/

#include <iostream>
#include <vector>

using namespace std;

struct Node
{
    int add, dat, nex;
};

const int N = 1e5+10;
struct Node a[N];
vector<Node> vec1, vec2;

int main()
{
    int h1, h2, n;
    cin >> h1 >> h2 >> n;
    for(int i=0; i<n; ++i)
    {
        int add, dat, nex;
        cin >> add >> dat >> nex;
        a[add] = {add, dat, nex};
    }
    
    while(h1 != -1)
    {
        vec1.push_back(a[h1]);
        h1 = a[h1].nex;
    }
    
    while(h2 != -1)
    {
        vec2.push_back(a[h2]);
        h2 = a[h2].nex;
    }
    
    if(vec1.size() < vec2.size())
        swap(vec1, vec2);
    
    for(int i=0, j=vec2.size()-1; i<vec1.size(); ++i)
    {
        auto ele = vec1[i]; 
        if(i != vec1.size()-1 || j == 0) //输出第一个链表的结点
        {
            //只有第二链表还有结点没有输出，才将该结点的next值输出为
            //vec2[j]的add值，
            if((i + 1) % 2 == 0 && j >= 0) 
                printf("%05d %d %05d\n", ele.add, ele.dat, vec2[j].add);
            else
                printf("%05d %d %05d\n", ele.add, ele.dat, ele.nex);
        }
        else
            printf("%05d %d -1\n", ele.add, ele.dat); 
            //表示两个链表的最后一个节点
            
        ele = vec2[j];
        if((i+1) % 2 == 0 && j>= 0) 
        {
            if(i != vec1.size() - 1)
                printf("%05d %d %05d\n", ele.add, ele.dat, vec1[i+1].add);
            else
                printf("%05d %d -1\n", ele.add, ele.dat);
                //表示两个链表的最后一个节点
            --j;
        }
    }
    
    return 0;
}