复习数据结构和算法03-List

#ifndef _ROC_LIST_H_
#define _ROC_LIST_H_

#include <iostream>


//注意: 用户类型需要重载"="运算符
template<typename ValType>
class List{
public:
    //定义结点类型
    template<typename ValType2>
    struct Node{a
        ValType2 value;
        Node<ValType2> *next;
    };
private:
    typedef List<ValType> MyList;        //链表类型名
    typedef Node<ValType> ListNode;        //结点类型名
    ListNode *m_HeadNode;                //头结点
    int m_nNodeCount;                    //结点计数
private:
    //功能: 获取第pos个结点.
    //参数:
    //    pos: 获取结点的序号.
    //返回值: 返回第pos个结点的指针.
    //
    //注意:
    //    pos=0时返回头结点,若pos>m_nNodeCount 则返回最后一个结点.
    ListNode* GetNode(int pos)
    {
        ListNode *pCurNode = m_HeadNode;
        while(pCurNode->next && pos)
        {
            pos--;
            pCurNode = pCurNode->next;
        }
        return pCurNode;
    }
public:
    //功能: 构造函数,创建一个空链表.
    List():m_nNodeCount(0)
    {
        m_HeadNode = new ListNode;
        if(NULL == m_HeadNode)
            return;
        m_HeadNode->next = NULL;
    }

    //功能: 复制构造函数, 以其他链表为模板创建新链表.
    //参数:
    //    alist: 模板链表.
    List(MyList &alist):m_nNodeCount(0)
    {
        m_HeadNode = new ListNode;
        if(NULL == m_HeadNode)
            return;
        m_HeadNode->next = NULL;

        Insert(0, alist, true);
    }

    //功能: 析构函数,销毁申请的资源.
    ~List()
    {
        //删除数据结点
        Destroy();
        //删除头结点
        if(m_HeadNode)
        {
            delete m_HeadNode;
            m_HeadNode = NULL;
        }
    }

    //功能: 删除出头结点外的所有结点.
    void Destroy()
    {
        ListNode *pCurNode = m_HeadNode->next;   
        ListNode *pNode = NULL;
        //从头向尾逐个删除结点
        while(pCurNode)
        {
            pNode = pCurNode->next;
            delete pCurNode;
            pCurNode = pNode;
        }
        m_HeadNode->next = NULL;
        m_nNodeCount = 0;
    }

    //功能: 获取链表结点数(除去头结点).
    //返回值: 返回结点数.
    int GetCount()
    {
        return m_nNodeCount;
    }

    //功能: 判断当前链表是否为空
    //返回值: 若链表为空则返回true, 否则返回false
    bool IsEmpty()
    {
        return m_nNodeCount == 0;
    }

    //功能: 在第pos个结点之后插入值为val的新结点.
    //参数:
    //    pos: 插入位置.
    //    val: 新结点的值.
    //返回值: 若插入成功则返回true, 否则返回false.
    bool Insert(int pos, const ValType &val)
    {
        if(pos<0)
            return false;

        ListNode *pCurNode = GetNode(pos);
        ListNode *pNewNode = new ListNode;
        if(NULL == pNewNode)
            return false;
        pNewNode->value = val;
        pNewNode->next = pCurNode->next;
        pCurNode->next = pNewNode;
        m_nNodeCount++;
        return true;
    }

