剑指offer-树

原创 2016年08月30日 13:09:55
#include<iostream>
#include<algorithm>
#include<queue>
#include<stack>
using namespace std;
struct BinaryTreeNode
{
    int data;
    BinaryTreeNode *left;
    BinaryTreeNode *right;
};
BinaryTreeNode *InsertNode(BinaryTreeNode *left, BinaryTreeNode *right, int data){
    BinaryTreeNode *root=new BinaryTreeNode;
    root->left=left;
    root->right=right;
    root->data=data;
    return root;
}
//按层次打印二叉树   递归和非递归版本
void  printByLevel(BinaryTreeNode *root){
    queue<BinaryTreeNode *>  q;
    q.push(root);
    int i=1;
    while (!q.empty())
    {
        BinaryTreeNode *p = q.front();
        q.pop();
        cout <<i++<< " "<<p->data << endl;
        if (p->left)
            q.push(p->left);
        if (p->right)
            q.push(p->right);
    }
}
void  printByLevelTraverse(BinaryTreeNode *root,int i){
    cout << i << ":" << root->data << endl;
    if (root->left)
        printByLevelTraverse(root->left,2*i);
    if (root->right)
        printByLevelTraverse(root->right,2*i+1);
}
//先序遍历
void PreOrder(BinaryTreeNode *root){
    if (root)
    {
        cout << root->data << " ";
        PreOrder(root->left);
        PreOrder(root->right);
    }
}
void PreOrderTraverse(BinaryTreeNode *root){
   stack<BinaryTreeNode *> s;
    BinaryTreeNode *p=root;
    while (p||!s.empty())
    {
        while (p)
        {
            cout << p->data << " ";
            s.push(p);
            p=p->left;
        }
        if (!s.empty()){
            p = s.top();
            s.pop();
            p=p->right;
        }
    }
    cout<<endl;
}
//中序遍历
void MidOrder(BinaryTreeNode *root){
    if (root){
        MidOrder(root->left);
        cout << root->data << " ";
        MidOrder(root->right);
    }
}
//递归中序遍历
void MidOrderTraverse(BinaryTreeNode *root){
    stack<BinaryTreeNode *> s;
    BinaryTreeNode *p=root;
    while (p||!s.empty())
    {
        while (p)
        {
            s.push(p);
            p=p->left;
        }
        if (!s.empty()){
            p = s.top();
            s.pop();
            cout << p->data << " ";
            p=p->right;
        }
    }
    cout<<endl;
}
//后序遍历
void PostOrder(BinaryTreeNode *root){
    if (root){
        PostOrder(root->left);
        PostOrder(root->right);
        cout << root->data << " ";
    }
}
void PostOrderTraverse(BinaryTreeNode *root){
    BinaryTreeNode *p=root;
    BinaryTreeNode *q=NULL;
    stack<BinaryTreeNode *>  s;
    while (p||!s.empty())
    {
        while (p)
        {
            s.push(p);
            p=p->left;
        }
        if (!s.empty()){
            p = s.top();
            if (p->right == NULL||p->right==q){
                cout << p->data << " ";
                q=p;
                p=NULL;
                s.pop();
            }
            else{
                p=p->right;
            }
        }
    }
    cout<<endl;
}
//二叉树的深度
int DepthOfBinaryTree(BinaryTreeNode *root){
    if (root==NULL)
                return 0;
    int l=DepthOfBinaryTree(root->left);
    int r=DepthOfBinaryTree(root->right);
    return l>r?l+1:r+1;
}


