二叉树操作——前序、中序、后序、层序

先上树

一、前序、中序、后序、层序

#include <jni.h>
#include <string>
#include <android/log.h>
#include <queue>

#define JNI_TAG "JNI_TAG"
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, JNI_TAG, __VA_ARGS__)

using namespace std;

template <class T>
class TreeNode {
public:
    T data;
    TreeNode* left = NULL;
    TreeNode* right = NULL;
public:
    TreeNode(T data) {
        this->data = data;
    }
};

//    void doPre(char data) {
//        LOGE("%c", data);
//    }
    
//    template <class T>
//    void preOrderTraverse(TreeNode<T> *node, void doPre(T)) {
//        if (node == NULL) {
//            return;
 //       }
    
//        doPre(node->data);
    
//        TreeNode<T> *left = node->left; // 这里使用了 left，在定义时需要定义为 NULL
//        preOrderTraverse(left, doPre);
//        TreeNode<T> *right = node->right;
//        preOrderTraverse(right, doPre);
//    }

template <class T>
void doPre(TreeNode<T> *node) {
    LOGE("%c", node->data);
}

// 前序遍历
template <class T>
void preOrderTraverse(TreeNode<T> *node, void doPre(TreeNode<T> *node)) {
    if (node == NULL) {
        return;
    }
    
    doPre(node);
    
    TreeNode<T> *left = node->left; // 这里使用了 left，在定义时需要定义为 NULL
    preOrderTraverse(left, doPre);
    TreeNode<T> *right = node->right;
    preOrderTraverse(right, doPre);
}

// 中序遍历
template <class T>
void inorderTraverse(TreeNode<T> *pNode, void (*visit)(T)) {
    if (pNode == NULL) {
        return;
    }

    inorderTraverse(pNode->left, visit);

    visit(pNode->data);

    inorderTraverse(pNode->right, visit);
}

// 后序遍历
template <class T>
void postOrderTraverse(TreeNode<T> *pNode, void (*visit)(T)) {
    if (pNode == NULL) {
        return;
    }

    postOrderTraverse(pNode->left, visit);

    postOrderTraverse(pNode->right, visit);

    visit(pNode->data);
}

// 层序遍历
template<class T>
void levelOrderTraverse(TreeNode<T> *pNode, void (*visit)(TreeNode<T> *)) {
    if (pNode == NULL) {
        return;
    }

    queue<TreeNode<T> *> nodeQ;
    nodeQ.push(pNode);

    while (!nodeQ.empty()) {
        TreeNode<T> *front = nodeQ.front();
        nodeQ.pop();
        visit(front);

        if (front->left) {
            nodeQ.push(front->left);
        }
        if (front->right) {
            nodeQ.push(front->right);
        }
    }
}

extern "C" JNIEXPORT jstring JNICALL
Java_com_lql_dn_ndk_ndk_1day42_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {

    TreeNode<char> *A = new TreeNode<char>('A');
    TreeNode<char> *B = new TreeNode<char>('B');
    TreeNode<char> *C = new TreeNode<char>('C');
    TreeNode<char> *D = new TreeNode<char>('D');
    TreeNode<char> *E = new TreeNode<char>('E');
    TreeNode<char> *F = new TreeNode<char>('F');
    
    A->left = B;
    A->right = C;
    
    B->left = D;
    B->right = E;
    
    C->right = F;
    
    LOGE("=========前序遍历=========");
    preOrderTraverse(A, doPre);
    LOGE("=========中序遍历=========");
    inorderTraverse(A, doPre);
    LOGE("=========后序遍历=========");
    postOrderTraverse(A, doPre);
    LOGE("=========层序遍历=========");
    levelOrderTraverse(A, doPre);

    LOGE("=========树的深度=========");
    int treeDepth = getDepthTree(A); // 参考：二、获取树的深度
    LOGE("%d", treeDepth);

    LOGE("=========是否为平衡二叉树=========");
    bool balanceTree  = isBalanceTree(A); // 参考：三、是否为平衡二叉树
    LOGE("%d", balanceTree);
    
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}

运行一下，打印结果

二、获取树的深度

/**
 * 树的深度
 * @tparam T 泛型类型
 * @param pNode 头节点
 * @return 树的深度
 */
template <class T>
int getDepthTree(TreeNode<T> *pNode) {
    if (pNode == NULL) {
        return 0;
    }

    int leftDepth = getDepthTree(pNode->left);
    int rightDepth = getDepthTree(pNode->right);
    return max(leftDepth, rightDepth) + 1; // 之所以加 1，是因为如果只有双亲节点，那么左右节点深度为 0，此时树深为双亲节点自身深度 1
}

三、是否为平衡二叉树

/**
 * 是否为平衡二叉树
 * @tparam T 泛型类型
 * @param pNode 头节点
 * @return true：是；false：否
 */
template <class T>
bool isBalanceTree(TreeNode<T> *pNode) {
    if (pNode == NULL) {
        return true;
    }

    int leftDepth = getDepthTree(pNode->left);
    int rightDepth = getDepthTree(pNode->right);

    return abs(leftDepth - rightDepth) <= 1 && isBalanceTree(pNode->left) && isBalanceTree(pNode->right);
}