1, Definition of linked list

Linked list is a kind of dynamic data structure, which is characterized by using a set of arbitrary storage units (can be continuous or discontinuous) to store data elements. Every element in the list is called "node". Each node is composed of data field and pointer field. The pointer field in each node points to the next node. Head is the "head pointer", indicating the beginning of the linked list, which is used to point to the first node, while the pointer field of the last pointer is null (null address), indicating the end of the linked list. It can be seen that the linked list structure can only be realized by using pointers, that is, a node must contain a pointer variable to store the address of the next node. In fact, each node in the linked list can use several data and several pointers. A linked list with only one pointer in a node is called a single linked list, which is the simplest linked list structure.

2, Advantages and disadvantages of chain storage

advantage:

• Insert, delete do not need to move other elements, just change the pointer
• The space of each node in the linked list is not required to be continuous in memory, and the space utilization rate is high

Disadvantages:

• Search needs traversal operation, which is troublesome

3, Code implementation

#include<iostream>
using namespace std;


class Node {
public:
    Node() {
        data = 0;
        next = NULL;
    }
    Node(int el, Node *ptr = NULL) {
        data = el;
        next = ptr;
    }
    void printNode()
    {
        cout<<data<<"->";
    }
    int data;
    Node *next;
};

class LinkList
{
public:
    LinkList();//Constructor
    ~LinkList();//Destructor
    void ClearLinkList();//Empty list
    bool LinkListEmpty();//Empty list
    int LinkListLength();//Chain length
    bool GetElem(int i, Node *pNode);//Gets the element of the specified index
    int LocateElem(Node *pNode);//Gets the index of the specified element
    bool PriorElem(Node *pCurrentNode, Node *pPreNode);//Get precursor node
    bool NextElem(Node *pCurrentNode, Node *pNextNode);//Get successor node
    void LinkListTraverse();//ergodic
    bool LinkListInsert(int i,Node *pNode);//Insert element
    bool LinkListDelete(int i, Node *pNode);//Delete element
    bool LinkListInsertHead(Node *pNode);//Insert after head node
    bool LinkListInsertTail(Node *pNode);//Insert at the end of the list
private:
    Node * m_pLinkList;
    int m_iLength;
};

//Constructor
//In the heap, memory is requested for the header node m ﹣ plinklist
//M ﹣ plinklist data field set to 0
//In fact, a header node is declared here. The header node has no successor node and the data field is empty
//Length set to 0
LinkList::LinkList()
{
    m_pLinkList = new Node;
    m_iLength = 0;
}

//Destructor
//Call to clear the linked list method
//Delete head node and empty
LinkList::~LinkList()
{
    ClearLinkList();
    delete m_pLinkList;
    m_pLinkList = NULL;
}

//Empty list
void LinkList::ClearLinkList()
{
    Node *currentNode = m_pLinkList->next;
    while (currentNode != NULL)
    {
        Node *temp = currentNode->next;
        delete currentNode;
        currentNode = temp;
    }
    m_pLinkList->next = NULL;
}

//Empty list
bool LinkList::LinkListEmpty()
{
    return 0 == m_iLength ? true : false;
}

//Get length
int LinkList::LinkListLength()
{
    return m_iLength;
}

//Insert element after head node
bool LinkList::LinkListInsertHead(Node *pNode)
{
    Node *temp = m_pLinkList->next;
    Node *newNode = new Node;
    if (newNode == NULL) //Determine whether the requested node memory is empty
    {
        return false;
    }
    else
    {
        newNode->data = pNode->data;
        m_pLinkList->next = newNode;
        newNode->next = temp;
        m_iLength++;
        return true;
    }
}

//Insert element after end node
bool LinkList::LinkListInsertTail(Node *pNode)
{
    Node *currentNode = m_pLinkList;
    while (currentNode->next != NULL)
    {
        currentNode = currentNode->next;
    }
    Node *newNode = new Node;
    if (newNode == NULL)
    {
        return false;
    }
    else
    {
        newNode->data = pNode->data;
        newNode->next = NULL;
        currentNode->next = newNode;
        m_iLength++;
        return true;
    }
}