//根据前序遍历和中序遍历重建二叉树
BinaryTreeNode *ConstructCore(int *startPreOrder, int *endPreOrder, int *startMidOrder, int *endMideOrder){
    int rootValue = startPreOrder[0];
    BinaryTreeNode *root = new BinaryTreeNode();
    root->data=rootValue;
    root->left=NULL;
    root->right=NULL;

    //递归结束条件
    if (startPreOrder == endPreOrder){
        if (startMidOrder==endMideOrder&&startPreOrder==startMidOrder)
                return root;
        else
            throw exception("inValid input");
    }
    //在中序遍历中找到根结点的值
    int *rootInOrder=startMidOrder;
    while (rootInOrder<=endMideOrder&&*rootInOrder!=rootValue)
    {
            ++rootInOrder;
    }
    int leftLength=rootInOrder-startMidOrder;
    int *leftPreOrderEnd=startPreOrder+leftLength;
    if (leftLength > 0){
        //构建左子树
        root->left = ConstructCore(startPreOrder+1,leftPreOrderEnd,startMidOrder,rootInOrder-1);
    }
    if (leftLength < endPreOrder - startMidOrder){
        //构建右子树
        root->right = ConstructCore(leftPreOrderEnd+1,endPreOrder,rootInOrder+1,endMideOrder);
    }
    return root;
}
BinaryTreeNode *Construct(int *preOrder, int *midOrder,int n){
    if (preOrder==NULL||midOrder==NULL||n<=0)
            return NULL;
    return ConstructCore(preOrder,preOrder+n-1,
                        midOrder,midOrder+n-1);
}
//打印二叉树中和为某一值的路径
void  PrintTreePathOfTarget(BinaryTreeNode *root, int sum, int target, vector<int> &pathVec)
{
    sum+=root->data;
    pathVec.push_back(root->data);
    bool isLeaf = root->left == NULL&& root->right == NULL;
    if (sum == target&&isLeaf)
    {
        for (auto c:pathVec)
            cout << c << " ";
        cout<<endl;
    }
    if (root->left){
        PrintTreePathOfTarget(root->left,sum,target,pathVec);
    }
    if (root->right)
    {
        PrintTreePathOfTarget(root->right,sum,target,pathVec);
    }
    pathVec.pop_back();
}

//二叉树的镜像
void MirrorOfTree(BinaryTreeNode *root){
    if (root==NULL)  return ;
    if (root->left==NULL&&root->right==NULL)
                return;
    BinaryTreeNode *p = root->left;
    root->left = root->right;
    root->right = p;
    if (root->left) 
        MirrorOfTree(root->left);
    if (root->right)
        MirrorOfTree(root->right);
}

//输入两颗二叉树A和B,判断B是不是A的子结构

bool isSubCore(BinaryTreeNode *A, BinaryTreeNode *B){
    if (A != NULL&&B != NULL){
        if (A->data == B->data){
            return isSubCore(A->left,B->left)&&isSubCore(A->right,B->right);
        }
    }
    if (A==NULL&&B==NULL)    return true;
    return false;
}
bool isSubTree(BinaryTreeNode *A, BinaryTreeNode *B)
{
    bool result=false;
    if (A->data==B->data)
        result = isSubCore(A,B);
    if (!result){
        result = isSubTree(A->left,B);
    }
    if (!result){
        result = isSubTree(A->right,B);
    }
}

