数据结构---链表

#include <iostream>
using namespace std;

class Node
{
public:
    int data;    //用来保存数据
    Node *next;    //指向下一个结点
    //构造函数
    Node(int _data)
    {
        data = _data;
        next = NULL;
    }
};


class LinkList
{
private:
    Node *head;    //表头
public:
    //构造函数
    LinkList()
    {
        head = NULL;        
    }

    //插入元素
    void insert(Node *node,int index)
    {
        //如果head为空指针
        if(head == NULL)
        {
            head = node;
            return;
        }

        //如果插入结点后的位置是链表首位
        if(index == 0)
        {
            node->next = head;    //node指针指向当前表头head
            head = node;
            return;
        }

        Node *current_node = head;    //用来在链表里遍历，初始指头指针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;    //新结点node的指针指向目标位置的后一个位置
            current_node->next = node;//目标位置的前一个结点指向新结点
        }
    }


    //遍历链表输出
    void output()
    {
        if(head == NULL)
        {
            return;
        }

        Node *current_node = head;    //用来遍历链表
        while(current_node != NULL)
        {
            cout << current_node->data << " ";
            current_node = current_node->next;
        }
        cout << endl;

    }
    //删除结点
    void delete_node(int index)
    {
        if(head == NULL)
        {
            return;
        }

        Node *current_node = head;
        int count = 0;

        if(index == 0)
        {
            head = head->next;
            delete current_node;
            return;
        }

        //寻找目标位置的前一个位置
        while( current_node->next != NULL && count < index-1)
        {
            current_node = current_node->next;
            count++;
        }

        if(count == index-1 && current_node->next != NULL)
        {
            Node *delete_node = current_node->next;
            current_node->next = delete_node->next;
            delete delete_node;
        }

    }

    //反转链表
    void reverse()
    {
        if(head == NULL)
        {
            return;
        }

        Node *next_node;//遍历过程中的下一个结点
        Node *current_node;//当前结点

        current_node = head->next;//current_node指向头节点的后一个节点
        head->next = NULL;//头结点的下一个结点指向一个空地址

        while(current_node != NULL)
        {。
            next_node = current_node->next;    //next_node 记录current_node的下一个结点
            current_node->next = head;//current_node 的next指针指向头结点

            head = current_node;    //更新头结点 
            current_node = next_node;    //更新current_node成为下一个结点
        }

    }

};

int main()
{
    LinkList linklist;
    for(int i = 1; i <= 10; ++i)
    {
        Node *node = new Node(i);
        linklist.insert(node,i-1);        
    }
    linklist.output();
    linklist.delete_node(3);
    linklist.output();
    linklist.reverse();
    linklist.output();
    return 0;
}

if(head == NULL)
{
    head = node;
    return;
}

if(index == 0)
{
    node->next = head;
    head = node;
    return;
}       

Node *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;    //新结点node的指针指向目标位置的后一个位置
    current_node->next = node;//目标位置的前一个结点指向新结点    
}

int main()
{
    LinkList linklist;
    for(int i = 1; i <= 10; ++i)
    {
    　　Node *node = new Node(i);
    　　linklist.insert(node,i-1);        
    }   
    return 0;
}