Chinaunix首页 | 论坛 | 博客

wuliqingyt

首页　| 　博文目录　| 　关于我

wuliqingyt

  • 博客访问： 160557
  • 博文数量： 34
  • 博客积分： 2070
  • 博客等级： 大尉
  • 技术积分： 277
  • 用 户 组： 普通用户
  • 注册时间： 2010-02-26 19:29
文章分类

全部博文（34）

文章存档

2015年（2）

2014年（4）

2013年（1）

2012年（1）

2011年（5）

2010年（21）

我的朋友
最近访客
推荐博文
相关博文
红黑色算法实现

分类： C/C++

2012-11-28 14:30:52

理论参考： 
维基百科中的红黑树算法介绍的很详细，下面是C++代码实现

  1. #ifndef _FRAME_RBTREE_H_
  2. #define _FRAME_RBTREE_H_

  4. #include <stdint.h>
  5. #include <new>

  7. #define S_OK                            0    

  9. #define E_CONTAIN_FULL                    0x80000001
  10. #define E_NOT_FOUND                        0x80000002

  12. template <typename Key, typename Value, uint32_t DEFAULT_ADD = 1024>
  13. class CRBTree
  14. {
  15. protected:
  16.     enum Color
  17.     {
  18.         enmColor_Red,
  19.         enmColor_Black,
  20.     };

  22. public:
  23.     class Node
  24.     {
  25.     public:
  26.         Key            nKey;
  27.         Value        value;

  29.     private:
  30.         Node        *pParent;
  31.         Node        *pLeft;
  32.         Node        *pRight;
  33.         Color        nColor;

  35.         friend    class CRBTree;

  37.         Node()
  38.         {
  39.             pParent = NULL;
  40.             pLeft    = NULL;
  41.             pRight    = NULL;
  42.             nColor    = enmColor_Red;
  43.         }
  44.     };

  46. public:
  47.     CRBTree()
  48.     {
  49.         m_pRoot = NULL;
  50.         m_pHead = NULL;
  51.         m_pMin = NULL;
  52.         m_nSize = 0;
  53.         m_pBuffer = NULL;
  54.     }

  56.     virtual ~CRBTree()
  57.     {
  58.         Clear();

  60.         while(NULL != m_pBuffer)
  61.         {
  62.             uint8_t *pBuffer = m_pBuffer;
  63.             m_pBuffer = *(uint8_t**)m_pBuffer;
  64.             delete pBuffer;
  65.         }
  66.     }

  68. protected:
  69.     Node* Pop()
  70.     {
  71.         if (NULL == m_pHead)
  72.         {
  73.             Reserve(GetCapacity() + DEFAULT_ADD);
  74.         }

  76.         ++m_nSize;
  77.         Node *pNode = m_pHead;
  78.         m_pHead = pNode->pParent;
  79.         return new(pNode)Node();
  80.     }

  82.     void Push(Node *pNode)
  83.     {
  84.         --m_nSize;
  85.         pNode->~Node();
  86.         pNode->pParent = m_pHead;
  87.         m_pHead = pNode;
  88.     }


  91. public:
  92.     int32_t Insert(const Key nKey, const Value &value)
  93.     {
  94.         Node *pNode = Pop();
  95.         if (NULL == pNode)
  96.         {
  97.             return E_CONTAIN_FULL;
  98.         }
  99.         pNode->nKey = nKey;
  100.         pNode->value = value;

  102.         if ((NULL == m_pMin) || (m_pMin->nKey >= pNode->nKey))
  103.         {
  104.             m_pMin = pNode;
  105.         }

  107.         Node *pParent = FindSite(m_pRoot, nKey);
  108.         if (NULL == pParent)
  109.         {
  110.             m_pRoot = pNode;
  111.             pNode->nColor = enmColor_Black;
  112.             return S_OK;
  113.         }

  115.         pNode->pParent = pParent;
  116.         if (pParent->nKey >= nKey)
  117.         {
  118.             pParent->pLeft = pNode;
  119.         }
  120.         else
  121.         {
  122.             pParent->pRight = pNode;
  123.         }

  125.         InsertRebalance(pNode);
  126.         return S_OK;
  127.     }

  129.     int32_t Delete(const Key nKey)
  130.     {
  131.         Node *pNode = FindNode(nKey);
  132.         if (NULL == pNode)
  133.         {
  134.             return S_OK;
  135.         }

  137.         if (m_pMin == pNode)
  138.         {
  139.             m_pMin = (NULL == pNode->pRight) ? pNode->pParent : FindSite(pNode->pRight, pNode->nKey);
  140.         }

  142.         if ((NULL != pNode->pLeft)
  143.                 && (NULL != pNode->pRight))
  144.         {
  145.             //替换
  146.             Node *pRMinNode = FindSite(pNode->pRight, nKey);    
  147.             Key nKey = pNode->nKey;
  148.             Value value = pNode->value;
  149.             pNode->nKey = pRMinNode->nKey;
  150.             pNode->value = pRMinNode->value;
  151.             pRMinNode->nKey = nKey;
  152.             pRMinNode->value = value;

  154.             pNode = pRMinNode;
  155.         }

  157.         if (pNode == m_pRoot)
  158.         {
  159.             if (NULL != pNode->pLeft)
  160.             {
  161.                 m_pRoot = pNode->pLeft;
  162.                 m_pRoot->pParent = NULL;
  163.             }
  164.             else if (NULL != pNode->pRight)
  165.             {
  166.                 m_pRoot = pNode->pRight;
  167.                 m_pRoot->pParent = NULL;
  168.             }
  169.             else
  170.             {
  171.                 m_pRoot = NULL;
  172.             }
  173.             Push(pNode);
  174.             return S_OK;
  175.         }

  177.         if (enmColor_Black == pNode->nColor)
  178.         {
  179.             Node *pChild = NULL;
  180.             if (NULL != pNode->pLeft)
  181.             {
  182.                 pChild = pNode->pLeft;
  183.             }
  184.             else if (NULL != pNode->pRight)
  185.             {
  186.                 pChild = pNode->pRight;
  187.             }
  188.             if (NULL != pChild)
  189.             {
  190.                 pNode->nColor = pChild->nColor;
  191.             }

  193.             DeleteRebalance(pNode);

  195.             if (NULL != pChild)
  196.             {
  197.                 pChild->nColor = pNode->nColor;
  198.             }
  199.         }

  201.         //删除节点
  202.         Node *pParent = pNode->pParent;
  203.         if (NULL != pNode->pLeft)
  204.         {
  205.             pNode->pLeft->pParent = pParent;
  206.             if (pNode == pParent->pLeft)
  207.             {
  208.                 pParent->pLeft = pNode->pLeft;
  209.             }
  210.             else
  211.             {
  212.                 pParent->pRight = pNode->pLeft;
  213.             }
  214.         }
  215.         else if (NULL != pNode->pRight)
  216.         {
  217.             pNode->pRight->pParent = pParent;
  218.             if (pNode == pParent->pLeft)
  219.             {
  220.                 pParent->pLeft = pNode->pRight;
  221.             }
  222.             else
  223.             {
  224.                 pParent->pRight = pNode->pRight;
  225.             }
  226.         }
  227.         else
  228.         {
  229.             if (pNode == pParent->pLeft)
  230.             {
  231.                 pParent->pLeft = NULL;
  232.             }
  233.             else
  234.             {
  235.                 pParent->pRight = NULL;
  236.             }
  237.         }
  238.         Push(pNode);
  239.         return S_OK;
  240.     }

  242.     int32_t Find(const Key nKey, Value &value)
  243.     {
  244.         Node *pNode = FindNode(nKey);
  245.         if (NULL == pNode)
  246.         {
  247.             return E_NOT_FOUND;
  248.         }
  249.         value = pNode->value;
  250.         return S_OK;
  251.     }

  253.     void Clear()
  254.     {
  255.         while(NULL != Begin())
  256.         {
  257.             Delete(Begin()->nKey);
  258.         }
  259.     }

  261.     void Reserve(const uint32_t nReserveSize)
  262.     {
  263.         const uint32_t nCapacity = GetCapacity();
  264.         if (nReserveSize <= nCapacity)
  265.         {
  266.             return;
  267.         }

  269.         Node arrNode[2];
  270.         const uint64_t nSize = (uint64_t)&arrNode[1] - (uint64_t)&arrNode[0];
  271.         const uint32_t nBlock = (nReserveSize - nCapacity + DEFAULT_ADD - 1) / DEFAULT_ADD;
  272.         for (uint32_t i = 0; i < nBlock; ++i)
  273.         {
  274.             uint8_t *pBuffer = new uint8_t[DEFAULT_ADD * nSize + sizeof(uint8_t*)];

  276.             *(uint8_t**)pBuffer = m_pBuffer;
  277.             m_pBuffer = pBuffer;

  279.             for (uint32_t j = 0; j < DEFAULT_ADD; ++j)
  280.             {
  281.                 Node *pNode = (Node*)(pBuffer + sizeof(uint8_t*) + j * nSize);
  282.                 pNode->pParent = m_pHead;
  283.                 m_pHead = pNode;
  284.             }
  285.         }
  286.     }

  288.     const Node* Begin()
  289.     {
  290.         return m_pMin;
  291.     }

  293.     const Node* Next(const Node *pNode)
  294.     {
  295.         if (NULL == pNode)
  296.         {
  297.             return NULL;
  298.         }
  299.         else if (NULL != pNode->pRight)
  300.         {
  301.             return FindSite(pNode->pRight, pNode->nKey);
  302.         }
  303.         else if (NULL != pNode->pParent)
  304.         {
  305.             while ((NULL != pNode->pParent) && (pNode == pNode->pParent->pRight))
  306.             {
  307.                 pNode = pNode->pParent;
  308.             }
  309.             return pNode->pParent;
  310.         }

  312.         return NULL;
  313.     }

  315.     uint32_t GetSize()
  316.     {
  317.         return m_nSize;
  318.     }

  320.     uint32_t GetCapacity()
  321.     {
  322.         uint32_t nCapacity = 0;
  323.         uint8_t *pBuffer = m_pBuffer;
  324.         while(NULL != pBuffer)
  325.         {
  326.             pBuffer = *(uint8_t**)pBuffer;
  327.             nCapacity += DEFAULT_ADD;
  328.         }

  330.         return nCapacity;
  331.     }

  333. protected:
  334.     Node* FindSite(Node *pNode, const Key nKey)
  335.     {
  336.         if (NULL == pNode)
  337.         {
  338.             return NULL;
  339.         }

  341.         while(true)
  342.         {
  343.             if (pNode->nKey >= nKey)
  344.             {
  345.                 if (NULL == pNode->pLeft)
  346.                 {
  347.                     return pNode;
  348.                 }

  350.                 pNode = pNode->pLeft;
  351.                 continue;
  352.             }
  353.             else
  354.             {
  355.                 if (NULL == pNode->pRight)
  356.                 {
  357.                     return pNode;
  358.                 }
  359.                 pNode = pNode->pRight;
  360.                 continue;
  361.             }
  362.         }
  363.         return NULL;
  364.     }

  366.     Node* FindNode(const Key nKey)
  367.     {
  368.         Node *pNode = m_pRoot;
  369.         if (NULL == pNode)
  370.         {
  371.             return NULL;
  372.         }

  374.         while (true)
  375.         {
  376.             if (pNode->nKey == nKey)
  377.             {
  378.                 return pNode;
  379.             }
  380.             else if (pNode->nKey > nKey)
  381.             {
  382.                 if (NULL == pNode->pLeft)
  383.                 {
  384.                     return NULL;
  385.                 }
  386.                 else
  387.                 {
  388.                     pNode = pNode->pLeft;
  389.                     continue;
  390.                 }
  391.             }
  392.             else
  393.             {
  394.                 if (NULL == pNode->pRight)
  395.                 {
  396.                     return NULL;
  397.                 }
  398.                 else
  399.                 {
  400.                     pNode = pNode->pRight;
  401.                     continue;
  402.                 }
  403.             }
  404.         }
  405.         return NULL;
  406.     }

  408.     void InsertRebalance(Node *pNode)
  409.     {
  410.         while(true)
  411.         {
  412.             //case 1
  413.             if (NULL == pNode->pParent)
  414.             {
  415.                 m_pRoot = pNode;
  416.                 pNode->nColor = enmColor_Black;
  417.                 return;
  418.             }

  420.             //case 2
  421.             Node *pParent = pNode->pParent;
  422.             if (enmColor_Black == pParent->nColor)
  423.             {
  424.                 return;
  425.             }

  427.             //case 3
  428.             Node *pGrandParent = pParent->pParent;
  429.             Node *pUncle = Uncle(pNode);
  430.             if ((NULL != pUncle) && (enmColor_Red == pUncle->nColor))
  431.             {
  432.                 pParent->nColor = enmColor_Black;
  433.                 pUncle->nColor = enmColor_Black;
  434.                 pGrandParent->nColor = enmColor_Red;

  436.                 pNode = pGrandParent;
  437.                 continue;
  438.             }

  440.             //case 4
  441.             if ((pNode == pParent->pRight) && (pParent == pGrandParent->pLeft))
  442.             {
  443.                 RotateLeft(pParent);
  444.                 pNode = pNode->pLeft;
  445.             }
  446.             else if ((pNode == pParent->pLeft) && (pParent == pGrandParent->pRight))
  447.             {
  448.                 RotateRight(pParent);
  449.                 pNode = pNode->pRight;
  450.             }

  452.             //case 5
  453.             pParent = pNode->pParent;
  454.             pGrandParent = pParent->pParent;

  456.             pParent->nColor = enmColor_Black;
  457.             pGrandParent->nColor = enmColor_Red;
  458.             if ((pNode == pParent->pLeft) && (pParent == pGrandParent->pLeft))
  459.             {
  460.                 RotateRight(pGrandParent);
  461.             }
  462.             else
  463.             {
  464.                 RotateLeft(pGrandParent);
  465.             }

  467.             break;
  468.         }

  470.         while((NULL != m_pRoot) && (NULL != m_pRoot->pParent))
  471.         {
  472.             m_pRoot = m_pRoot->pParent;
  473.         }
  474.     }

  476.     void DeleteRebalance(Node* pNode)
  477.     {
  478.         if (enmColor_Red == pNode->nColor)
  479.         {
  480.             pNode->nColor = enmColor_Black;
  481.             return;
  482.         }

  484.         while(true)
  485.         {
  486.             //case 1
  487.             if (NULL == pNode->pParent)
  488.             {
  489.                 break;
  490.             }

  492.             //case 2
  493.             Node *pParent = pNode->pParent;
  494.             //兄弟节点不可能是空节点
  495.             Node *pBrother = Brother(pNode);
  496.             if (enmColor_Red == pBrother->nColor)
  497.             {
  498.                 pParent->nColor = enmColor_Red;
  499.                 pBrother->nColor = enmColor_Black;
  500.                 if (pNode == pParent->pLeft)
  501.                 {
  502.                     RotateLeft(pParent);
  503.                 }
  504.                 else
  505.                 {
  506.                     RotateRight(pParent);
  507.                 }

  509.                 //旋转后兄弟节点位置发生变化
  510.                 pBrother = Brother(pNode);
  511.                 if (NULL == pBrother)
  512.                 {
  513.                     pParent->nColor = enmColor_Black;
  514.                     break;
  515.                 }
  516.             }

  518.             //case 3
  519.             if ((enmColor_Black == pParent->nColor)
  520.                     && SelfAndSonAllBlack(pBrother))
  521.             {
  522.                     pBrother->nColor = enmColor_Red;
  523.                     pNode = pParent;
  524.                     continue;
  525.             }

  527.             //case 4
  528.             if ((enmColor_Red == pParent->nColor)
  529.                     && SelfAndSonAllBlack(pBrother))
  530.             {
  531.                 pBrother->nColor = enmColor_Red;
  532.                 pParent->nColor = enmColor_Black;
  533.                 break;
  534.             }

  536.             //case 5
  537.             if (enmColor_Black == pBrother->nColor)
  538.             {
  539.                 if ((pNode == pParent->pLeft)
  540.                  && (NULL != pBrother->pLeft)
  541.                  && (enmColor_Red == pBrother->pLeft->nColor))
  542.                 {
  543.                     if ((NULL == pBrother->pRight)
  544.                             || (enmColor_Black == pBrother->pRight->nColor))
  545.                     {
  546.                         pBrother->nColor = enmColor_Red;
  547.                         pBrother->pLeft->nColor = enmColor_Black;
  548.                         RotateRight(pParent->pRight);
  549.                     }
  550.                 }
  551.                 else if ((pNode == pParent->pRight)
  552.                  && (NULL != pBrother->pRight)
  553.                  && (enmColor_Red == pBrother->pRight->nColor))
  554.                 {
  555.                     if ((NULL == pBrother->pLeft)
  556.                             || (enmColor_Black == pBrother->pLeft->nColor))
  557.                     {
  558.                         pBrother->nColor = enmColor_Red;
  559.                         pBrother->pRight->nColor = enmColor_Black;
  560.                         RotateLeft(pParent->pLeft);
  561.                     }
  562.                 }
  563.                 //旋转后兄弟节点位置发生变化
  564.                 pBrother = Brother(pNode);
  565.             }

  567.             //case 6
  568.             pBrother->nColor = pParent->nColor;
  569.             pParent->nColor = enmColor_Black;
  570.             if (pNode == pParent->pLeft)
  571.             {
  572.                 if (NULL != pBrother->pRight)
  573.                 {
  574.                     pBrother->pRight->nColor = enmColor_Black;
  575.                 }
  576.                 RotateLeft(pParent);
  577.             }
  578.             else
  579.             {
  580.                 if (NULL != pBrother->pLeft)
  581.                 {
  582.                     pBrother->pLeft->nColor = enmColor_Black;
  583.                 }
  584.                 RotateRight(pParent);
  585.             }

  587.             break;
  588.         }

  590.         while((NULL != m_pRoot) && (NULL != m_pRoot->pParent))
  591.         {
  592.             m_pRoot = m_pRoot->pParent;
  593.         }
  594.     }

  596.     Node* Uncle(const Node *pNode)
  597.     {
  598.         Node *pParent = pNode->pParent;
  599.         if ((NULL == pParent) || (NULL == pParent->pParent))
  600.         {
  601.             return NULL;
  602.         }

  604.         Node *pGrandParent = pParent->pParent;
  605.         if (pParent == pGrandParent->pLeft)
  606.         {
  607.             return (NULL == pGrandParent->pRight) ? NULL : pGrandParent->pRight;
  608.         }

  610.         return (NULL == pGrandParent->pLeft) ? NULL : pGrandParent->pLeft;
  611.     }

  613.     Node* Brother(const Node *pNode)
  614.     {
  615.         if (NULL == pNode->pParent)
  616.         {
  617.             return NULL;
  618.         }

  620.         Node *pParent = pNode->pParent;
  621.         if (pNode == pParent->pLeft)
  622.         {
  623.             return (NULL == pParent->pRight) ? NULL : pParent->pRight;
  624.         }
  625.         return (NULL == pParent->pLeft) ? NULL : pParent->pLeft;
  626.     }


  629.     void RotateLeft(Node *pNode)
  630.     {
  631.         Node *pRSon = pNode->pRight;
  632.         
  633.         if (NULL != pNode->pParent)
  634.         {
  635.             Node *pParent = pNode->pParent;
  636.             (pNode == pParent->pLeft) ? pParent->pLeft = pNode->pRight : pParent->pRight = pNode->pRight;
  637.         }

  639.         pRSon->pParent = pNode->pParent;
  640.         pNode->pParent = pNode->pRight;
  641.         pNode->pRight = pRSon->pLeft;
  642.         pRSon->pLeft = pNode;

  644.         if (NULL != pNode->pRight)
  645.         {
  646.             pNode->pRight->pParent = pNode;
  647.         }
  648.     }

  650.     void RotateRight(Node *pNode)
  651.     {
  652.         Node *pLSon = pNode->pLeft;

  654.         if (NULL != pNode->pParent)
  655.         {
  656.             Node *pParent = pNode->pParent;
  657.             (pNode == pParent->pLeft) ? pParent->pLeft = pNode->pLeft: pParent->pRight = pNode->pLeft;
  658.         }

  660.         pLSon->pParent = pNode->pParent;
  661.         pNode->pParent = pNode->pLeft;
  662.         pNode->pLeft = pLSon->pRight;
  663.         pLSon->pRight = pNode;

  665.         if (NULL != pNode->pLeft)
  666.         {
  667.             pNode->pLeft->pParent = pNode;
  668.         }
  669.     }

  671.     bool SelfAndSonAllBlack(const Node *pNode)
  672.     {
  673.         if (enmColor_Black != pNode->nColor)
  674.         {
  675.             return false;
  676.         }

  678.         if ((NULL != pNode->pLeft)
  679.          && (enmColor_Black != pNode->pLeft->nColor))
  680.         {
  681.             return false;
  682.         }

  684.         if ((NULL != pNode->pRight)
  685.          && (enmColor_Black != pNode->pRight->nColor))
  686.         {
  687.             return false;
  688.         }

  690.         return true;
  691.     }

  693. protected:
  694.     Node                    *m_pRoot;
  695.     Node                    *m_pHead;
  696.     Node                    *m_pMin;

  698.     uint32_t                m_nSize;    
  699.     uint8_t                    *m_pBuffer;
  700. };

  702. #endif
