CTDChain<T,sort,equal,pointer> * nodeTemp = NULL;

------------------------------------------------------------------------------

using namespace std;
//双向不循环链表
//sort 指示是否有序
//equal 指示当出现相同节点时的处理方法
//pointer 指示是否是一个指针类型，在析构时必不可少
template <class T,
        const int sort = 0,
        const CtEqualMethod equal = CtEM_ALLOW,
        const int pointer = 1> 
--------------------------------------------------------------------------------------
class CTDChain
{
public:
    CTDChain    * m_pPrev;
    CTDChain    * m_pNext;
    T            m_tItem;
 
protected:
 
    // 向链表头搜索一个节点, 失败时返回空指针，direct指示搜索方向
    virtual CTDChain * SearchPrev(T &item)
    {
        if( TypeComp(m_tItem,item, CtCS_EQ) ) return this;
        else if( m_pPrev )
            return m_pPrev->CTDChain<T,sort,equal,pointer>:: SearchPrev(item);
        else return NULL;
    }
 
 
    // 向链表尾部搜索一个节点, 失败时返回空指针，direct指示搜索方向
    virtual CTDChain * SearchNext(T &item)
    {
        if( TypeComp(m_tItem,item, CtCS_EQ) ) return this;
        else if( m_pNext )
            return m_pNext->CTDChain<T,sort,equal,pointer>:: SearchNext(item);
        else return NULL;
    }
 
 
    //从本节点开始向后查找最小的节点，由排序函调用
    virtual CTDChain * SmallestNext()
    {
        CTDChain<T,sort,equal,pointer> * nodeNext = m_pNext;
        CTDChain<T,sort,equal,pointer> * nodeSmall = this;
 
        while( nodeNext )
        {
            if( nodeSmall->m_tItem > nodeNext->m_tItem ) nodeSmall = nodeNext;
            nodeNext = nodeNext->m_pNext;
        }
        return nodeSmall;
    }
 
public:
 
    CTDChain(): m_pPrev(0), m_pNext(0), m_tItem(0){};
 
 
    CTDChain(T &item): m_pPrev(0), m_pNext(0), m_tItem(0)
    {
        CTDChain<T,sort,equal,pointer>:: SetNodeItem(item);
    }
 
 
    //考贝构造函数
    CTDChain(CTDChain & node)
    {
        m_pPrev = node.m_pPrev;
        m_pNext = node.m_nNext;
        if( pointer )
        {
            if( !m_tItem ) m_tItem = new T;
            *m_tItem = *(node.nodeItem);
        }
        else m_tItem = node.nodeItem;
 
    }
 
 
    //析构时自动删除在它后面的节点
    ~CTDChain()
    {
        if( pointer && m_tItem ) delete m_tItem;
        if( m_pPrev ) m_pPrev->m_pNext = NULL;
        if( m_pNext )
        {
            m_pNext->m_pPrev = NULL;
            delete m_pNext;
            m_pNext = NULL;
        }
    }
 
 
    // 找到链表头节点
    CTDChain * Head()
    {
        if( !m_pPrev ) return this;
        else return m_pPrev->CTDChain<T,sort,equal,pointer>:: Head();
    }
 
 
    // 找到链表尾节点
    CTDChain * Tail()
    {
        if( !m_pNext ) return this;
        else return m_pNext->CTDChain<T,sort,equal,pointer>:: Tail();
    }
 
 
    //统计链表中节点个数
    int NodeNum()
    {
        int nNum = 0;
        CTDChain<T,sort,equal,pointer> * nodeTemp = Head();
        while( nodeTemp )
        {
            nNum++;
            nodeTemp = nodeTemp->m_pNext;
        }
        return nNum;
    }
 
 
    //从链表中移走一个节点
    //注意：Pop头节点时，要有指针记录新的头节点
    virtual void Pop()
    {
        if( m_pPrev ) m_pPrev->m_pNext = m_pNext;
        if( m_pNext ) m_pNext->m_pPrev = m_pPrev;
        m_pPrev = m_pNext = NULL;
    }
 
 
    //设置一个节点的值，替换掉原有的值
    virtual int SetNodeItem(const T &item)
    {
        if( pointer && m_tItem ) delete m_tItem;
        m_tItem = item;
        return CtRC_REPLACE;
    }
 
