单链表

用一组地址任意的存储单元存放线性表中的数据元素。 　　

以元素+ 指针= 结点

以“结点的序列”表示线性表称作线性链表（单链表） 　

　单链表是一种顺序存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。 　　

因此，查找第 i 个数据元素的基本操作为：

移动指针，比较 j 和 i 　　单链表 　　1、链接存储方法 　　链接方式存储的线性表简称为链表（Linked List）。

链表的具体存储表示为：① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的） 　　② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)） 　　

注意：链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。 　　

2、链表的结点结构 　　┌──┬──┐ 　　

                                │data│next│ 　　

                                 └──┴──┘ 　　

data域--存放结点值的数据域 　　next域--存放结点的直接后继的地址（位置）的指针域（链域） 　　注意： 　　

①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 　　

②每个结点只有一个链域的链表称为单链表（Single Linked List）。

#ifndef __SINGLE_LIST_H__
 #define __SINGLE_LIST_H__
#endif

#include <assert.h>
/*#include <crtdbg.h>

#ifdef _DEBUG
#define DEBUG_NEW new (_NORMAL_BLOCK, THIS_FILE, __LINE__)
#endif

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
*/
#ifdef _DEBUG
#ifndef ASSERT
#define ASSERT  assert
#endif
#else   // not _DEBUG
#ifndef ASSERT
#define ASSERT
#endif
#endif  // _DEBUG
#define NULL 0

template<typename T>
class Node
{
public:
    Node(void):data(T()),next(NULL){}
    Node(const Node &initdata):data(initdata),next(NULL){}
    Node(const Node &initdata, Node<T> *cnext):data(initdata),next(cnext){}
public:
    T data;
    Node<T> *next;
};

template<typename T>
class Mylist
{
public:
    Mylist();
    Mylist(const T &initdata);
    ~Mylist();

public:
    int     IsEmpty() const;                                //判断list是否为空
    int     GetCount() const;                                //获取list元素个数
    int     InsertBefore(const int pos, const T data);        //pos前插
    int     InsertAfter(const int pos, const T data);        //pos后插
    int     AddHead(const T data);                            //头插
    int     AddTail(const T data);                            //尾插法
    void    RemoveAt(const int pos);                        //删除某元素
    void    RemoveHead();                                    //删除头结点
    void    RemoveTail();                                    //删除尾结点
    void    RemoveAll();                                    //删除所有元素
    T&      GetTail();                                        //获取尾元素引用
    T       GetTail() const;                                //获取尾元素
    T&      GetHead();                                        //获取头结点引用
    T       GetHead() const;                                //获取头结点
    T&      GetAt(const int pos);                            //根据位置获取某元素引用
    T       GetAt(const int pos) const;                        //根据位置获取某元素
    void    SetAt(const int pos, T data);                    //修改特定位置的值
    int     Find(const T data) const;                        //查找元素

protected:
    Node<T> *m_pNodeHead;
    int m_nCount;

};

template<typename T>
inline Mylist<T>::Mylist():m_nCount(0),m_pNodeHead(NULL)
{
}

template<typename T>
inline Mylist<T>::Mylist(const T &initdata):m_nCount(0),m_pNodeHead(NULL)
{
    AddHead(initdata);
}

template<typename T>
inline Mylist<T>::~Mylist()
{
    RemoveAll();
}

template<typename T>
inline int Mylist<T>::IsEmpty() const
{
    return NULL == m_pNodeHead;
}

template<typename T>
inline int Mylist<T>::GetCount() const
{
    return m_nCount;
}

template<typename T>
int Mylist<T>::InsertBefore(const int pos, const T data)
{
    Node<T> *pNewNode;
    Node<T> *pNewNode1;
    Node<T> *pNewNode2;
    int npos;

    pNewNode = new Node<T>;
    if(NULL == pNewNode)
    {
        npos = 0;
        goto Exit0;
    }

    pNewNode->data = data;
    //pNewNode->next = NULL;//is default constructor is NULL

    if (NULL == m_pNodeHead)
    {
        pNewNode->next = m_pNodeHead;
        m_pNodeHead = pNewNode;
        npos = 1;
        goto Exit1;
    }

    ASSERT(1 <= pos && pos <= m_nCount);

    pNewNode1 = m_pNodeHead;
    for (int i = 1; i < pos; i++)
    {
        pNewNode2  = pNewNode1;
        pNewNode1 = pNewNode1->next;
    }
    
    pNewNode->next = pNewNode1;
    pNewNode2->next = pNewNode;

    npos = pos;

Exit1:
    ++m_nCount;
Exit0:
    return npos;
}

//    int     InsertAfter(const int pos, const T data);        //后插法
template<typename T>
int Mylist<T>::InsertAfter(const int pos, const T data)
{
    Node<T> *pNewNode;
    Node<T> *pNewNode1;
    int npos;

    pNewNode = new Node<T>;
    if (NULL == pNewNode)
    {
        npos = 0;
        goto Exit0;
    }

    pNewNode->data = data;

    if(NULL == m_pNodeHead)
    {
        pNewNode->next = m_pNodeHead;
        m_pNodeHead = pNewNode;
        npos = 1;
        goto Exit1;
    }

    ASSERT(1 <= pos && pos <= m_nCount);

    pNewNode1 = m_pNodeHead;
    for (int i = 1; i < pos; i++)
    {
        pNewNode1 = pNewNode1->next;
    }

    pNewNode->next = pNewNode1->next;
    pNewNode1->next = pNewNode;
    npos = pos+1;

Exit1:
    ++m_nCount;
Exit0:
    return npos;
}