    //功能: 在第pos个结点之后插入一链表alist.
    //参数:
    //    pos: 插入结点的位置.
    //    alist: 插入的链表.
    //    bCreateNewNode: 是否申请空间创建新结点, 若为true则创建新结点, 源链表alist不变,
    //                    若为false则将源链表alist的结点断开插入当前链表.
    //返回值:若插入成功则返回true, 否则返回false.
    bool Insert(int pos, MyList &alist, bool bCreateNewNode = true)
    {
        if(pos<0)
            return false;
        ListNode *pAListCurNode = alist.m_HeadNode;

        if(bCreateNewNode)
        {
            //在第pos个结点之后插入新结点
            pAListCurNode = pAListCurNode->next;
            ListNode *pCurNode = GetNode(pos);
            ListNode *pNewNode = NULL;

            //遍历alist,以alist的结点值创建新结点
            while(pAListCurNode)
            {   
                pNewNode = new ListNode;
                if(NULL==pNewNode)
                    return false;
                pNewNode->next = pCurNode->next;
                pNewNode->value = pAListCurNode->value;
                pCurNode->next = pNewNode;            //连接新老结点
                pCurNode = pNewNode;                //将新结点作为当前结点,向后插入结点
                pAListCurNode = pAListCurNode->next;
            }
        }
        else    //若不创建新结点则将alist中结点插在pos+1个结点之前
        {
            ListNode *pCurNode = GetNode(pos);
            //遍历alist到链表尾部
            while(pAListCurNode->next)
                pAListCurNode = pAListCurNode->next;
            //将当前链表与alist的结点相连
            pAListCurNode->next = pCurNode->next;
            pCurNode->next = alist.m_HeadNode->next;
           
            //断开alist与结点的关系
            alist.m_HeadNode->next = NULL;
            alist.m_nNodeCount = 0;
        }

        return true;
    }

    //功能: 删除第pos个结点;
    //参数:
    //    pos: 删除链表的序号;
    void Delete(int pos)
    {
        //若序号不正确则返回
        if(pos<1 || pos>m_nNodeCount)
            return;

        //获取第pos-1个结点
        ListNode *pCurNode = GetNode(pos-1);
        ListNode *pNextNode = pCurNode->next;
        //若第pos个结点存在则删除结点
        if(pNextNode)
        {
            pCurNode->next = pNextNode->next;
            delete pNextNode;
            m_nNodeCount--;
        }
    }

    //功能: 查找值为val的结点,并返回结点的序号.
    //参数:
    //    val: 匹配值.
    //返回值: 若查找成功则返回第一个值为val的结点的位置, 否则失败返回-1.
    int Find(const ValType &val)
    {
        int pos = 0;
        ListNode *pCurNode = m_HeadNode;
        while(pCurNode->next)
        {
            pCurNode = pCurNode->next;
            pos++;
            if(pCurNode->value == val)
                return pos;
        }
        return -1;
    }

    //功能: 交换链表结点.
    //参数:
    //    alist: 交换对象.
    void Swap(MyList &alist)
    {
        ListNode *head = m_HeadNode;
        int nCount = m_nNodeCount;
        //交换结点
        m_HeadNode = alist.m_HeadNode;
        alist.m_HeadNode = head;
        //交换链表结点数
        m_nNodeCount = alist.m_nNodeCount;
        alist.m_nNodeCount = nCount;
    }

    //功能: 打印链表.
    void Print()
    {
        ListNode *pCurNode = m_HeadNode->next;
        while(pCurNode)
        {
            std::cout<<pCurNode->value<<std::endl;
            pCurNode = pCurNode->next;
        }
    }
};

#endif    //#ifndef _ROC_LIST_H_

//------------------------------------------------------------------------------------------------------------------------
//Test.cpp
// Test.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include "ListTemplate.h"

int main(int argc, _TCHAR* argv[])
{
    List<int> list1;
    int i=0;
    for(i=0; i<11; i++)
        list1.Insert(5, i);
   
    std::cout<<"list1.Insert()"<<std::endl;
    std::cout<<"list1"<<std::endl;
    list1.Print();

    List<int> list2;
    for(i=50; i<56; i++)
        list2.Insert(0, i);
   
    std::cout<<"list2.Insert()"<<std::endl;
    std::cout<<"list2"<<std::endl;
    list2.Print();

    list2.Swap(list1);

    std::cout<<"list2.Swap(list1)"<<std::endl;
    std::cout<<"list1"<<std::endl;
    list1.Print();
   
    std::cout<<"list2"<<std::endl;
    list2.Print();

    List<int> list3(list1);
    std::cout<<"List<int> list3(list1)"<<std::endl;
    std::cout<<"list3"<<std::endl;
    list3.Print();

    List<int> list4;
    list4.Insert(0, list3, false);

    std::cout<<"list4.Insert(0, list3, false)"<<std::endl;
    std::cout<<"list3"<<std::endl;
    list3.Print();

    std::cout<<"list4"<<std::endl;
    list4.Print();
    return 0;
}