二叉树前序中序，后序中序，公共最近祖先的实现

 

二叉树前序中序，后序中序，公共最近祖先的实现

注释中详细介绍了算法，故不再赘述。

无论是前序还是后序，一个节点的左子树和右子树都是可以看做是分开的，有一定规律可循，故可用递归进行实现。

 

#include <iostream>
#include <cstring>
#include <vector>

using namespace std;

const int len = 12;

char pre[len] = "ABDEHCFIJGK";
char mid[len] = "DBHEAIFJCKG";

typedef struct _Node{
	char data;
	struct _Node *left;
	struct _Node *right;
}TreeNode, *Tree;

//  确定c在中序序列mid中的下标,假设树的各个节点的值各不相同
int position(char c) {
	return strchr(mid, c) - mid; 
}

/*  利用前序中序序列创建树
 *    i: 子树的前序序列字符串的首字符在pre[]中的下标
 *    j: 子树的中序序列字符串的首字符在mid[]中的下标
 *  len: 子树的字符串序列的长度
*/
void premidCreateTree(Tree &node, int i, int j, int len) {
	if(len <= 0) {
		node = NULL;
		return;
	}

	node = new TreeNode;
	node->data = pre[i];
	int m = position(pre[i]);
	// i+1 :该node节点的左子树前序序列字符串的首字符在pre[]中的下标
	// j   :该node节点的左子树中序序列字符串的首字符在mid[]中的下标
	// m-j :该node节点的左子树字符串序列的长度
	premidCreateTree(node->left, i+1, j, m-j);
	// i+(m-j)+1  :该node节点的右子树前序序列字符串的首字符在pre[]中的下标
	//       m+1  :该node节点的右子树中序序列字符串的首字符在mid[]中的下标
	// len-1-(m-j):该node节点的右子树字符串序列的长度
	premidCreateTree(node->right, i+(m-j)+1, m+1, len-1-(m-j));
}

//  前序遍历树
void PreTravelTree(Tree &node) {
	if(node) {
		cout << node->data;
		PreTravelTree(node->left);
		PreTravelTree(node->right);
	}
}

/*  利用后序中序序列创建树
  *        i: 子树的后序序列字符串的尾字符在post[]中的下标
  *        j: 子树的中序序列字符串的首字符在mid[]中的下标
  *      len: 子树的字符串序列的长度
  */
void PostMidCreateTree(PNode &pn, int i, int j, int len) {
	if(len <= 0) {
		node = NULL;
		return;
	}
  pn = new Node;
  pn->v = post[i];
  int m = Position(post[i]);
  PostMidCreateTree(pn->left, i-1-(len-1-(m-j)), j, m-j);//注意参数:m-j左子树的长度,len-1-(m-j)右子树的长度
  PostMidCreateTree(pn->right, i-1, m+1, len-1-(m-j));
}

//  寻找两个节点的最近公共祖先，但是遇到下面这种情况时，会有bug
//            A          寻找B,C的公共祖先，不能用此算法
//           / \
//          B   D
//         /
//        C
int findPNode(Tree root, char a, char b, TreeNode** PNode){
	if(root == NULL) return 0;
	if(root->data == a || root->data == b) {
		return 1;
	}
	int left = findPNode(root->left, a, b, PNode);
	if(left == 2) return 2;
	int right = findPNode(root->right, a, b, PNode);
	if(right == 2) return 2;
	if(left + right == 2) *PNode = root;
	return left + right;
}

// 二叉树是普通的二叉树，节点只有left/right，没有parent指针。
//
//                                           10
//                                         /    \     
//                                        6      14   
//                                       / \    /  \  
//                                      4   8  12   18
//                                     / \
//                                    3   5
//
// 基本思想：记录从根找到node1和node2的路径，然后再把它们的路径用类似的情况一来做分析，比如还是node1=3,node2=8这个case.
// 我们肯定可以从根节点开始找到3这个节点，同时记录下路径3,4,6,10，类似的我们也可以找到8,6,10。
// 我们把这样的信息存储到两个vector里面，把长的vector开始的多余节点3扔掉，从相同剩余长度开始比较，4!=8, 6==6,我们找到了我们的答案。

bool findParentByVector(TreeNode* root, char NData, vector<TreeNode*>& path) {
	if(root == NULL) return false;
	if(root->data != NData) {
		if(findParentByVector(root->left, NData, path)) {
			path.push_back(root);
			return true;
		} else {
			if(findParentByVector(root->right, NData, path)) {
				path.push_back(root);
				return true;
			} else {
				return false;
			}
		}
	} else {
		path.push_back(root);
		return true;
	}
}

TreeNode* findBstNode(TreeNode* root, char a, char b) {
	vector<TreeNode*> path1;
	vector<TreeNode*> path2;
	bool find = false;
	find |= findParentByVector(root, a, path1);
	find &= findParentByVector(root, b, path2);
	if(find) {
		int minSize = path1.size() > path2.size() ? path2.size() : path1.size();
		int th1 = path1.size() - minSize;
		int th2 = path2.size() - minSize;
		for(; th1 < (int)path1.size() && th2 < (int)path2.size(); th1++, th2++) {
			if(path1[th1] == path2[th2]) {
				return path1[th1];
			}
		}	
	}
	return NULL;
}

int main() {
	Tree root = NULL;
	premidCreateTree(root, 0, 0, strlen(mid));
	PreTravelTree(root);

	TreeNode *PNode = NULL;
	/*findPNode(root, 'D', 'B', &PNode);
	cout << endl << PNode->data << endl;*/

	PNode = findBstNode(root, 'I', 'G');
	cout << endl << PNode->data << endl;
	
	getchar();
	return 0;
}