判断单链表是否有环（C++）

问题：判断单链表是否有环（C++）
有一个链表，我们需要判断链表中是否存在环。有环则输出true，否则输出false。
输入有多行，每行为由空格分隔的两个整数m和n，m是当前结点的数据，n代表当前结点的指针域指向第n个结点。
n存在四种情形：
①为-1，代表该结点的指针域指向NULL，输入结束；
②指向该结点之前的结点，如第3个结点的指针域指向n = 2的结点；
③指向自己，如第3个结点的指针域指向n = 3的结点；
④指向其直接后继结点，如第3个结点的指针域指向n = 4的结点，不能指向n = 5的结点。

当输入为：
1 2
2 3
3 -1
时，代表：第1个结点的数据为1，指向第2个结点；第2个结点的数据为2，指向第3个结点；第3个结点的数据为3，指向NULL，输入结束。

样例1
输入：
1 2
3 3
4 2
5 -1
输出：
true

#include <memory>
#include <vector>
#include <iostream>


template <typename T>
class slist {
public:
        slist() = default;
        slist(const T &data) : data(new T(data)) { } 
        // ~slist() { std::cout << "destructor" << std::endl;  }
        std::shared_ptr<T> data;
        std::weak_ptr<slist<T>> next;
};

int main(int argc, char *argv[])
{
        std::vector<std::shared_ptr<slist<int>>> lvec;

        int val, i, line, nextone;
        line = 0;
        while (true) {
                ++line;
                std::cin >> val >> nextone;
                if (!std::cin) {
                        break;
                }   
                std::shared_ptr<slist<int>> cur, next;
                if (line > lvec.size()) {
                        cur = std::make_shared<slist<int>>(val);
                        lvec.push_back(cur);
                } else {
                        lvec[line - 1]->data = std::make_shared<int>(val);
                }   
                for (i = lvec.size(); i < nextone; ++i) {
                        lvec.push_back(std::make_shared<slist<int>>());
                }   
                if (nextone == -1) {
                        break;
                }   
                lvec[line - 1]->next = lvec[nextone - 1]; 

        }   

        for (const auto &num : lvec) {
                std::cout << *(num->data) << " ";
        }   
        std::cout << std::endl;

        if (lvec.empty()) {
                return 0;
        }

        std::shared_ptr<slist<int>> node1 = lvec[0], node2;
        if (!node1) {
                std::cout << std::boolalpha << false << std::endl;
                return 0;
        }
        if (node2 = node1->next.lock()) {
                if (node2 == node1) {
                        std::cout << std::boolalpha << true << std::endl;
                        return 0;
                }
        } else {
                std::cout << std::boolalpha << false << std::endl;
                return 0;
        }

        while (true) {
                node1 = node1->next.lock();
                node2 = node2->next.lock();
                if (!node2) {
                        std::cout << std::boolalpha << false << std::endl;
                        break;
                }
                if (node2 == node1) {
                        std::cout << std::boolalpha << true << std::endl;
                        break;
                }
                node2 = node2->next.lock();
                if (!node2) {
                        std::cout << std::boolalpha << false << std::endl;
                        break;
                }
                if (node1 == node2) {
                        std::cout << std::boolalpha << true << std::endl;
                        break;
                }
        }

        return 0;
}

// g++ xx.cpp -std=c++11
// gcc 5.3.1