stl关于set问题

[yinquan8241]

set<int> coll;
coll.insert(1);
coll.insert(2);
coll.insert(3);
coll.insert(4);
coll.insert(5);
coll.insert(6);
这样子生成的二叉树的形态是怎样的??

set<int> coll1;
coll1.insert(4);
coll1.insert(2);
coll1.insert(1);
coll1.insert(3);
coll1.insert(6);
coll1.insert(5);

coll和coll1的形态是一样的吗？

[yshuise]

1
\
2
\
3
\
4
\
5
\
6



4
/ \
2 6
/ \ /
1 3 5

[mengde007]

应该不一样吧；set的底层是rb-tree;rb-tree的变化应该不同；

[yinquan8241]

你那第一个结果是二叉树吗？

[yinquan8241]

同意二楼的请举下手

[nickyjay0501]

同意二楼的

[Jamy325]

2楼的说法不对｀｀
set底层实现是用红黑树实现的，
满足下面几个条件的二叉搜索树，称为红黑树：
１任何一个节点都被着色――红色或是黑色。
２.根节点是黑色的。
３.所有的NIL节点都看成黑色（NIL节点是就是一个假想的或是无实在意义的节点，所有应该指向NULL的指针，都看成指向了NIL节点。包括叶节点的子节点指针或是根节点的父指针）。
４. 如果一个节点是红色的，那么它的子节点一定是黑色的。
５.对于任何一个节点而言，从该节点到它的子孙节点中的NIL节点路径中，所包含的黑节点个数相同。


每次的插入多要考虑红黑的平衡，不可能是直接插入｀｀

[yinquan8241]

那你说说两棵二叉树的形态是怎样的？？

[yshuise]

[Quote=引用 6 楼 suzhijie325 的回复:]
2楼的说法不对｀｀
set底层实现是用红黑树实现的，
满足下面几个条件的二叉搜索树，称为红黑树：
１任何一个节点都被着色――红色或是黑色。
２.根节点是黑色的。
３.所有的NIL节点都看成黑色（NIL节点是就是一个假想的或是无实在意义的节点，所有应该指向NULL的指针，都看成指向了NIL节点。包括叶节点的子节点指针或是根节点的父指针）。
４. 如果一个节点是红色的，那么它的子节点一定是黑色的。
５.对于任何一个节点而…
[/Quote]
楼主问的是二叉树，不是红黑树。我是按照二叉树来写的。至于说set是用红黑树来实现，到没有考虑。
但是，只要按照这个顺序插入，就是这种形态。

[yinquan8241]

我看的侯捷写的 C++标准程序库 里说的set底层确实是二叉树

同意二楼 yshuise 说的 请举手，举手就给分。

[taodm]

去认真看《stl源码剖析》吧

[猫已经找不回了]

set是红黑树，操作过程看看这里吧

http://blog.csdn.net/ujs_abc/archive/2008/01/28/2069950.aspx

[ououo]

恶.... 飘过

[yinquan8241]

红黑树也是二叉树
我现在不关心它是什么树
我只要知道
set <int> coll;
coll.insert(1);
coll.insert(2);
coll.insert(3);
coll.insert(4);
coll.insert(5);
coll.insert(6);
和
set <int> coll1;
coll1.insert(4);
coll1.insert(2);
coll1.insert(1);
coll1.insert(3);
coll1.insert(6);
coll1.insert(5);

的形态是什么？
赞成二楼的举手

[hhygcy]

首先肯定是关联性的容器的内部数据结构是平衡树.
在 STL的map和set中出于效率的考虑使用的红黑树. 注意不是AVL树.
网上搜索一下很容易的得到红黑树的Applet

[yshuise]

这是我很早实现的红黑树，参照《算法导论》上实现的。

//RedBlack.h
#ifndef REDBLACK_INCLUDE
#define REDBLACK_INCLUDE

template<typename T>
class RedBlackTree
{
    struct Node{
            T       key;
            bool    color;
            Node*   parent;
            Node*   left;
            Node*   right;
            Node(T data_, bool  color_, Node* p, Node* l, Node* r)
                :key(data_),color(color_),parent(p),left(l),right(r)...{}
    };     
           Node* NIL;
           Node* root;
           bool  RED   ;
           bool  BLACK ;
           
public:

