9月11日算法学习（链表）

1.模板链表

描述：
请你实现一个链表。

操作：
insert x y：将yy加入链表，插入在第一个值为xx的结点之前。若链表中不存在值为xx的结点，则插入在链表末尾。保证xx,yy为int型整数。
delete x：删除链表中第一个值为xx的结点。若不存在值为xx的结点，则不删除。

输入描述：
第一行输入一个整数nn (1≤n≤1041≤n≤104)，表示操作次数。
接下来的nn行，每行一个字符串，表示一个操作。保证操作是题目描述中的一种。
输出描述：
输出一行，将链表中所有结点的值按顺序输出。若链表为空，输出"NULL"(不含引号)。

这题还是使用结构体完成，将几个相关操作进行封装，说起来简单，实际上要完成各个操作的实现，是十分繁琐复杂的。

#include <iostream>
#include <string>
using namespace std;
 
typedef struct LNode {
    int value;
    struct LNode* next;
}* LinkList;
 
void insertValue(LinkList& L, int x, int y) {
    if (L != NULL) {
        LNode* p = L;
        if (p->value == x) {
            LNode* new_node = new LNode;
            new_node->value = y;
            new_node->next = p;
            L = new_node;
            return;
        }
        LNode* pre = p;
        p = p->next;
        while (p) {
            if (p->value == x) {
                LNode* new_node = new LNode;
                new_node->value = y;
                new_node->next = p;
                pre->next = new_node;
                return;
            }
            pre = p;
            p = p->next;
        }
        LNode* new_node = new LNode;
        new_node->value = y;
        new_node->next = p;
        pre->next = new_node;
    } else {
        LNode* new_node = new LNode;
        new_node->value = y;
        new_node->next = NULL;
        L = new_node;
    }
}
 
void deleteValue(LinkList& L, int x) {
    if (L != NULL) {
        LNode* p = L;
        if (p->value == x) {
            L = p->next;
            delete p;
            return;
        }
        LNode* pre = p;
        p = p->next;
        while (p) {
            if (p->value == x) {
                pre->next = p->next;
                delete p;
                return;
            }
            pre = p;
            p = p->next;
        }
    } else {
        return;
    }
}
 
int getLinkListLength(LinkList L) {
    int nums = 0;
    LNode* p = L;
    while (p != NULL) {
        ++nums;
        p = p->next;
    }
    return nums;
}
 
void PrintLinkList(LinkList L) {
    if (L == NULL) {
        cout << "NULL" << endl;
    } else {
        LNode* p = L;
        for (int i = 0; i < getLinkListLength(L); i++) {
            if (i == getLinkListLength(L) - 1) {
                cout << p->value << endl;
            } else {
                cout << p->value << " ";
            }
            p = p->next;
        }
    }
}
 
int main() {
 
    LinkList L = NULL;
    int n, a, b;
 
    cin >> n;
    string str;
 
    while (n) { 
        cin >> str;
        if (str == "insert") {
            cin >> a >> b;
            insertValue(L, a, b);
        } else if (str == "delete") {
            cin >> a;
            deleteValue(L, a);
        }
        --n;
    }
    PrintLinkList(L);
 
}

2.反转链表

描述：
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤10000≤n≤1000
要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。

如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

事实上，这道题是一道十分简单的题目，只要进行节点的交换即可，进行一个小小的循环，设置一个缓存的节点，将节点进行首尾互换。

#include <cstddef>
class Solution {
public:
    ListNode* ReverseList(ListNode* head) {
        ListNode* newHead = nullptr;
        while(head){
            ListNode* temp = head -> next;
            head->next = newHead;
            newHead = head;
            head = temp;
        }
        return newHead;
    }
};

谢谢阅读！