2019-06-25 树的遍历 递归非递归

struct TreeNode {
    TreeNode* left;
    TreeNode* right;
    int val;
    TreeNode(int x) {
        val = x;
        left = nullptr;
        right = nullptr;
    }
};

/*
 * 前序遍历 递归
 */

void preOrderRecursive(TreeNode* root) {
    if (!root) return;
    cout << root->val << ", ";
    preOrderRecursive(root->left);
    preOrderRecursive(root->right);
}


/*
 * 前序遍历 非递归
 */

void preOrderIterative(TreeNode* root) {
    if (!root) return;
    stack s;
    while (!s.empty() || root) {
        while (root) {
            cout << root->val << ", ";
            s.push(root);
            root = root->left;
        }

        if (!s.empty()) {
            TreeNode* node = s.top();
            s.pop();
            if (node->right) root = node->right;
        }
    }
}


/*
 * 中序遍历 递归
 */

void inOrderRecursive(TreeNode* root) {
    if (!root) return;
    inOrderRecursive(root->left);
    cout << root->val << ", ";
    inOrderRecursive(root->right);
}

/*
 * 中序遍历 非递归
 */

void inOrderIterative(TreeNode* root) {
    if (!root) return;
    stack s;
    while (!s.empty() || root) {
        while (root) {
            s.push(root);
            root = root->left;
        }

        if (!s.empty()) {
            TreeNode* node = s.top();
            s.pop();
            cout << node->val << ", ";
            if (node->right) root = node->right;
        }
    }
}

/*
 * 后续遍历 递归
 */

void postOrderRecursive(TreeNode* root) {
    if (!root) return;

    postOrderRecursive(root->left);
    postOrderRecursive(root->right);

    cout << root->val << ", ";
}


/*
 * 后续遍历 非递归
 */

void postOrderIterative(TreeNode* root) {
    if (!root) return;

    stack s;

    TreeNode* visited = nullptr;

    while (!s.empty() || root) {
        while (root) {
            s.push(root);
            root = root->left;
        }

        root = s.top();

        if (root->right == nullptr || root->right == visited) {
            cout << root->val << " ,";
            s.pop();

            visited = root;
            root = nullptr;
        } else {
            root = root->right;
        }

    }

}


/*
 * 层序遍历 递归
 */

int height(TreeNode* root) {
    if (!root) return 0;

    int left = 1 + height(root->left);
    int right = 1 + height(root->right);

    return left > right ? left : right;
}


void levelOrderRecursiveInternal(TreeNode* root, int level) {
    if (!root) return;
    if (level == 1) {
        cout << root->val << " ,";
    }

    levelOrderRecursiveInternal(root->left, level - 1);
    levelOrderRecursiveInternal(root->right, level - 1);
}


void levelOrderRecursive(TreeNode* root) {
    if (!root) return;

    int h = height(root);

    for (int i = 1; i <= h; i++) {
        levelOrderRecursiveInternal(root, i);
    }
}



/*
 * 层序遍历 非递归
 */


void levelOrderIterative(TreeNode* root) {
    if (!root) return;

    stack s;
    s.push(root);

    while (!s.empty()) {
        TreeNode* node = s.top();

        s.pop();
        cout << node->val << " ,";

        if (node->left) {
            s.push(node->left);
        }

        if (node->right) {
            s.push(node->right);
        }
    }


}


int main() {
    TreeNode* root = new TreeNode(3);
    root->left = new TreeNode(2);
    root->right = new TreeNode(4);

    root->left->left = new TreeNode(1);
    root->left->right = new TreeNode(5);

    root->right->right = new TreeNode(10);


    cout << endl << "***** pre order *****" << endl;
    preOrderRecursive(root);
    cout << endl << "*****" << endl;
    preOrderIterative(root);
    cout << endl << "*****" << endl;



    cout << endl << "***** in order *****" << endl;
    inOrderRecursive(root);
    cout << endl << "*****" << endl;
    inOrderIterative(root);
    cout << endl << "*****" << endl;



    cout << endl << "***** post order *****" << endl;
    postOrderRecursive(root);
    cout << endl << "*****" << endl;
    postOrderIterative(root);
    cout << endl << "*****" << endl;



    cout << endl << "***** level order *****" << endl;
    levelOrderRecursive(root);
    cout << endl << "*****" << endl;
    levelOrderIterative(root);
    cout << endl << "*****" << endl;
    
    // i = 3, j = 6 // a, 6
}