    RedBlackTree(T data=0, bool str=false, Node* p=NULL, Node* q=NULL, Node* e=NULL):RED(true),BLACK(false)
    {   
           
            NIL =  new Node(0, BLACK, NIL, NIL, NIL);//哨兵结点
            root = NIL;
        
    }
    ~RedBlackTree()
    {
       DeleteTree(root);
       delete NIL;
    }
    
     void  LeftRotate(Node* x);
     void  RightRotate(Node* y);
     void  RBInsert(T  data);
     void  RBInsertFixup(Node* z);
     void  RBDelete(T data);
     void  RBDeleteFixUp(Node* x);
     Node* TreeSearchNumber(Node* x, T k);
     Node* TreeSuccessor(Node* x);
     void  DeleteTree(Node* x);
     void  PrintTree(Node* x);
     Node* GetNode(void);
     Node* TreeMinIMUM(Node* x );

};

#endif
//RedBlackTree_.h
#ifndef REDBLACKTREE_H_INCLUDE
#define REDBLACKTREE_H_INCLUDE

#include "RedBlack.h"
#include <assert.h>
#include <string>
#include <iostream>

template<typename T>
RedBlackTree<T>::Node* RedBlackTree<T>::TreeMinIMUM(Node* x )
{
    while(x->left != NIL)
      x = x->left;
      return x;
}
template<typename T>
RedBlackTree<T>::Node*  RedBlackTree<T>::GetNode(void)
{
    return root;
}

template<typename T>
void RedBlackTree<T>::PrintTree(Node* x)
{   
    if(NIL != x)...{
        if(NIL != x->left)
        {
         PrintTree(x->left);
        }
        if(NIL != x->right)
        {
         PrintTree(x->right);
        }
        std::cout<<x->key<<std::endl;
    }
}

template<typename T>
void RedBlackTree<T>::DeleteTree(Node* x)
{
    if(x != NIL)
    {   
        if(NIL != x->left )
        {
         DeleteTree(x->left);
        }
        if(NIL != x->right  )
        {
         DeleteTree(x->right);
        }
         delete x;
         x = NULL;
    }
}

template<typename T>
RedBlackTree<T>::Node* RedBlackTree<T>::TreeSearchNumber(Node* x, T k)
{
        if( x == NIL || k == x->key )
            return x;
        if( k < x->key )
            return TreeSearchNumber(x->left, k);
        else
            return TreeSearchNumber(x->right, k);
 }

template<typename T>
RedBlackTree<T>::Node* RedBlackTree<T>::TreeSuccessor(Node* x)//存在两种情况:
{
      if (x->right != NIL)//如果结点x的右子树非空，则x的后继即右子树中的最左的结点。
            return TreeMinIMUM(x->right) ;
      Node* y = x->parent;//如果结点x的右子树为空，且x有一个后继y，则y是x的最低祖先结点，
      while( (y != NIL) && (x == x->right))//且y的左儿子也是x的祖先票篇 p154,p155《算法导论》
      {
          x = y;
          y = y->parent;
      }
       return y;
 }
template<typename T>
void RedBlackTree<T>::LeftRotate(Node* x)
{  
      Node* y  = x->right; //y是x的右结点
      if(NIL == y)
          return;
      x->right = y->left;     //让x的右指针指向y的左结点。
      if(NIL != y->left)      //y的左结点不是哨兵
          y->left->parent = x;//让y的左结点的parent指向x
      y->parent = x->parent;  //让y的父子针指向x的父结点
      if(x->parent == NIL) //x为根结点
      {
           root = y;//让y成为根结点
      }
      else if(x == x->parent->left)//如果x为左子女
      {
        x->parent->left = y; //y便代替x成为左子女
      }
      else
          x->parent->right =y; //否则代替x成为右子女

      y->left = x;            //x成为y的左子女
      x->parent = y;          //y成为x的父结点
}
//______________________________________________________________//
//                                                              //
//     |                                 |                      //
//       X      left_Rotate(T,x)           Y                      //
//      /      ----------------->        /                      //
//   α  Y    <----------------        X  γ                    //
//      /     Right_Rotate(T,y)      /                        //
//       β γ                         α β                      //
//______________________________________________________________//