    int TypeComp(const T &a, const T&b, CtCompartStyle style = CtCS_GT)
    {
        if( pointer )
        {
            switch( style )
            {
            case CtCS_GT: return ((*a) >  (*b)); break;
            case CtCS_GE: return ((*a) >= (*b)); break;
            case CtCS_EQ: return ((*a) == (*b)); break;
            case CtCS_NE: return ((*a) != (*b)); break;
            case CtCS_LT: return ((*a) <  (*b)); break;
            case CtCS_LE: return ((*a) <= (*b)); break;
            default: return 0;
            }
        }
        else
        {
            switch( style )
            {
            case CtCS_GT: return (a >  b); break;
            case CtCS_GE: return (a >= b); break;
            case CtCS_EQ: return (a == b); break;
            case CtCS_NE: return (a != b); break;
            case CtCS_LT: return (a <  b); break;
            case CtCS_LE: return (a <= b); break;
            default: return 0;
            }
        }
            return 1;
    }
 
 
    // 搜索一个节点, 失败时返回空指针
    virtual CTDChain * Search(T &item)
    {
        CTDChain<T,sort,equal,pointer> * nodeTemp = NULL;
 
        if( TypeComp(m_tItem,item,CtCS_EQ) ) return this;
        if( sort )
        {//有序
            if( TypeComp(item,m_tItem) ) nodeTemp = CTDChain<T,sort,equal,pointer>:: SearchNext(item);
            else nodeTemp = CTDChain<T,sort,equal,pointer>:: SearchPrev(item);
        }
        else
        {//无序
            nodeTemp = CTDChain<T,sort,equal,pointer>:: SearchPrev(item);
            if( !nodeTemp ) nodeTemp = CTDChain<T,sort,equal,pointer>:: SearchNext(item);
        }
        return nodeTemp;
    }
 
 
    //插入一个节点在本节点之前，node必须是一个单节点
    virtual int PushPrev(CTDChain * node)
    {
        node->m_pNext = this;
        node->m_pPrev = m_pPrev;
        if( m_pPrev ) m_pPrev->m_pNext = node;
        m_pPrev = node;
        return CtRC_SUCCESS;
    }
 
 
    //插入一个节点在本节点之后，node必须是一个单节点
    virtual int PushNext(CTDChain * node)
    {
        node->m_pNext = m_pNext;
        node->m_pPrev = this;
        if( m_pNext ) m_pNext->m_pPrev = node;
        m_pNext = node;
        return CtRC_SUCCESS;
    }
 
 
    //插入一个单节点
    virtual int Push(CTDChain * &node)
    {
        CTDChain<T,sort,equal,pointer> * nodeTemp;
 
        if( !node ) return CtRC_FAIL;
 
        //判断相同节点
        switch( equal )
        {
        case CtEM_REJECT:    //不允许出现相同节点
        case CtEM_REPLACE:    //替换相同节点
            nodeTemp = CTDChain<T,sort,equal,pointer>:: Search(node->m_tItem);
            if( NULL == nodeTemp ) break;
            if( equal == CtEM_REJECT ) return CtRC_REJECT;
            return nodeTemp->CTDChain<T,sort,equal,pointer>:: SetNodeItem(node->m_tItem);
            break;
        case CtEM_ALLOW:    //允许出现相同节点
        default:
            break;
        }
 
        //查找插入点，这里不用考虑相等情况
        nodeTemp = this;
        if( sort )
        {//有序
            if( TypeComp(node->m_tItem,nodeTemp->m_tItem) )
            {//向表尾查找
                while( TypeComp(node->m_tItem,nodeTemp->m_tItem) )
                {
                    if( !nodeTemp->m_pNext ) break;
                    nodeTemp = nodeTemp->m_pNext;
                }
            }
            else
            {//向表头查找
                while( TypeComp(nodeTemp->m_tItem,node->m_tItem) )
                {
                    if( !nodeTemp->m_pPrev )
                        return nodeTemp->CTDChain<T,sort,equal,pointer>:: PushPrev(node);
                    nodeTemp = nodeTemp->m_pPrev;
                }
            }
        }
        else
        {//无序
            nodeTemp = CTDChain<T,sort,equal,pointer>:: Tail();
        }
 
        //在上面还有一个插入点，是插入在链表的头部
        return nodeTemp->CTDChain<T,sort,equal,pointer>:: PushNext(node);
    }
 
