#include <iostream>
#include <vector>
#include <stack>
#include <queue>

using namespace std;

typedef struct BSTreeNode{
    int num;
    BSTreeNode* leftChild;
    BSTreeNode* rightChild;

}*TreeNode;


TreeNode search(TreeNode root,int key)
{
    if (!root)
    {
        return NULL;
    }
    if (key==root->num)
    {
        return root;
    }
    if (key<root->num)
    {
        search(root->leftChild,key);
    }
    return search(root->rightChild,key);
}
//利用指针的指针进行改变树结构。
void insert_node(TreeNode* node,int num)
{
    if ((*node)==NULL)
    {
        (*node)=new BSTreeNode;
        (*node)->num=num;
        (*node)->leftChild=(*node)->rightChild=NULL;
    }
    else
    {
        if (num<(*node)->num)
        {
            insert_node(&(*node)->leftChild,num);
        }
        else if (num>(*node)->num)
        {
            insert_node(&(*node)->rightChild,num);
        }
        else
            cout<<" insert duplicated elements \n";
    }
}
//利用引用去改变整个树结构。
void insert_node2(TreeNode &root,int num)
{
    if (root==NULL)
    {
        root=new BSTreeNode;
        root->num=num;
        root->leftChild=root->rightChild=NULL;
    }
    else
    {
        if (num<root->num)
        {
            insert_node2(root->leftChild,num);
        }
        else if (num>root->num)
        {
            insert_node2(root->rightChild,num);
        }
        else
            cout<<" insert duplicated elements \n";
    }
}
//中序遍历输出树结果。
void inorder(TreeNode root)
{
    if (root!=NULL)
    {
        inorder(root->leftChild);
        cout<<root->num<<" ";
        inorder(root->rightChild);
    }
}
//非递归的中序遍历。
void inorderTraverse(TreeNode root)
{
    stack<TreeNode>sta;
    TreeNode p=root;
    while (p||sta.size())
    {
        if (p)
        {
            sta.push(p);
            p=p->leftChild;
        }
        else
        {
            p=sta.top();
            cout<<p->num<<" ";
            sta.pop();
            p=p->rightChild;
        }
    }
}
/*
题目：输入一个整数和棵二元树。
从树的根结点开始往下访问一直到叶所经过有形成条路径。打印出和与输入整数相等的所有路径。
*/
void findPath(TreeNode root,vector<int>&path,int current_sum,int expected_sum)
{
    //这个路径必须包括根节点，而且必须是连接的的线路。
    if (root==NULL||current_sum>expected_sum)//剪枝条件
    {
        return;
    }
    current_sum+=root->num;
    //path 存下数字路径
    path.push_back(root->num);
    bool is_leaf=(!root->leftChild)&&(!root->rightChild);
    if (is_leaf&&(expected_sum==current_sum))
    {
        //符合条件输出该情况树节点。
        vector<int>::iterator it;
        for (it=path.begin();it!=path.end();it++)
        {
            cout<<*it<<" ";
        }
        cout<<endl;
    }
    //类似于全排列算法的实现。先加入某个节点递归，然后在删除递归。
    if (root->leftChild)
    {
        findPath(root->leftChild,path,current_sum,expected_sum);
    }
    if (root->rightChild)
    {
        findPath(root->rightChild,path,current_sum,expected_sum);
    }
    current_sum-=root->num;
    path.pop_back();
}
//输入一颗二元查找树，将该转换为它的镜像即在转换后的二元查找树中，左子结点都大于右。递归方法简单实现
TreeNode traverseTree(TreeNode& root)
{
    if (root)
    {
        //递归逻辑一定清楚！！
        TreeNode left=root->leftChild;
        TreeNode right=root->rightChild;
        root->leftChild=traverseTree(right);
        root->rightChild=traverseTree(left);
    }
    return root;
}
/*
使用循环方式实现镜像的转换。
解法一：用递归。假设当前结点为root，只需交换该结点的左右子女，然后分别递归求解左子树和右子树即可。
解法二：用循环，需要一个辅助栈完成，每次取栈顶元素交换左右子女，然后将左右子女分别压入辅助栈，当栈中元素为空时，结束循环。
其实不论是递归也好，循环也好，都是利用栈的特性完成。
*/

TreeNode traverseTreeType2(TreeNode &root)
{
    if (root)
    {
        stack<TreeNode>sta;
        sta.push(root);
        while (sta.size())
        {
            TreeNode pNode=sta.top();
            TreeNode leftChild=pNode->leftChild;
            TreeNode rightChild=pNode->rightChild;
            sta.pop();
            if (leftChild)
            {
                sta.push(leftChild);
            }
            if (rightChild)
            {
                sta.push(rightChild);
            }
            pNode->leftChild=rightChild;
            pNode->rightChild=leftChild;
        }
    }
    return root;
}
//求树的深度递归实现。
int deepth(TreeNode root)
{
    int leftDeep=0,RightDeep=0;
    if (root==NULL)
    {
        return 0;
    }
    RightDeep= deepth(root->rightChild)+1;
    leftDeep=deepth(root->leftChild)+1;	
    return leftDeep>RightDeep? leftDeep:RightDeep;
}
/*
层次遍历树过程
创建一个队列q;
将根放入队列;
while(队列非空)
{
从队列取出一个元素并访问;
如果该元素有左子树就将它放入队列;
如果该元素有右子树就将它放入队列;
}
*/
void levelTravese(TreeNode root)
{
    queue<TreeNode>que;
    que.push(root);
    while (que.size())
    {
        TreeNode pNode=que.front();
        que.pop();
        cout<<pNode->num<<" ";
        if (pNode->leftChild)
        {
            que.push(pNode->leftChild);
        }
        if (pNode->rightChild)
        {
            que.push(pNode->rightChild);
        }
    }
}

int main()
{
    int a[]={10,5,12,4,7,6,11};
    TreeNode root=NULL;
    for (int i=0;i<7;i++)
    {
        //insert_node(&root,a[i]);
        insert_node2(root,a[i]);
    }
    cout<<"insert ending 中序遍历输出"<<endl;
    //inorder(root);
    inorderTraverse(root);
    cout<<endl;
    levelTravese(root);
    cout<<endl;
    vector<int>path;
    int current_sum=0;
    int expected_sum=28;
    findPath(root,path,current_sum,expected_sum);
    //traverseTree(root);
    traverseTreeType2(root);
    inorder(root);
    return 0;
}