template<typename T>
void RedBlackTree<T>::RightRotate(Node* y )
{
      Node* x = y->left;
      if(NIL == x)
          return;
      y->left = x->right;
      if(x->right != NIL)
          x->right->parent = y;
      x->parent = y->parent;
      if(y->parent == NIL)
      {
          root = x;
      }
      else if (y == y->parent->right)
      {
          y->parent->right = x;
      }
      else
      {
          y->parent->left = x;
      }
      
      x->right  = y;
      y->parent = x;
}

template<typename T>
void RedBlackTree<T>::RBInsert(T data)
{     
      Node* x = root;
      Node* z = new Node(data,RED,NULL,NULL,NULL);//将要插入的结点
      assert(z != NULL);
      Node* y = NIL;
     
      while( x != NIL)
      {
          y = x;
          if(z->key < x->key)
          {
              if(x->left != NIL)
              {
               x = x->left;
              }
              else
              {
                  break;
              }
          }
          else 
          {    
              if(x->right != NIL)
              {
                 x = x->right;
              }
              else
              {
                  break;
              }
          }
      }
       z->parent = y;
       if(y == NIL)
           root = z;
       else if(z->key < y->key)
           y->left = z;
           else
               y->right = z;
        z->left = NIL;
        z->right = NIL;
        z->color = RED;
        RBInsertFixup(z);
}

}

[yshuise]

//在调用RBInsertFixup()，那些红黑树的性质可能会被破坏呢？性质1和性质3当然继续成立，
//因为新插入的结点的子女都是哨兵NIL。性质5即从一个制定结点开始的每条路径上黑结点的个数
//都是相等的，也会成立，因为结点z本身就是具有哨兵子女的红结点。因此，可能被破坏的就是根节点2，
//以及一个红结点不能有红子女的性质4。这两个可能的破坏是因为z被着为红色。如果z是根结点则破坏了性质2,
//如果z的父结点是红色就破坏了性质4.

template<typename T>
void RedBlackTree<T>::RBInsertFixup(Node* z)
{    
      Node* y = NIL;
      while( root != z && z->parent->color == RED)
      {
        if( z->parent == z->parent->parent->left)
          {
              y =  z->parent->parent->right;
            if(y != NIL && y->color == RED  )
            {
                z->parent->color = BLACK;
                y->color = BLACK;
                z->parent->parent->color = RED;
                z = z->parent->parent;
            }
             else 
             {
                if( z == z->parent->right)
                {
                    z = z->parent;
                    LeftRotate(z);
                }
            
             
                 z->parent->color = BLACK;
                 z->parent->parent->color = RED;//还没旋转
                 RightRotate(z->parent->parent);
             }
             
          }
              
        else
        {     
             y =  z->parent->parent->left;
          if(y != NIL && y->color == RED  )
          {
              z->parent->color = BLACK;
              y->color = BLACK;
              z->parent->parent->color = RED;
              z = z->parent->parent;
          }
          else 
          {  
              if (z == z->parent->left)
              {
                  z = z->parent;
                  RightRotate(z);
              }
         
              z->parent->color = BLACK;
              z->parent->parent->color = RED;
              LeftRotate(z->parent->parent);
          }
          
        }

      
      }//while
        
      root->color = BLACK;

}

template<typename T>
void RedBlackTree<T>::RBDelete(T data)
{     
      Node* x = NIL;
      Node* y = NIL;
      assert(TreeSearchNumber(root, data)->key == data);//查找看有没有值和同结点指示的一样
      Node* z = TreeSearchNumber(root, data);//找到此结点
      if((z->left == NIL) ||(z->right == NIL))
      {
        y = z;
      }
       else
       {
         y = TreeSuccessor(z);
       }
      if(y->left != NIL)
      {
         x = y->left;
      }
       else
       {
          x = y->right;
       }

      x->parent = y->parent;
      if(y->parent == NIL)
          root = x;
      else if(y == y->parent->left)
          y->parent->left = x;
      else
          y->parent->right = x;

      if(y != z)
          z->key = y->key;
    
      if(y->color == BLACK && NIL != x)
          RBDeleteFixUp(x);

      delete y;
}

