构建一个 “链表”

链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，每个元素包含两个结点，一个是存储元素的数据域 (内存空间)，另一个是指向下一个结点地址的指针域非连续的 指针地址

#include
using namespace std;

// 声明一个链表节点的数据类型
typedef struct ListNode {
    int data;// 当前链表节点保存的数据
    struct ListNode * nextListNode;// 指向下一个链表节点
}ListNode;

class List
{
public:
    List();
    ~List();

    void PrintAllNode();// 打印所有链表节点
    void PrintHeadAndTrail();// 打印头节点和尾节点
    void InsertNodeData(int data); // 插入一个节点数据（这里会自动创建一个节点并将数据保存到新创建的节点，默认是加到当前最后一个节点的下一个节点）
    void RemoveNode(int index);// 移除指定下标的节点
private:
    int maxListLength; // 链表的最大长度数值

    ListNode * headNode;// 头节点
    ListNode * trailNode;// 尾节点
    ListNode * generalNode;// 通用节点
};

List::List(){
    this->maxListLength = 0;
    this->headNode = nullptr;
    this->trailNode = nullptr;
    this->generalNode = nullptr;
}

List::~List(){
    // free(this->generalNode);
    delete this->generalNode;
}

void List::PrintAllNode(){
    printf("%sn", "打印:");

    if ( this->headNode == 0 ) {
        printf("%sn", "======这是一个空链表======");
    }else {
        ListNode * listNode = nullptr;
        listNode = this->headNode;
        while ( listNode != 0 ) {
            cout << listNode->data << " ";
            listNode = listNode->nextListNode;
        }
        cout << endl;
    }
}

void List::PrintHeadAndTrail(){
    printf("%sn", "打印头和尾：");

    if ( this->headNode == 0 || this->trailNode == 0 ) {

    }else {
        cout << "head:" << this->headNode->data << " " << "trail:" << this->trailNode->data << endl;
    }
}

void List::InsertNodeData(int data){
    printf("%s：%dn", "插入",data);

    // this->generalNode = (ListNode*)malloc(sizeof(ListNode));
    this->generalNode = new ListNode;
    this->generalNode->data = data;
    this->generalNode->nextListNode = nullptr;
    if ( this->headNode == 0 ) {
        this->headNode = this->generalNode;
        this->trailNode = this->generalNode;
    }else {
        this->trailNode->nextListNode = this->generalNode;
        this->trailNode = this->generalNode;
        
        this->maxListLength = this->maxListLength + 1;
    }
}

void List::RemoveNode(int index){
    printf("%s：%dn", "移除元素下标",index);

    if ( this->headNode == 0 ) {
        printf("%sn", "======这是一个空链表======");
    }else if (index > this->maxListLength) {
        printf("%s:%dn", "选定下标超出链表的最大长度，链表的最大长度下标",this->maxListLength);
    }else {
        ListNode * listNode = nullptr;
        ListNode * listNodeFront = nullptr;
        ListNode * listNodeBack = nullptr;
        listNode = this->headNode;

        int count = 0;
        while ( listNode != 0 ) {
            if ( index > 0 ) {
               if ( count == index-1 ) {
                    listNodeFront = listNode;
                } 
            }

            if ( count == index ) {
                listNodeBack = listNode->nextListNode;
                break;
            }

            listNode = listNode->nextListNode; 
            count = count + 1;
        }

        if ( index == 0 ) {
            this->headNode->nextListNode = nullptr;
            this->headNode = listNodeBack;
        }else if ( index == this->maxListLength) {
            this->trailNode = listNodeFront;
            this->trailNode->nextListNode = nullptr;
        } else {
            listNode = listNodeFront->nextListNode;
            listNode->nextListNode = nullptr;
            listNodeFront->nextListNode = listNodeBack;
        }
    }
}

int main(int argc, char const *argv[])
{
    List list;
    list.InsertNodeData(7);
    list.InsertNodeData(8);
    list.InsertNodeData(9);
    list.InsertNodeData(10);
    list.InsertNodeData(11);
    list.InsertNodeData(12);
    list.PrintAllNode();
    list.PrintHeadAndTrail();
    list.RemoveNode(3);
    list.PrintAllNode();
    list.PrintHeadAndTrail();

    return 0;
}