int main(){
    //1.创建二叉树
    BinaryTreeNode *n1 = InsertNode(NULL,NULL,1);
    BinaryTreeNode *n2 = InsertNode(NULL,NULL,7);
    BinaryTreeNode *n3 = InsertNode(NULL, NULL, 8);
    BinaryTreeNode *n4 = InsertNode(NULL, NULL, 3);
    BinaryTreeNode *n5 = InsertNode(n1, n2, 4);
    BinaryTreeNode *n6 = InsertNode(n3, n4, 5);
    BinaryTreeNode *root = InsertNode(n5,n6,2);
    //2.按层次打印二叉树
    printByLevel(root);     //迭代
    printByLevelTraverse(root,1);//递归

    //3.先序遍历
    PreOrder(root);cout<<endl;
    PreOrderTraverse(root);

    //4.中序遍历
    MidOrder(root);cout<<endl;
    MidOrderTraverse(root);

    //5.后序遍历
    PostOrder(root);cout<<endl;
    PostOrderTraverse(root);

    //6.返回二叉树的深度
    cout << DepthOfBinaryTree(root)<<endl;


    //7.根据前序遍历和中序遍历重建二叉树
    //const int n=7;
    //int  preOrder[n] = {2,4,1,7,5,8,3};//已知前序遍历
    //int  midOrder[n] = {1,4,7,2,8,5,3};//已知中序遍历
    //Construct(preOrder,midOrder,n);

    //8.打印和为某一值的路径
    vector<int>  pathVec;
    PrintTreePathOfTarget(root,0,15,pathVec);

    //9.二叉树的镜像
//    MirrorOfTree(root);
//    printByLevel(root);

    //10.输入两颗二叉树A和B,判断B是不是A的子结构
    BinaryTreeNode *A=root;
    BinaryTreeNode *B=n5;
    bool flag= isSubTree(A,B);

    cout<<flag<<endl;
    system("pause");
    return 0;
}

【剑指offer】判断二叉树平衡

题目:输入一个二叉树的根节点,判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1,那么它就是一棵平衡二叉树。 剑指offer上给的第二种思路,用后序遍历真的是将递归发...
  • mmc_maodun
  • mmc_maodun
  • 2014年05月28日 08:22
  • 3063

剑指offer - 从上往下遍历二叉树

二叉树结点定义如下: struct BinaryTreeNode{ int value; BinaryTreeNode *pLeft; BinaryTreeNode *pRight; }; ...
  • zkp0601
  • zkp0601
  • 2015年10月01日 21:05
  • 443

剑指offer-判断树是否对称

分析 若根节点为空,返回TRUE; 不为空,判断左右两颗子树是否对称,即左子树的左孩子==右子树的右孩子 && 左子树的右孩子==右子树的左孩子。 递归判断函数中,注意递归出口。 代码public c...
  • Noshandow
  • Noshandow
  • 2017年04月01日 14:39
  • 188

剑指offer-归并排序

package Sai.XiaoMI; /** * 2) 归并排序 * * @author WangSai * */ public class Solution { /** * ...
  • VIP_WangSai
  • VIP_WangSai
  • 2017年06月01日 01:55
  • 144

剑指offer-快速排序

快速排序 package case99_QuickSort; public class QuickSort { // 快速排序 public static void main(String[]...
  • VIP_WangSai
  • VIP_WangSai
  • 2017年04月17日 17:41
  • 193

剑指offer-数组查找

题目描述在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。 输入描述: arr...
  • sinat_27612639
  • sinat_27612639
  • 2016年06月30日 10:08
  • 103

剑指Offer-变态跳台阶

变态跳台阶题目描述:   一只青蛙一次可以跳上1级台阶,也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。 解题思路:   仔细分析一下可以发现问题数组的第n个的结...
  • yannanying
  • yannanying
  • 2015年08月27日 21:31
  • 345

剑指Offer-字符串

替换空格题目描述请实现一个函数,将一个字符串中的空格替换成 “%20”。例如,当字符串为 We Are Happy. 则经过替换之后的字符串为 We%20Are%20Happy。 时间限制:1 秒 空...
  • surp2011
  • surp2011
  • 2016年12月27日 15:11
  • 235

剑指Offer-栈

剑指Offer-栈此处两道题为《剑指Offer》中举例让抽象问题具体化的21和22题,记录一下实现思路。题1,包含min函数的栈:定义栈的数据结构,请在该类型中实现一个能够得到栈最小元素的min函数思...
  • u011197534
  • u011197534
  • 2017年10月26日 15:43
  • 37

剑指offer-合并链表

输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减的规则。 非递归版本: /* struct ListNode { int val; struct List...
  • ccnnli
  • ccnnli
  • 2017年06月13日 14:28
  • 71
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:剑指offer-树
举报原因:
原因补充:

(最多只允许输入30个字)