链表系列二：链表的C++表示

这里以单链表为例阐述如何用C++实现表的基本表示：

1）表的结构

单链表的每一个结点都是由一个任意数据类型的元素和一个指向下一个元素的指针构成的，如下：

 

通过开始结点A0可以访问整个表元素，最后的一个结点的指针为NULL。

2）引入表头结点

在实现中，为了实现对各个结点的处理的一致性，引入了一个头结点，头结点是指向链表开始结点A0的结点，这样一来链表的所有结点都有了前驱结点，开始结点（链表实际结点的第一个结点）的插入和删除也就不会特别处理，对空表或非空表的处理也是一致的。引入头结点后的结构如下：

其中头结点的数据域可以不保存任何数据信息或者保存如链表长度这样的数据，头结点的指针指向链表的开始结点。

3）链表的C++表示

根据上面的结构将链表抽象为两个类：ListNode，myList。ListNode封装了一个结点的信息，包含一个任意数据类型的数据和一个指向下一个元素的指针；myList封装了一个链表的数据和行为，myList通过头结点表示的，给出了一个头结点就相当于给了一个链表，这里采用模板类以使链表可以适应各种各样的数据类型，在VS2010中具体的C++代码如下：

/* ListNode.h*/
#ifndef LISTNODE_H
#define LISTNODE_H

template <typename T> class myList;

template <typename T>
class ListNode
{
friend class myList<T>;
public:
    ListNode()
    {
        data = 0;
        next = NULL;
    }
    ListNode(T val)
    {
        data = val;
        next = NULL;
    }
private:
    T data;
    ListNode *next;
};

#endif

/* myList.h */
#ifndef MYLIST_H
#define MYLIST_H

#include "ListNode.h"

template <class T>
class myList
{
public:
    myList();
    ListNode<T>* Find(T val);
    ListNode<T>* FindPrev(T val);
    ListNode<T>* Last();
    void Insert(ListNode<T>* x, T data);
    void Delete(T data);
    void Attach(T data);
    void Print();

private:
    ListNode<T> *head;
};

#endif

/* myList.cpp */
#include "myList.h"
#include<iostream>
using namespace std;

template<class T>
myList<T>::myList()
{ 
    head = new ListNode<T>;
}

template<class T>
ListNode<T>* myList<T>::Find(T val)
{
    ListNode<T>* cur = head->next;
    while(cur != NULL)
    {
        if(cur->data == val)
            return cur;
        cur = cur->next;
    }
    return NULL;
}

template<class T>
ListNode<T>* myList<T>::FindPrev(T val)
{
    ListNode<T>* cur = head->next;
    ListNode<T>* prev = head->next;
    while(cur != NULL)
    {
        if(cur->data == val)
            return prev;
        prev = cur;
        cur = cur->next;        
    }
    return NULL;
}

template<class T>
ListNode<T>* myList<T>:: Last()
{
    ListNode<T>* cur = head;
    while(cur->next != NULL)
    {
        cur = cur->next;        
    }
    return cur;
}

template<class T>
void myList<T>::Insert(ListNode<T>* x, T data)
{
    if(x != NULL)
    {
        ListNode<T>* node = new ListNode<T>(data);
        node->next = x->next;
        x->next = node;
    }
}

template<class T>
void myList<T>::Attach(T data)
{
    ListNode<T>* last = Last();
    Insert(last, data);
}

template<class T>
void myList<T>::Delete(T data)
{
    ListNode<T>* node = Find(data);
    ListNode<T>* prev = FindPrev(data);
    if(node != NULL && prev != NULL)
    {
        prev->next = node->next;
        delete node;
    }
}

template<class T>
void myList<T>::Print()
{
    ListNode<T>* cur = head->next;
    while(cur != NULL)
    {
        cout<<cur->data<<endl;
        cur = cur->next;
    }
    cout<<endl;
}

/*主程序*/
#include "stdafx.h"
#include "listNode.h"
#include "myList.h"
#include "myList.cpp"
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
    myList<int> l;
    l.Attach(1);
    l.Attach(2);
    l.Attach(3);
    l.Attach(4);
    l.Attach(5);
    l.Print();

    ListNode<int>* node = l.Find(2);
    l.Insert(node, 10);    
    l.Print();

    l.Delete(10);
    l.Print();

    system("pause");
    return 0;
}

当然myList类中对链表的操作可以包含很多，通常为了使类保持紧凑性，同时为了适应不同的需求和方便用户添加新的成员函数，可以将对链表的遍历相关的操作另外封装为一个类，这里就不再细讲了，如果有兴趣可以参见东南大学金远平教授编著的《数据结构(C++描述)》第三章（P71）。

在随后的链表章节中，为了使算法的表述更加直观，就将ListNode和myList类中的成员变量设为public权限。