下面是测试代码，在linux平台环境下测试通过

  1. #include <stdlib.h>
  2. #include <iostream>
  3. #include "frame_rbtree.h"
  4. using namespace std;

  6. #define COUT(x) \
  7.     do { cout << #x << "=" << x << endl; } while(false)

  9. typedef CRBTree<uint32_t, uint32_t, 16> RBTree;

  11. enum
  12. {
  13.     //enmKeySize = 512,
  14. };

  16. class A
  17. {
  18. public:
  19.     A()
  20.     {
  21.         COUT(__FUNCTION__);
  22.     }
  23.     ~A()
  24.     {
  25.         COUT(__FUNCTION__);
  26.     }
  27. };

  29. typedef CRBTree<uint32_t, uint32_t, 16> RBTree;

  31. typedef CRBTree<uint32_t, A, 16> ARBTree;

  33. int32_t main(const int32_t argc, const char** argv)
  34. {    
  35.     uint32_t enmKeySize = (uint32_t)atoi(argv[1]);
  36.     COUT(enmKeySize);

  38.     /*
  39.     A a;
  40.     ARBTree *Atree = new ARBTree();

  42.     for (uint32_t i = 0; i < enmKeySize; ++i)
  43.     {
  44.         Atree->Insert(i, a);
  45.     }

  47.     for (const ARBTree::Node *pNode = Atree->Begin(); NULL != pNode; pNode = Atree->Next(pNode))
  48.     {
  49.         COUT(pNode->nKey);
  50.     }

  52.     for (uint32_t i = 0; i < enmKeySize; ++i)
  53.     {
  54.         Atree->Delete(i);
  55.     }

  57.     Atree->Reserve(100);

  59.     COUT(Atree->GetSize());
  60.     COUT(Atree->GetCapacity());


  63.     delete Atree;
  64.     return 0;
  65.     */

  67.     uint32_t *arrKey = new uint32_t[enmKeySize];
  68.     for (uint32_t i = 0; i < enmKeySize; ++i)
  69.     {
  70.         arrKey[i] = i;
  71.     }

  73.     srand(time(NULL));
  74.     for (uint32_t i = 0; i < enmKeySize; ++i)
  75.     {
  76.         uint32_t nRand = rand() % enmKeySize;
  77.         uint32_t nTmp = arrKey[nRand];
  78.         arrKey[nRand] = arrKey[i];
  79.         arrKey[i] = nTmp;
  80.     }

  82.     RBTree *tree = new RBTree();
  83.     for (uint32_t i = 0; i < enmKeySize; ++i)
  84.     {
  85.         tree->Insert(arrKey[i], i);
  86.         //tree->Insert(i, i);
  87.     }

  89.     for (uint32_t i = 0; i < enmKeySize; i++)
  90.     {
  91.         tree->Delete(i);
  92.     }

  94.     for (uint32_t i = enmKeySize; i < enmKeySize * 2; ++i)
  95.     {
  96.         tree->Insert(i, i);
  97.     }

  99.     for (uint32_t i = 0; i < enmKeySize * 2; i += 10)
  100.     {
  101.         tree->Delete(i);
  102.     }

  104.     for (uint32_t i = 0; i < enmKeySize * 2; i += 10)
  105.     {
  106.         tree->Insert(i, i);
  107.     }

  109.     for (uint32_t i = 0; i < enmKeySize * 2; i += 10)
  110.     {
  111.         tree->Insert(0, 0);
  112.         tree->Insert(enmKeySize * 2, enmKeySize * 2);
  113.     }

  115.     for (const RBTree::Node *pNode = tree->Begin(); NULL != pNode; pNode = tree->Next(pNode))
  116.     {
  117.         printf("Key=%d, Value=%d\n", pNode->nKey, pNode->value);
  118.     }

  120.     COUT(tree->GetSize());
  121.     COUT(tree->GetCapacity());

  123.     return 0;
  124. }



阅读(1663) | 评论(0) | 转发(0) |
0

上一篇：gdb调试基本命令

下一篇：改变linux shell的输出效果［字体颜色，样式等］

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6