io ti consiglierei un btree per quello che vorresti fare:
codice:
 
/// The tree node
typedef struct CTreeNode_t 
{ 
	int n;                           
	struct CTreeNode_t* left;
	struct CTreeNode_t* right;
} CTreeNode, *PCTreeNode;

/// The tree class
class CTree {
  private:
    PCTreeNode FRoot;
    void InternalDestroyCTree(PCTreeNode&);
    void InternalAdd(int, PCTreeNode&);
    void InternalShowInOrder(PCTreeNode);
    int InternalSearch(int, PCTreeNode);
  public:
    CTree()
    { 
    	FRoot = NULL;
    };
    virtual ~CTree() 
    { 
    	InternalDestroyCTree(FRoot); 
    };
    void Add(int n);
    void ShowInOrder();
    int Search(int n)
    {
    	return InternalSearch(n, FRoot);
    };
};

void CTree::InternalAdd(int n, PCTreeNode& ARoot)
{
     if (ARoot == NULL)
     {
         ARoot = new CTreeNode;
         ARoot->n = n;
         ARoot->left = NULL;
         ARoot->right = NULL;
     }
     else
     if (n <= ARoot->n) InternalAdd(n, ARoot->left);
     else
     if (n > ARoot->n) InternalAdd(n, ARoot->right);
}

void CTree::Add(int n)
{
     InternalAdd(n, FRoot);
}

void CTree::InternalShowInOrder(PCTreeNode P)
{
     if (P->left) InternalShowInOrder(P->left);
     std::cout << "\t" << P->n << "\n \t";
     if (P->right) InternalShowInOrder(P->right);
}

void CTree::ShowInOrder()
{
     std::cout << "Items sorted: ";
     InternalShowInOrder(FRoot);
     std::cout << std::endl;
}

void CTree::InternalDestroyCTree(PCTreeNode& P)
{
     if (P->left) InternalDestroyCTree(P->left);
     if (P->right) InternalDestroyCTree(P->right);
     delete P;
     P = NULL;
}