//Insert element at specified location
bool LinkList::LinkListInsert(int i, Node *pNode)
{
    if (i<0 || i>m_iLength)
    {
        return false;
    }
    Node *currentNode = m_pLinkList;
    for (int k = 0; k < i; k++)
    {
        currentNode = currentNode->next;
    }
    Node *newNode = new Node;
    if (newNode == NULL) //Determine whether the requested node memory is empty
    {
        return false;
    }
    else
    {
        newNode->data = pNode->data;
        newNode->next = currentNode->next;
        currentNode->next = newNode;
        return true;
    }
}

//Delete element
bool LinkList::LinkListDelete(int i, Node *pNode)
{
    if (i<0 || i>=m_iLength)
    {
        return false;
    }
    Node *currentNode = m_pLinkList;
    Node *currentNodeBefore = NULL;
    for (int k = 0; k <= i; k++)
    {
        currentNodeBefore = currentNode;
        currentNode = currentNode->next;
    }
    currentNodeBefore->next = currentNode->next;
    pNode->data = currentNode->data;
    delete currentNode;
    m_iLength--;
    return true;
}

//Gets the element of the specified index
bool LinkList::GetElem(int i, Node *pNode)
{
    if (i<0 || i >= m_iLength)
    {
        return false;
    }
    Node *currentNode = m_pLinkList;
    for (int k = 0; k <= i; k++)
    {
        currentNode = currentNode->next;
    }
    pNode->data = currentNode->data;
    return true;
}

//Gets the index of the specified element
int LinkList::LocateElem(Node *pNode)
{
    Node *currentNode = m_pLinkList;
    int count = 0;
    while (currentNode->next != NULL)
    {
        currentNode = currentNode->next;
        if (currentNode->data == pNode->data)
        {
            return count;
        }
        count++;
    }
    return -1;
}

//Get precursor node
bool LinkList::PriorElem(Node *pCurrentNode, Node *pPreNode)
{
    Node *currentNode = m_pLinkList;
    Node *tempNode = NULL;
    int count = 0;
    while (currentNode->next != NULL)
    {
        tempNode = currentNode;
        currentNode = currentNode->next;
        if (currentNode->data == pCurrentNode->data)
        {
            if (tempNode == m_pLinkList)
            {
                return false;
            }
            pPreNode->data = tempNode->data;
            return true;
        }
    }
    return false;
}

//Get successor node
bool LinkList::NextElem(Node *pCurrentNode, Node *pNextNode)
{
    Node *currentNode = m_pLinkList;
    while (currentNode->next != NULL)
    {
        currentNode = currentNode->next;
        if (currentNode->data == pCurrentNode->data)
        {
            if (currentNode->next == NULL)
            {
                return false;
            }
            pNextNode->data = currentNode->next->data;
            return true;
        }
    }
    return false;
}

//ergodic
void LinkList::LinkListTraverse()
{
    Node *currentNode = m_pLinkList;
    while (currentNode->next != NULL)
    {
        currentNode = currentNode->next;
        currentNode->printNode();
    }
}

int main() {

    //Create a linked list
    LinkList l_list;
    for(int i = 1; i<10; i++)
    {
        Node node(i);
        l_list.LinkListInsertTail(&node);
    }

    //Get link length
    cout<<"LinkListLength:"<<l_list.LinkListLength()<<endl;

    //Insert node
    Node node(22);
    l_list.LinkListInsertHead(&node);
    Node node_2(33);
    l_list.LinkListInsertTail(&node_2);
    Node node_3(44);
    l_list.LinkListInsert(2,&node_3);

    //Delete node
    Node *node_4;
    l_list.LinkListDelete(1, node_4);
    cout<<"LinkListDelete:"<<node_4->data<<endl;

    //Get the specified location element
    Node node_5;
    l_list.GetElem(1, &node_5);
    cout<<"GetElem:"<<node_5.data<<endl;

    //Gets the index of the specified element
    Node node_6(2);
    int index = l_list.LocateElem(&node_6);
    cout<<"index:"<<index<<endl;

    //Get precursor node
    Node node_7;
    Node node_8(44);
    l_list.PriorElem(&node_8, &node_7);
    cout<<"PriorElem:"<<node_7.data<<endl;

    //Get successor node
    l_list.NextElem(&node_8, &node_7);
    cout<<"PriorElem:"<<node_7.data<<endl;

    //ergodic
    l_list.LinkListTraverse();
    return 0;
}