template<typename T>
void RedBlackTree<T>::RBDeleteFixUp(Node* x)
{   
    Node* y = NIL;
    Node* w = NIL;
    while(x != root && BLACK == x->color)
    {
       if(x == x->parent->left)
       {
            w = x->parent->right;
            if(NIL == w)
               continue;
            if(w->color == RED)
            {
               w->color = BLACK;
               x->parent->color = RED;
               LeftRotate(x->parent);
               w = x->parent->right;
            }
             if( NIL != w->left &&   BLACK == w->left->color && 
                NIL != w->right && BLACK == w->right->color)
             {
                w->color = RED;
                x = x->parent;
             }
            else 
            {
                if(NIL != w->right && BLACK == w->right->color)
                {
                   w->left->color = BLACK;
                   w->color = RED;
                   RightRotate(w);
                   w = x->parent->right;
                }
            
            
                w->color = x->parent->color;
                x->parent->color = BLACK;
                w->right->color = BLACK;
                LeftRotate(x->parent);
                x = root;
            }
            
       }

        else 
        { 
               w = x->parent->left;
               if(NIL == w)
                  continue;
               if(RED == w->color)
               {   
                   w->color = BLACK;
                   x->parent->color = RED;
                   RightRotate(x->parent);
                   y = x->parent->left;
               }
               if(NIL != w->left && BLACK == w->left->color &&
                   NIL != w->right && BLACK == w->right->color)
               {  
                   w->color = RED;
                   x = x->parent;
               }
           else 
           { 
             if(NIL != w->left && w->left->color == BLACK)
             {
               w->right->color = BLACK;
               w->color = RED;
               LeftRotate(w);
               w = x->parent->left;
             }
                   
               w->color = w->parent->color;
               w->parent->color = BLACK;
               w->left->color = BLACK;
               RightRotate(w->parent);
               x = root;
           }
        
        }
    }
    x->color = BLACK;
}

#endif
// stdafx.h : include file for standard system include files,
//  or project specific include files that are used frequently, but
//      are changed infrequently
//

#if !defined(AFX_STDAFX_H__5AFECD4B_C1BA_40D8_9CDA_150A0A3D20C6__INCLUDED_)
#define AFX_STDAFX_H__5AFECD4B_C1BA_40D8_9CDA_150A0A3D20C6__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


// TODO: reference additional headers your program requires here

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_STDAFX_H__5AFECD4B_C1BA_40D8_9CDA_150A0A3D20C6__INCLUDED_)
// RedBlackTree.cpp : Defines the entry point for the console application.
//主要参考了《算法导论》和博客http://www.cppblog.com/converse/archive/2006/10/07/13413.html
//红黑树的性质：
//1.每个结点或是红的或是黑的
//2.根结点是黑的
//3.每个叶结点（NULL）是黑的
//4.如果一个结点是红的，则它的两个儿子都是黑的
//5.对每个结点，从该结点到其他子孙结点的所有路径上包含相同数目的黑结点
//注意哨兵NIL和NULL不能混用，以及关于调整树时if...else的用法。

#include "stdafx.h"
#include <iostream>
#include <string>
#include "RedBlackTree_.h"


int main(int argc, char* argv[])
{
    RedBlackTree<int>rt;
    rt.RBInsert(5);
    rt.RBInsert(34);
    rt.RBInsert(456);
    rt.RBInsert(75);
    rt.RBInsert(42);
    rt.RBDelete(34);
    rt.PrintTree(rt.GetNode());
    return 0;
}

[珍惜生命远离CPP]

没有规定set必须得用树来实现 ......

[捕鲸叉]

set一般用红黑树实现，研究一下它，就明白了

[捕鲸叉]

set一般是用红黑树实现的，研究一下就知道了。