microsoft software test

give a sequence and each element is less than 2,000,000. there maybe exist reverse orde pair in the sequence . a reverse order pair is defined as a pair consisting of 2 elements: A and B, A appearing before B and A>B. Now what we should do is to find these reverse order pairs in the given sequence and the time complexity must be O(nlogn) or less.

hint: sorting and tree data structure can be used to solve the problem

 

my idea: use sorted binary tree to store the elements of the sequence and if there is no reverse pair in the sequence then no left subtree will exist. so what we should do is to count the depth of left subtree for every node in the sorted binary tree.

 

code:write a sorted binary tree and then traverse the tree in a depth-first way. for each node visited calculate the depth of left subtree of the node and count them all as total number of reverse order pairs. 

major function: findPair,ldepth

 #include <iostream> using namespace std; struct tree_node { tree_node * parent; tree_node * left; tree_node * right; int value; }; class Tree { private: tree_node * root; tree_node * cur; public: int depth(); int depth(tree_node * node); Tree():root(NULL),cur(NULL){} void insert(int a); int findPair(); int findPair(tree_node * node); int ldepth(tree_node * node); int ldepth_loop(tree_node * node); void insertBtree(int a); void insertBtree(tree_node *& node,int a); void display(int a); void pretraverse(tree_node * node); void posttraverse(tree_node * node); void middletraverse(tree_node * node); int findnode(int a); int findnode(tree_node * curnode,int a); int findfather(int a,int b); tree_node * findfather(tree_node * curnode,int a, int b); }; int Tree::findfather(int a , int b) { if(!findnode(root,a) || !findnode(root,b))return -1; tree_node * node = findfather(root,a,b); if(node != NULL) return node->value; else return -1; } tree_node * Tree::findfather(tree_node * curnode ,int a,int b) { if(curnode == NULL)return NULL; if(findnode(curnode->left,a) && findnode(curnode->left,b))return findfather(curnode->left,a,b); else if(findnode(curnode->right,a) && findnode(curnode->right,b))return findfather(curnode->right,a,b); else return curnode; } int Tree::findnode(int a) { return findnode(root,a); } int Tree::findnode(tree_node * curnode,int a) { if(curnode == NULL)return 0; if(curnode->value == a)return 1; return ( findnode(curnode->left,a)||findnode(curnode->right,a) ); } int Tree::depth() { depth(root); } int Tree::depth(tree_node * node) { if(node== NULL)return 0; int l = depth(node->left); int r = depth(node->right); return l>r?l+1:r+1; } void Tree::display(int i) { switch(i) { case 0: pretraverse(root); break; case 1: middletraverse(root); break; case 2: posttraverse(root); break; } } void Tree::pretraverse(tree_node * node) { if(node==NULL)return; cout<<node->value<<endl; pretraverse(node->left); pretraverse(node->right); } void Tree::posttraverse(tree_node * node) { if(node==NULL)return; pretraverse(node->left); pretraverse(node->right); cout<<node->value<<endl; } void Tree::middletraverse(tree_node * node) { if(node==NULL)return; pretraverse(node->left); cout<<node->value<<endl; pretraverse(node->right); } void Tree::insertBtree(int a) { insertBtree(root,a); } void Tree::insertBtree(tree_node *& node,int a ) { if(node == NULL){ tree_node * newNode = new tree_node; newNode->value = a; newNode->parent = newNode->left = newNode->right = NULL; node = newNode; return; } if(node->value >= a) { insertBtree(node->left,a); } else if(node->value < a) { insertBtree(node->right,a); } } int Tree::ldepth(tree_node * node) { if(node == NULL)return 0; if(node->left) { return ldepth(node->left) + 1; } else { return 0; } } int Tree::ldepth_loop(tree_node * node) { int a = 0; while(node->left) { ++a; node = node->left; } return a; } int Tree::findPair() { return findPair(root); } int Tree::findPair(tree_node * node) { if(node == NULL)return 0; int pair = depth(node->left); pair += findPair(node->left); pair += findPair(node->right); return pair; } void Tree::insert(int a) { tree_node * newNode = new tree_node; newNode->value = a; newNode->parent = newNode->left = newNode->right = NULL; if(root == NULL) { cur = root = newNode; } else { if(cur->left == NULL) { cur->left = newNode; } else if(cur->right == NULL) { cur->right = newNode; } else { cur = cur->left; cur->left = newNode; } } } int main() { int a[]={4,2,3,5,6}; Tree tree; for(int i = 0; i < 5;i++) { tree.insertBtree(a[i]); } cout<<"depth = "<<tree.depth()<<endl; cout<<"pair = "<<tree.findPair()<<endl; tree.display(0); cout<<"common father = "<<tree.findfather(6,6)<<endl; }