2分木　　　左右回転

前提・実現したいこと

まず、5 8 7 13 1 20 11 -1の順番でデータを入力し、2分木を作ります。
(最後の-1は入力終了を示すための数値です）
その後、クエリとして
1 5 8 7 13 11 20 0 6 9 14 18 30 -1
を入力し、上述のデータ構造で格納されているデータ内に存在するかしないかを探索し，その数値が存在する場合には判定するまでに行ったデータ内数値との比較回数、その数値が存在しなかった場合には，存在しないと判定できるまでに行ったデータ内数値との比較回数にマイナスを掛けた値を返す関数を作成し，main 関数の通りに合計比較数を求めます。

次に、rotation関数内で指定されたポインタ（BinNode* rp）を根とする部分木を回転する際に，左側の子を回転後の部分木の根とする（つまり rp->left のノードを次の部分木の根）回転を右回転，逆に右側の子を回転後の部分木の根とする（rp->right のノードを次の部分木の根）回転を左回転とします．回転の基準となるノードは，ノードの数値で指定し，指定された数値のノードが存在する場合には，そのノードに対し指定された方向に回転をし，指定された数値のノードが存在しない場合には回転はしません．また，回転を行う際に，基準となるノードに，必要な子が存在しない場合（右回転の際に rp->left==NULL，左回転の際に rp->right==NULL）の場合にも何もしません．
【試す指定されたポインタ・回転】
(a)順番 Aで構築された二分探索木を 5の値を持つノードで右回転
(b)順番 Aで構築された二分探索木を 5の値を持つノードで左回転
(c)順番 Aで構築された二分探索木を 8の値を持つノードで右回転
(d)(a)で構築された二分探索木を 1の値を持つノードで左回

発生している問題・エラーメッセージ

【発生している問題】
direction==-1のとき(左回転)
探索回数の表示がされません。
(a)も探索回数が表示はされているものの条件が局所的すぎるので、
あまり汎用的ではないか考えています。
(a)
input data (n>=0) : if you complete data input, input negative values)
5 8 7 13 1 20 11 -1
Input query numbers and put negtive values at the end of the query
1 5 8 7 13 11 20 0 6 9 14 18 30 -1
Comparison number using BinTree: 40(7)
Input value of target node・・or quit, input negative value・
5
1
Comparison number using BinTree: 49
(b)
input data (n>=0) : if you complete data input, input negative values)
5 8 7 13 1 20 11 -1
Input query numbers and put negtive values at the end of the query
1 5 8 7 13 11 20 0 6 9 14 18 30 -1
Comparison number using BinTree: 40(7)
Input value of target node・・or quit, input negative value・
5
Input direction of rotation (-1: Left rotation, 1: right rotation)
-1
``C++
【ソースコード】
#include <iostream>
#include <vector>
#include <cstdlib>
#include <iomanip>
using namespace std;
class BinTree {
 private:
	class BinNode {
    	 public:
		    int idata;
        	BinNode* left, * right;
        	BinNode(int a = 0) { idata = a; left = right = 0; }
        	void printNode() { cout << idata << " "; } 
        	~BinNode() { printNode(); cout << " has been deleted..." << endl;}

	};
    BinNode* root;
    void  clearTree(BinNode* p); 
    void traverse(BinNode* rp);
    BinNode* addNode(BinNode* rp, BinNode* node);
    BinNode* delNode(BinNode* rp, int x);
	//------ For report no.5
	int searchNode(BinNode* rp, int x) const;	
	BinNode* rotation(BinNode* rp, int x,int direction);
 public:
    BinTree() { root = 0;}
    ~BinTree() { clear();}
    void clear() {
        clearTree(root);
        root = NULL;
	}
    void printTree() { traverse(root); }
    void insert(int x) {
	    BinNode* np = new BinNode(x);
        root = addNode(root, np);
	}
    void remove(int x) { root = delNode(root, x); }
	int treeSearch(int x) const { return searchNode(root,x);}
	void treeRotation(int x, int direction) { root=rotation(root, x, direction);}
};

//////////////////////////////////////////////////////////
BinTree::BinNode* BinTree::addNode(BinNode* rp, BinNode* node) {
	if (!rp) return node;
	if (!node) return rp;

	if (node->idata < rp->idata)
        rp->left = addNode(rp->left, node); // p.7
    else
        rp->right = addNode(rp->right, node);
    return rp;
}

void BinTree::traverse(BinNode* rp) { // pp.8-9
	if (!rp) return;  
    	traverse(rp->left);
    	rp->printNode();
    	traverse(rp->right);
}

BinTree::BinNode* BinTree::delNode(BinTree::BinNode* rp, int x) { 
    if (rp == NULL)
        return NULL;
    else if (x == rp->idata) { 
        BinNode* lf = rp->left;
        BinNode* rt = rp->right;
        delete rp;
        return addNode(rt, lf);
    }
    else {
        if (rp->idata > x)
            rp->left = delNode(rp->left, x);
        else
            rp->right = delNode(rp->right, x);
        return rp;
    }
}

void  BinTree::clearTree(BinTree::BinNode* rp) {
    if (rp != NULL) {
        clearTree(rp->right);
        clearTree(rp->left);
        delete rp;
    }
}

int BinTree::searchNode(BinNode* rp, int x) const{
	BinNode *head = rp;
	int count = 0;
	if (!head)
		return (-1) * count;
    while (head != NULL){
		if(head->idata==x){
		   count++;
		   return count;
		}
		else if (x < head->idata){ 
		   head = head->left;
		   count++;
	    }
        else{
           head = head->right;
		   count++;
		}
	}
	return (-1) * count;
}

BinTree::BinNode* BinTree::rotation(BinNode* rp, int x,int direction){
    BinNode *head = rp;
    if(direction==1){
        if(!head->left)
            return head;
        BinNode *p1;
        p1 = head->left;
        p1->right = head;
        p1->right->left = NULL;
        return p1;
    }
    else{
        if(!head->right)
            return head;
        BinNode *p2;
        p2 = head->right;
        p2->left = head;
        if(head->right->left)
            p2->left->right = head->right->left;
        return p2;
    }	
}

int main() {
	BinTree bt;
	vector<int> query;
	int n;

	//Input enrolled numbers (until negative value is input)
	cout<<"input data (n>=0) : if you complete data input, input negative values)"<<endl; 
	while(cin>>n && n>=0){
		bt.insert(n);
	}

	int nB=0;int fB=0;

	cout<<"Input query numbers and put negtive values at the end of the query"<<endl;
	while(cin>>n && n>=0){
		query.push_back(n);
		int b=bt.treeSearch(n);
		nB+=abs(b);if(b>0) fB++;
	}
			
	cout << "Comparison number using BinTree: " << nB << "("<< fB<<")"<<endl;
	
	//-----------------------------------------------------------
	int d;
	cout << "Input value of target node";
	cout << "（For quit, input negative value）" << endl;
	while(cin>>n && n>=0){
		cout<<"Input direction of rotation (-1: Left rotation, 1: right rotation) "<<endl;
		cin>>d;
		bt.treeRotation(n,d);
	
		nB=0;
		for(n=0;n<query.size();n++)
			nB+=abs(bt.treeSearch(query[n]));
		cout << "Comparison number using BinTree: " << nB << endl;
	}
	
	//---------------------------------------------------------
    
	return 0;
}