    virtual int Push(T &item)
    {
        CTDChain<T,sort,equal,pointer> * nodeTemp;
        int nRet;
 
        if( NULL == (nodeTemp = new CTDChain<T,sort,equal,pointer>(item)) )
        {
            RAISE_ERROR("警告：申请内存失败");
            return CtRC_FAIL;
        }
 
        nRet = CTDChain<T,sort,equal,pointer>:: Push(nodeTemp);
        switch( nRet )
        {
        case CtRC_FAIL: break;
        case CtRC_SUCCESS: break;
        case CtRC_REPLACE:
            if( pointer ) nodeTemp->m_tItem = NULL;
        case CtRC_REJECT:
            delete nodeTemp;
            break;
        default: break;
        }
 
        return nRet;
    }
 
 
    //插入另外一个链表的所有节点，返回值是插入节点的个数
    //插入完成后，原链表被删除
    virtual int Merge(CTDChain * &chain)
    {
        CTDChain<T,sort,equal,pointer> * nodeTemp;
        int nRet, nNum = 0;
        if( !chain ) return 0;
 
        //先截断原链表
        if( chain->m_pPrev )
        {
            chain->m_pPrev->m_pNext = NULL;
            chain->m_pPrev = NULL;
        }
 
        //如果允许相同节点且无序
        if( equal == CtEM_ALLOW && !sort )
        {
            nNum = chain->NodeNum();
            nodeTemp = CTDChain<T,sort,equal,pointer>:: Tail();
            nodeTemp->m_pNext = chain;
            chain->m_pPrev = nodeTemp;
        }
        else
        {
            nodeTemp = chain;
            while( nodeTemp )
            {
                chain = chain->m_pNext;
                nodeTemp->Pop();
                nRet = CTDChain<T,sort,equal,pointer>:: Push(nodeTemp);
                switch( nRet )
                {
                case CtRC_SUCCESS: nNum++; break;
                case CtRC_REPLACE:
                    if( pointer ) nodeTemp->m_tItem = NULL;
                case CtRC_REJECT:
                case CtRC_FAIL:
                    delete nodeTemp;
                    break;
                default: break;
                }
                nodeTemp = chain;
            }
        }
        chain = NULL;
        return nNum;
    }
 
 
    //排序函数, 它使用T的操作符 '>'
    virtual void Sort()
    {
        CTDChain<T,sort,equal,pointer> * nodeSmall;
        CTDChain<T,sort,equal,pointer> * nodeTemp = CTDChain<T,sort,equal,pointer>:: Head();
 
        while( nodeTemp )
        {
            nodeSmall = nodeTemp->CTDChain<T,sort,equal,pointer>:: SmallestNext();
            if( nodeSmall != nodeTemp )
            {//最小节点不是当前节点
                nodeSmall->CTDChain<T,sort,equal,pointer>:: Pop();
                nodeTemp->CTDChain<T,sort,equal,pointer>:: PushPrev(nodeSmall);
            }
            else nodeTemp = nodeTemp->m_pNext;
        }
    }

C++ 模板双向不循环链表！！的更多相关文章

  1. Redis list实现原理 - 双向循环链表

    双向链表 双向表示每个节点知道自己的直接前驱和直接后继,每个节点需要三个域 查找方向可以是从左往右也可以是从右往左,但是要实现从右往左还需要终端节点的地址,所以通常会设计成双向的循环链表; 双向的循环 ...

  2. Dancing Links 模板

    struct dl{ // x: line, y: column struct node{ int c, left, right, up, down; }; vector<node> a; ...

  3. 通过例子进阶学习C++（七）CMake项目通过模板库实现约瑟夫环

    本文是通过例子学习C++的第七篇,通过这个例子可以快速入门c++相关的语法. 1.问题描述 回顾一下约瑟夫环问题:n 个人围坐在一个圆桌周围,现在从第 s 个人开始报数,数到第 m 个人,让他出局:然 ...

  4. 侯捷STL学习(一)

    开始跟着<STL源码剖析>的作者侯捷真人视频,学习STL,了解STL背后的真实故事! 视频链接:侯捷STL 还有很大其他视频需要的留言 第一节:STL版本和重要资源 STL和标准库的区别 ...

