7-24 链表去重

7-24 链表去重

分数 15

作者 陈越

单位 浙江大学

给定一个带整数键值的链表 L，你需要把其中绝对值重复的键值结点删掉。即对每个键值 K，只有第一个绝对值等于 K 的结点被保留。同时，所有被删除的结点须被保存在另一个链表上。例如给定 L 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15。

输入格式：

输入在第一行给出 L 的第一个结点的地址和一个正整数 N（≤105，为结点总数）。一个结点的地址是非负的 5 位整数，空地址 NULL 用 -1 来表示。

随后 N 行，每行按以下格式描述一个结点：

地址 键值 下一个结点

其中地址是该结点的地址，键值是绝对值不超过104的整数，下一个结点是下个结点的地址。

输出格式：

首先输出去重后的链表，然后输出被删除的链表。每个结点占一行，按输入的格式输出。

输入样例：

00100 5
99999 -7 87654
23854 -15 00000
87654 15 -1
00000 -15 99999
00100 21 23854

输出样例：

00100 21 23854
23854 -15 99999
99999 -7 -1
00000 -15 87654
87654 15 -1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

栈限制

8192 KB

代码

#include <bits/stdc++.h>
using namespace std;

struct node
{
    string nodeAddress;
    int nodeValue;
    string nextAddress;
};

int main()
{
    string addressFirst;
    int N;
    cin >> addressFirst >> N;
    unordered_map<string, node> addressNode;
    // 输入所有的节点
    for (int i = 0; i < N; i++)
    {
        node tempNode;
        cin >> tempNode.nodeAddress >> tempNode.nodeValue >> tempNode.nextAddress;
        addressNode.insert(make_pair(tempNode.nodeAddress, tempNode));
    }
    // 划分出重复的元素
    vector<node> repeatedNode;
    vector<node> noRepeatedNode;
    bool ifRepeat[100001] = {false};
    node tempNode = addressNode[addressFirst];
    for (int i = 0; i < addressNode.size(); i++)
    {
        if (!ifRepeat[abs(tempNode.nodeValue)]) // 如果不重复
        {
            noRepeatedNode.push_back(tempNode);
            ifRepeat[abs(tempNode.nodeValue)] = true;
        }
        else // 重复了
        {
            repeatedNode.push_back(tempNode);
        }
        if (tempNode.nextAddress == "-1")
            break;
        else
            tempNode = addressNode[tempNode.nextAddress];
    }
    // 输出非重复节点
    for (int i = 0; i < noRepeatedNode.size(); i++)
    {
        cout << noRepeatedNode[i].nodeAddress << " " << noRepeatedNode[i].nodeValue << " " << ((i == (noRepeatedNode.size() - 1)) ? "-1" : noRepeatedNode[i + 1].nodeAddress) << "\n";
    }
    // 输出重复节点
    for (int i = 0; i < repeatedNode.size(); i++)
    {
        cout << repeatedNode[i].nodeAddress << " " << repeatedNode[i].nodeValue << " " << ((i == (repeatedNode.size() - 1)) ? "-1" : repeatedNode[i + 1].nodeAddress) << "\n";
    }
    return 0;
}

优化代码

#include <bits/stdc++.h>
using namespace std;

struct Node {
    string address;
    int value;
    string next;
};

int main() {
    string startAddress;
    int N;
    cin >> startAddress >> N;

    unordered_map<string, Node> nodes;
    for (int i = 0; i < N; i++) {
        Node tempNode;
        cin >> tempNode.address >> tempNode.value >> tempNode.next;
        nodes[tempNode.address] = tempNode;
    }

    vector<Node> uniqueNodes, duplicateNodes;
    unordered_set<int> seenValues;
    for (string currAddress = startAddress; currAddress != "-1"; currAddress = nodes[currAddress].next) {
        Node& currNode = nodes[currAddress];
        if (seenValues.insert(abs(currNode.value)).second) {
            uniqueNodes.push_back(currNode);
        } else {
            duplicateNodes.push_back(currNode);
        }
    }

    auto printNodes = [](const vector<Node>& nodes) {
        for (int i = 0; i < nodes.size(); i++) {
            cout << nodes[i].address << " " << nodes[i].value << " " << ((i == nodes.size() - 1) ? "-1" : nodes[i + 1].address) << "\n";
        }
    };

    printNodes(uniqueNodes);
    printNodes(duplicateNodes);

    return 0;
}

• 待看