//int     AddHead(const T data);                            //头插
template<typename T>
int Mylist<T>::AddHead(const T data)
{
    Node<T> *pNewNode;

    pNewNode = new Node<T>;

    if (NULL == pNewNode)
    {
        return 0;
    }
    pNewNode->data = data;
    pNewNode->next = NULL;

    if (NULL == m_pNodeHead)
    {
        pNewNode->next = m_pNodeHead;
        m_pNodeHead = pNewNode;
        m_nCount++;
        return 1;
    }

    pNewNode->next = m_pNodeHead;
    m_pNodeHead = pNewNode;
    m_nCount++;
    return 1;
}

//   int     AddTail(const T data);                            //尾插法

template<typename T>
inline int Mylist<T>::AddTail(const T data)
{
    return InsertAfter(GetCount(), data);
}

//void    RemoveAt(const int pos);                        //删除某元素
template<typename T>
void Mylist<T>::RemoveAt(const int pos)
{
    ASSERT(1 <= pos && pos <= m_nCount);
    Node<T> *pNewNode;
    Node<T> *pTempNode;

    pNewNode = m_pNodeHead;

    if (1 == pos)
    {
        m_pNodeHead = m_pNodeHead->next;
        goto Exit1;
    }
    for (int i = 1; i < pos; i++)
    {
        pTempNode = pNewNode;
        pNewNode = pNewNode->next;
    }

    pTempNode->next = pNewNode->next;

Exit1:
    delete pNewNode;
    --m_nCount;
}

// void    RemoveHead();                                    //删除头结点

template<typename T>
inline void Mylist<T>::RemoveHead()
{
    ASSERT(0!=m_nCount);
    RemoveAt(1);
}

//void    RemoveTail();                                    //删除尾结点
template<typename T>
inline void Mylist<T>::RemoveTail()
{
    ASSERT(0 != m_nCount);
    RemoveAt(m_nCount);
}

//void    RemoveAll();                                    //删除所有元素
template<typename T>
void Mylist<T>::RemoveAll()
{
    //ASSERT(0 != m_nCount); 
    
    Node<T> *pNewNode;
    Node<T> *pTempNode;

    pNewNode = m_pNodeHead;
/*    while (pNewNode)
    {
        pTempNode = pNewNode;
        pNewNode = pTempNode->next;

        m_nCount--;
        delete pTempNode;
        pTempNode = NULL;
    }
    */
    for (int i = 0; i < m_nCount; i++)
    {
        pTempNode = pNewNode;
        pNewNode = pTempNode->next;

        delete pTempNode;
        pTempNode = NULL;
    }
    m_nCount = 0;
}

//T&      GetTail();                                        //获取尾元素引用
template<typename T>
T& Mylist<T>::GetTail()
{
    ASSERT( 0 != m_nCount);

    Node<T> *pNewNode;

    pNewNode = m_pNodeHead;

    for (int i = 1; i < m_nCount; i++)
    {
        pNewNode = pNewNode->next;
    }

    return pNewNode->data;
}

//T       GetTail() const;                                //获取尾元素
template<typename T>
T Mylist<T>::GetTail() const
{
    ASSERT(0 != m_nCount);

    Node<T> *pNewNode;
    pNewNode = m_pNodeHead;

    for (int i = 1; i < m_nCount; i++)
    {
        pNewNode = pNewNode->next;
    }

    return pNewNode->data;
}

//T&      GetHead();                                        //获取头结点引用
template<typename T>
T& Mylist<T>::GetHead()
{
    ASSERT(0 != m_nCount);

    return m_pNodeHead->data;
}

//T       GetHead() const;                                //获取头结点
template<typename T>
T Mylist<T>::GetHead() const
{
    ASSERT(0 != m_nCount);

    return m_pNodeHead->data;
}

//T&      GetAt(const int pos);                            //根据位置获取某元素引用
template<typename T>
T& Mylist<T>::GetAt(const int pos)
{
    ASSERT(1 <= pos && pos <= m_nCount);

    Node<T> *pNewNode;
    pNewNode = m_pNodeHead;

    for (int i = 1; i < m_nCount; i++)
    {
        pNewNode = pNewNode->next;
    }

    return pNewNode->data;

}

//T       GetAt(const int pos) const;                        //根据位置获取某元素
template<typename T>
T Mylist<T>::GetAt(const int pos) const
{
    ASSERT(1 <= pos && pos <= m_nCount);

    Node<T> *pNewNode;
    pNewNode = m_pNodeHead;

    for (int i = 1; i < m_nCount; i++)
    {
        pNewNode = pNewNode->next;
    }

    return pNewNode->data;

}
//void    SetAt(const int pos, T data);                    //修改特定位置的值
template<typename T>
void Mylist<T>::SetAt(const int pos, T data)
{
    ASSERT(1 <= pos && pos <= m_nCount);

    Node<T> *pNewNode;

    pNewNode = m_pNodeHead;

    for (int i = 1; i < pos; i++)
    {
        pNewNode = pNewNode->next;
    }

    pNewNode->data = data;
}

//int     Find(const T data) const;                        //查找元素

template<typename T>
int Mylist<T>::Find(const T data) const
{
    ASSERT(0 != m_nCount);

    Node<T> *pNewNode;
    int i = 1;

    pNewNode = m_pNodeHead;

/*    while (pNewNode)
    {
        i++;

        if (pNewNode->data == data)
        {
            return i;
        }
        else
        {
            pNewNode = pNewNode->next;
        }
    }
*/
    for (i = 0; i < m_nCount; i++)
    {
        if (pNewNode->data == data)
        {
            return i+1;
        }
        pNewNode = pNewNode->next;
    }
    return -1;
}