  5. 侯捷STL课程及源码剖析学习1

    1.C++标准库和STL C++标准库以header files形式呈现: C++标准库的header files不带后缀名(.h),例如#include <vector> 新式C hea ...

  6. 侯捷STL学习(一)--顺序容器测试

    开始跟着<STL源码剖析>的作者侯捷真人视频,学习STL,了解STL背后的真实故事! 视频链接:侯捷STL 还有很大其他视频需要的留言 第一节:STL版本和重要资源 STL和标准库的区别 ...

  7. 详解DLX及其应用

    什么是DLX? 让我们看看百度百科上的解释:在 计算机科学 中, Dancing Links ,舞蹈链, 也叫 DLX, 是由 Donald Knuth 提出的数据结构,目的是快速实现他的 X算法.X ...

  8. Josephus环类问题，java实现

    写出一个双向的循环链表,弄一个计数器,我定义的是到三的时候,自动删除当前节点,很简单. package Com; import java.util.Scanner; /* * 约瑟夫环问题,有n个人组 ...

  9. Redis入门指南（第2版） Redis设计思路学习与总结

    https://www.qcloud.com/community/article/222 宋增宽,腾讯工程师,16年毕业加入腾讯,从事海量服务后台设计与研发工作,现在负责QQ群后台等项目,喜欢研究技术 ...

随机推荐

  1. [vim]的关键字补全

    除了complete关键字补全,所有补全相关命令都以CTRL-X开始,然后再接与补全类型相关的命令.CTRL-N与CTRL-P在找的的内容中选择的通用的命令,上下选择用的,CTRL-E则是取消选择.( ...

  2. 实践：VIM深入研究（20135301 && 20135337）

    目录 一.基本知识 1.vim模式介绍 2.三种常用模式的切换 二.Vim文档编辑 1.vim重复命令 2.游标的快速跳转 3.复制粘贴和剪切 4.删除文本 5.字符的替换及撤销(Undo操作) 6. ...

  3. 在MacBook Air 上装Win10的，反反复复的失败过程。

    这个月初,一个女性朋友托我帮她装电脑,往MacBook Air上面装Windows 系统,原因是windows用的习惯,用起来顺手.然后用脚趾头考虑了一下,就一口答应下来了.难道这就是一个标准程序员的 ...

  4. Orchard基本概念

    本文链接:http://www.cnblogs.com/souther/p/4531273.html Orchard是个CMS(这不是废话么),它的首要目标是帮助你从现有的碎片建设网站.这些碎片大小不 ...

  5. 微信小程序「官方示例代码」浅析【上】

    从某个微信群里,拿到了这个IDE的下载地址,然后就有了这个: 根本登不上去,怎么办,怎么办呢? 看代码啊... 反正我又没有保密协议,解压缩一看NodeWebkit + React: 好啦 ,逛逛呗, ...

  6. （旧）子数涵数·PS ——素描效果

    一.准备素材(均为在百度上下载的) 二.打开ps,并在ps中打开第一张素材 三.复制图层(好习惯) 四.去色将图像变成黑白,图像->调整->去色,快捷键为Ctrl+Shift+U 五,复制 ...

  7. php检测php.ini是否配制正确

    运行命令行 php -d display_startup_errors=1 -d error_reporting=-1 -d display_errors -c "C:\path-to-ph ...

  8. 百度地图 IOS版开发经验分享

    最近刚完成app中地图的应用,感觉非常的曲折,折腾了很久,刚才开始一直不能成功使用百度地图api,报一大堆的错误,后来换到高德地图,又发现服务端使用的百度的经纬度,又从高德换回百度,泪奔. 这里简单比 ...

  9. C#线程模型脉络

    今天在看同事新买到的<C#本质论 Edition 4>的时候,对比下以前Edtion3的新特性时针对Async/Await关键字时发现对一些线程方面的定义还理解的不是很透彻,脉络还不是很清 ...

  10. “耐撕”团队 2016.03.24 站立会议

    时间: 2016.03.22  17:00-17:30     18:30-19:00 成员: Z 郑蕊 * 组长 (博客:http://www.cnblogs.com/zhengrui0452/), ...