链表-进阶

• 1000ms
•  32768K

这样我们就已经学完了链表的几个基本的操作了。在这一节里，我们还是设置了一个难题，你需要独立的构造一个链表，并且去实现我们已经学习过的插入、遍历、删除、反转的方法。基本的框架已经写好了，你只要在相应的位置去完善代码就好了。

输入格式

第一行输入为一个正整数 $m$（$1\le m\le 100$），代表一共有 $m$ 个操作。

接下来一共输入 $m$ 行，每行首先输入一个整数 $t$，代表着以下几种操作：

• $t=1$，代表执行插入操作，此时还需输入两个整数 $a$ 和 $b$（$0\le a,b\le 100$），代表在位置 $a$ 上插入值为 $b$ 的元素，成功插入输出success，否则输出failed。
• $t=2$，代表执行遍历操作，此时程序顺序输出链表的所有元素。
• $t=3$，代表执行删除操作，此时还需输入一个整数 $a$（$0\le a\le 100$），表示删除位置 $a$ 上的元素，如果成功删除则输出success，否则输出failed。
• $t=4$，代表执行反转链表的操作，在执行了反转操作之后，还会有其他的操作来验证你的程序是否正确的完成了链表的反转。

输出格式

输出的结果取决于每组输入的数据。在遍历输出链表时，每个元素后面跟一个空格。对于操作 $1$ 和操作 $2$，操作成功输出success，否则输出failed。每次操作的输出各占一行。

样例输入

9
1 0 1
1 0 2
1 0 3
2
4
2
3 3
3 0
2

样例输出

success
success
success
3 2 1 
1 2 3 
failed
success
2 3 

#include <iostream>
#include<iostream>
using namespace std;

template <typename Type> class Node {
public:
    Type data;
    Node<Type> *next;
    Node(const Type &_data) {
        data = _data;
        next = NULL;
    }
};
template <typename Type> class LinkedList {
private:
    Node<Type> *head;
public:
    LinkedList() {
        head = NULL;
    }
    ~LinkedList() {
        Node<Type> *current_node = head;
        while (current_node != NULL) {
            Node<Type> *delete_node = current_node;
            current_node = current_node->next;
            delete delete_node;
        }
    }
    bool insert(Node<Type> *node, int index) {
        if (head == NULL) {
            if (index != 0) {
                return false;
            }
            head = node;
            return true;
        }
        if (index == 0) {
            node->next = head;
            head = node;
            return true;
        }
        Node<Type> *current_node = head;
        int count = 0;
        while (current_node->next != NULL && count < index - 1) {
            current_node = current_node->next;
            count++;
        }
        if (count == index - 1) {
            node->next = current_node->next;
            current_node->next = node;
            return true;
        }
        return false;
    }
    void output() {
        if (head == NULL) {
            return;
        }
        Node<Type> *current_node = head;
        while (current_node != NULL) {
            cout << current_node->data << " ";
            current_node = current_node->next;
        }
        cout << endl;
    }
    int delete_node(int index) {
        if (head == NULL) {
            return 0;
        }
        Node<Type> *current_node = head;
        int count = 0;
        if (index == 0) {
            head = head->next;
            delete current_node;
            return 1;
        }
        while (current_node->next != NULL && count < index -1) {
            current_node = current_node->next;
            count++;
        }
        if (count == index - 1 && current_node->next != NULL) {
            Node<Type> *delete_node = current_node->next;
            current_node->next = delete_node->next;
            delete delete_node;
            return 1;
        }
        return 0;
    }
    void reverse() {
        if(head==NULL) {return;}
        Node<Type>* next_node,*current_node;
        current_node = head->next;
        head->next = NULL;
        while(current_node!=NULL){
            next_node = current_node->next;
            current_node->next = head;
            head = current_node;
            current_node = next_node;
        }
    }
};
int main() {
    LinkedList<int> linkedlist;
    int m,t,a,b;
    cin >> m;
    while(m--){
        cin >> t;
        if(t==1){
            cin >> a >> b;
            Node<int>* node = new Node<int>(b);
            if(linkedlist.insert(node,a))
            cout << "success"; else cout << "failed" ;
            cout << endl;
        }else if(t==2){
            linkedlist.output();
        }else if(t==3){
            cin >> a;
            if(linkedlist.delete_node(a))
            cout << "success"; else cout << "failed" ;
            cout << endl;
        }else if(t==4){
            linkedlist.reverse();
        }
    }
    return 0;
}