有序单链表拼接

#pragma once

#include <iostream>
using namespace std;

/**
 *	结点类
 */
template <typename T> class ListNode
{
private:
    T data;
    ListNode *next;

public:
    ListNode():next(NULL){}

    ListNode(T value):data(value), next(NULL){}

    void SetNext(ListNode<T>* nextnode)
    {
        next = nextnode;
    }

    ListNode<T> * GetNext() const
    {
        return next;
    }

    T& GetData()
    {
        return data;
    }
};

/**
 *	单链表,拥有一个表头节点
 */
template <typename T> class List
{
public:
    List();
    ~List();
   

    /**
     *	表尾插入
     */
    bool AddTail(T data);

    bool RemoveTail();

    /**
     *	在索引值指向的结点前插入结点
     */
    bool InsertAt(int index, T data);

    bool RemoveAt(int index);

    int GetCount();

    bool IsEmpty();

    T& GetAt(int index);

    ListNode<T> * GetHead();
    ListNode<T> * GetTail();
    ListNode<T> * GetNodeAt(int index);

    ListNode<T> * GetCur();

    /**
     *	使cur向后移动一个结点，返回移动后的cur
     */
    ListNode<T> * GetTowardCur();

    void SetTail(ListNode<T> *pnode);

    void RemoveAll();


   
private:
    ListNode<T> *head;
    ListNode<T> *tail;
};


//

/**
 *	创建表头结点，同时使head和tail指向该结点
 */
template <typename T> List<T>::List()
{
    head =  tail = new ListNode<T>;
}

template <typename T> List<T>::~List()
{
    RemoveAll();

    // 释放头结点
    if(head)
    {
        delete head;
        head = tail = NULL;
    }
}

template <typename T> bool List<T>::AddTail(T data)
{
    ListNode<T> *pnode = new ListNode<T>(data);

    tail->SetNext(pnode);
    tail = pnode;

    if(tail == NULL)
    {
        return false;
    }
    else
    {
        return true;
    }
}

template <typename T> bool List<T>::RemoveTail()
{
    return RemoveAt(GetCount()-1);
}
template <typename T> int List<T>::GetCount()
{
    int count = 0;
    ListNode<T> *pNode = head;

    while(pNode->GetNext() != NULL)
    {
        ++count;
        pNode = pNode->GetNext(); // 移动到下一个结点
    }

    return count;
}
template <typename T> bool List<T>::InsertAt(int index, T data)
{
    if( (index<0) || (index>GetCount()-1) ) // 注意减一
    {
        return false;
    }

    // 查找结点
    ListNode<T> *pCur = head;

    while(index) // 注意
    {
        --index;
        pCur = pCur->GetNext(); // 指向下一个结点
    }

    ListNode<T> *pNode = new ListNode<T>(data);

    pNode->SetNext(pCur->GetNext());
    pCur->SetNext(pNode);

    if(pCur->GetNext() != NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}


template <typename T> bool List<T>::RemoveAt(int index)
{
    if( (index < 0) || (index > GetCount()-1))
    {
        return false;
    }

    ListNode<T> *pPrev = head;   // 指向删除的前一个结点
    ListNode<T> *pCur = pPrev->GetNext(); // 指向删除的结点

    while(index)
    {
        pPrev = pPrev->GetNext();
        pCur = pCur->GetNext();

        --index;
    }

    if(pCur == tail) // 如果要删除的是尾结点
    {
        tail = pPrev;
    }

    pPrev->SetNext(pCur->GetNext()); // 删除结点

    if(pPrev != NULL)
    {
        return true;
    }
    else
    {
        return false;
    }

}

template <typename T> bool List<T>::IsEmpty()
{
    return head->GetNext() == NULL;
}

template <typename T> T& List<T>::GetAt(int index)
{
  /*  if( (index < 0) || (index > GetCount() - 1))
        return false;*/

    ListNode<T> *pCur = head->GetNext();

    while(index)
    {
        pCur = pCur->GetNext();
        --index;
    }

    return pCur->GetData();
}

template <typename T> ListNode<T> * List<T>::GetHead()
{
    return head;
}

template <typename T> ListNode<T> * List<T>::GetTail()
{
    return tail;
}

template <typename T> ListNode<T> * List<T>::GetNodeAt(int index)
{
    if( (index < 0) || (index > GetCount() - 1))
    {
        return false;
    }

    ListNode<T> *pCur = head;

    while(index)
    {
        pCur = pCur->GetNext();
        --index;
    }

    return pCur;
}



template <typename T> void List<T>::SetTail(ListNode<T> *pnode)
{
    tail = pnode;
}


template <typename T> void List<T>::RemoveAll()
{
    ListNode<T> *pnode = head;

    while(head->GetNext() != NULL)
    {
        pnode = head->GetNext();
        head->SetNext(pnode->GetNext());

        delete pnode;
    }

    tail = head; // 注意
}