C++实现单向链表的增加、删除、读取功能

链表相比于数组的优势有：
1. 增加和删除元素效率非常高；
2. 可以不需要预先知道存储元素的数量。
相比于数组的劣势有：
1. 查找元素的效率低；
2. 由于存储额外节点指针，带来的空间消耗。

采用C语言形式实现插入和删除两个函数

//插入元素
bool InsertNode(Node* p, int index, int data)
{
     Node* pCur = p;
     int i = 0;
     while(i < index -1)
     {
         if(NULL == pCur) return false;
         pCur = pCur->pNext;
         i++;
     }
     Node* pAdd = new Node;
     pAdd->data = data;
     pAdd->pNext = pCur->pNext;
     pCur->pNext = pAdd;
     return true;
}
//删除元素
bool DeleteNode(Node* p, int index)
{
    Node* pCur = p;
    int i = 0;
    while(i < index - 1)
    {
        if(NULL == pCur) return false;
        pCur = pCur->pNext;
        i++;
    }
    Node* pDel = pCur;
    pCur = pDel->pNext;
    delete pDel;
    return true;
}

采用C++类的方式，实现插入、删除、查找等基本函数

//main.cpp
#include "stdafx.h"
#include <iostream>
#include <assert.h>
using namespace std;

struct MyNode
{
    int data;
    MyNode* pNext;
};

class MyList
{
private:
    MyNode* pHead;
    int count;
public:
    MyList()
    {
        pHead = NULL;
        count = 0;
    }
    ~MyList()
    {
        MyNode* pDel;
        while (pHead)
        {
            pDel = pHead;
            pHead = pHead->pNext;
            delete pDel;
        }
        pHead = NULL;
    }

    /**
    * @brief 在链表的头部添加一个元素
    */
    bool push_front(int data)
    {
        MyNode* pAdd = new MyNode;
        pAdd->data = data;
        pAdd->pNext = pHead;
        pHead = pAdd;
        count++;
        return true;
    }
    /**
    * @brief 在链表的头部删除一个元素
    */
    bool pop_front()
    {
        if (0 == count) return false;
        MyNode* pDel = pHead;
        pHead = pHead->pNext;
        delete pDel;
        count--;
        return true;
    }
    /**
    * @brief 在链表尾部添加一个元素
    * @warning 需要考虑链表为空的情况
    */
    bool push_back(int data)
    {
        MyNode* pCur = pHead;
        int i = 0;
        //遍历到最后一个节点，所以pCur为最后一个节点
        while (i < count - 1)
        {
            pCur = pCur->pNext;
            i++;
        }
        MyNode* pAdd = new MyNode;
        pAdd->data = data;
        pAdd->pNext = NULL;
        if (0 == count)
            pHead = pAdd;
        else
            pCur->pNext = pAdd; 
        count++;
        return true;
    }
    /**
    * @brief 在链表尾部弹出一个元素
    */
    bool pop_back()
    {
        MyNode* pCur = pHead;
        int i = 0;
        //遍历到倒数第二个元素
        while (i < count - 2)
        {
            pCur = pCur->pNext;
            i++;
        }
        MyNode* pDel = pCur->pNext;
        pCur->pNext = NULL;
        delete pDel;
        count--;
        return true;
    }
    /** 
    * @brief 在list表中插入一个元素
    * @param[in] data 将要插入的元素
    * @param[in] index 表示插入到index指定的地方
    */
    bool Insert(int index, int data)
    {
        if (index < 1 || index > count) return false;
        MyNode* pCur = pHead;
        int i = 0;
        while (i < index - 1)
        {
            pCur = pCur->pNext;
            i++;
        }
        MyNode* pAdd = new MyNode;
        pAdd->data = data;
        pAdd->pNext = pCur->pNext;
        pCur->pNext = pAdd;
        count++;
        return true;
    }
    /**
    * @brief 在list表中删除一个元素
    * @param[in] index 表示删除index指定的地方的元素
    */
    bool Delete(int index)
    {
        if (index < 1 || index > count) return false;
        MyNode* pCur = pHead;
        int i = 0;
        while (i < index - 1)
        {
            pCur = pCur->pNext;
            i++;
        }
        MyNode* pDel = pCur->pNext;
        pCur->pNext = pDel->pNext;
        delete pDel;
        count--;
        return true;
    }
    /**
    * @brief 获取指定位置的元素，操作符[]重载
    * @param[in] index 表示获取index指定的地方的元素
    */
    int operator[](int index)
    {
        assert(index >=0 && index < count);
        MyNode* pCur = pHead;
        int i = 0;
        while (i < index)
        {
            pCur = pCur->pNext;
            i++;
        }
        return pCur->data;
    }

    void Traverse()
    {
        MyNode* pCur = pHead;
        while (pCur)
        {
            cout << pCur->data << " ";
            pCur = pCur->pNext;
        }
        cout << endl;
    }
};

//入口函数
int main()
{
    MyList mylist;
    mylist.push_back(2);
    mylist.push_back(4);
    mylist.push_back(6);
    mylist.push_back(8);
    mylist.push_front(0);
    mylist.push_back(10);
    mylist.push_front(-2);
    mylist.Traverse();
    mylist.pop_back();
    mylist.pop_front();
    mylist.Traverse();
    mylist.Insert(4, 100);
    mylist.Traverse();
    mylist.Delete(4);
    mylist.Traverse();
    cout << mylist[4] << endl;
    getchar();
    return 0;
}