师兄面试总结编程部分解答之四

个人感觉树的问题大部分都是用递归的思想。

首先定义树节点结构体

typedef struct _treeNode
{
int val;
_treeNode* left;
_treeNode* right;
_treeNode (int value)
{
val = value;
left = NULL;
right = NULL;
}
}TreeNode,*TreeNodePtr;

构造搜索二叉树：

//根据输入内容构造二叉查找
TreeNodePtr constructTree()
{
int c;
TreeNodePtr parentNode,root,curNode;
std::cin>>c;
root = new TreeNode(c);
parentNode = root;
curNode = root;
while((std::cin>>c))
{
curNode = root;
while(curNode)
{
if (c < curNode->val)
{
parentNode = curNode;
curNode = curNode->left;
}else
{
parentNode = curNode;
curNode = curNode->right;
}
}
TreeNodePtr tmpNode = new TreeNode(c);
if(c < parentNode->val)
parentNode->left = tmpNode;
else
parentNode->right = tmpNode;
}
return root;
}

1、树的深度，广度遍历源代码

//使用堆栈
//深度优先遍历，非递归算法实现
//代码书写熟练程度远远不够，还要进行多次调试，说明思路不清晰
void DFS(TreeNodePtr root)
{
if(root == NULL)
return;
TreeNodePtr stack[MAX];
int top = 0;
TreeNodePtr cur = root;
stack[top++] = cur;
cur = cur->left;
while(top != 0 || cur != NULL)
{
while(cur != NULL)
{
stack[top++] = cur;
cur = cur->left;
}
if(top > 0)
{
cur = stack[--top];
std::cout<<cur->val<<" ";
cur = cur->right;
}
}
std::cout<<std::endl;
}
//使用队列
//广度优先遍历
void BFS(TreeNodePtr root)
{
if (root == NULL)
return;
TreeNodePtr queue[MAX];
int head = 0;
int tail = 0;
queue[head++] = root;
TreeNodePtr cur;
while(tail != head)
{
cur = queue[tail++];
std::cout<<cur->val<<" ";
if(cur->left)
queue[head++] = cur->left;
if(cur->right)
queue[head++] = cur->right;
}
std::cout<<std::endl;
}

2、二叉树镜像（剑指offer125页）

//将给定树，转化为其镜像，左右互换
void change(TreeNodePtr root)
{
if(root == NULL)
return;
TreeNodePtr tmp = root->left;
root->left = root->right;
root->right = tmp;
}
void TreeMirror(TreeNodePtr root)
{
//思路利用广度优先遍历，并分别互换子树
if(root == NULL)
return;
TreeNodePtr queue[MAX];
int head = 0;
int tail = 0;
queue[head++] = root;
TreeNodePtr cur;
while(tail != head)
{
cur = queue[tail++];
change(cur);
if(cur->left)
queue[head++] = cur->left;
if(cur->right)
queue[head++] = cur->right;
}
}
//二叉树镜像递归实现
void TreeMirror_recu(TreeNodePtr root)
{
if (root == NULL)
return;
TreeNodePtr tmp = root->left;
root->left = root->right;
root->right = tmp;
TreeMirror_recu(root->left);
TreeMirror_recu(root->right);
}

3、二叉树中某一值的路径（剑指offer 143页）

//在二叉树中找出和为某一值的所有路径
//找到路径还是比较简单的，关键是打印路径怎么去实现
bool isLeaf(TreeNodePtr root)
{
if (!root) return false;
if(root->left == NULL && root->right == NULL)
return true;
else
return false;
}
void findPath(TreeNodePtr root, int sum,TreeNodePtr stack[],int top)
{

if(root == NULL) return;
if(isLeaf(root) && root->val == sum)
{
std::cout<<"find a path: ";
for(int i = 0; i < top;i++)
{
std::cout<<stack[i]->val<<" ";
}
std::cout<<root->val;
std::cout<<std::endl;
return;
}
if( !isLeaf(root) && root->val < sum)
{
stack[top++] = root;
if (root->left)
findPath(root->left, sum - root->val,stack,top);
if(root->right)
findPath(root->right, sum - root->val,stack,top);
}
else
return;

}

4、二叉搜索树后序遍历序列（剑指offer 140页）

//后序遍历，这里的顺序是只根节点的遍历顺序，后序即为 左子树-右子树-根节点 顺序完成遍历
void LRD(TreeNodePtr root)
{
if (!root) return;
TreeNodePtr stack[MAX];
int record[MAX] = {0};
int top = 0;
TreeNodePtr cur = root;
while(top != 0 || cur != NULL)
{
while(cur != NULL)//左支深度遍历
{
stack[top] = cur;
record[top++] = 1;
cur = cur->left;
}
cur = stack[top-1];
if(cur->right == NULL || record[top - 1] == 2)//当前节点右子树为空，或已经二次遍历
{
std::cout<<cur->val<<" ";
top--;
cur = NULL;
}
else//遍历右子树
{
record[top - 1] = 2;
cur = cur->right;
}
}
}