二叉树（一）

来源：互联网发布：SQL是面向问题的语言吗编辑：程序博客网时间：2024/04/27 23:02

二叉树

二叉树的概念：高度、深度、层次、完全二叉树、满二叉树
二叉树的性质：层次与结点的关系

二叉树的遍历：中序遍历、先序遍历、后序遍历、层次遍历、zigzag遍历

递归-中序遍历：时间复杂度和空间复杂度均为O(N)

void inorderTraversal(TreeNode *root, vector<int> &nodes){    if(root==NULL) return;    inorderTraversal(root->left,nodes);    nodes.push_back(root->val);    inorderTraversal(root->right,nodes);}vector<int> inorderTraversal(TreeNode *root){    vector<int> nodes;    inorderTraversal(root,nodes);    return nodes;}

递归-先序遍历：时间复杂度和空间复杂度均为O(N)

void preorderTraversal(TreeNode *root, vector<int> &nodes){    if(root==NULL) return;    nodes.push_back(root->val);    inorderTraversal(root->left,nodes);    inorderTraversal(root->right,nodes);}vector<int> preorderTraversal(TreeNode *root){    vector<int> nodes;    preorderTraversal(root,nodes);    return nodes;}

递归-后序遍历：时间复杂度和空间复杂度均为O(N)

void postorderTraversal(TreeNode *root, vector<int> &nodes){    if(root==NULL) return;    inorderTraversal(root->left,nodes);    inorderTraversal(root->right,nodes);    nodes.push_back(root->val);}vector<int> postorderTraversal(TreeNode *root){    vector<int> nodes;    postorderTraversal(root,nodes);    return nodes;}

递归-层次遍历

void buildOrder(TreeNode *root, vector<vector<int> > &nodes, int depth){    if(root==NULL) return;    if(node.size()==depth) nodes.push_back(vector<int> ());    nodes[depth].push_back(root->val);    buildOrder(root->left, nodes, depth+1);    buildOrder(root->right,nodes, depth+1);}vector<int> levelTraversal(TreeNode *root){    vector<vector<int> > nodes;    buildOrder(root,nodes,0);    return nodes;}

递归-zigzag遍历

void buildOrder(TreeNode *root, vector<vector<int> > &nodes, int depth){    if(root==NULL) return;    if(node.size()==depth) nodes.push_back(vector<int> ());    if(depth%2==0) nodes[depth].push_back(root->val);    else nodes[depth].insert(res[depth].begin(),root->val);    buildOrder(root->left, nodes, depth+1);    buildOrder(root->right,nodes, depth+1);}vector<int> levelTraversal(TreeNode *root){    vector<vector<int> > nodes;    buildOrder(root,nodes,0);    return nodes;}

迭代-中序遍历：时间复杂度和空间复杂度均为O(N)

vector<int> inorderTraversal(TreeNode *root){    stack<TreeNode*> temp;    TreeNode *cur=root;    vector<int> res;    while(cur || !temp.empty()){        if(cur){            temp.push(cur);            cur=cur->left;        }else{            cur=temp.top();            temp.pop();            res.push_back(cur->val);            cur=cur->right;        }    }    return res;}

迭代-先序遍历：时间复杂度和空间复杂度均为O(N)

vector<int> preorderTraversal(TreeNode *root){    stack<TreeNode*> temp;    TreeNode *cur=root;    vector<int> res;    while(cur||!temp.empty()){        if(cur){            temp.push(cur);            res.push_back(cur->val);            cur=cur->left;        }else{            cur=temp.top();            temp.pop();            cur=cur->right;        }    }    return res;}

迭代-后序遍历：时间复杂度和空间复杂度均为O(N)

vecto<int> postorderTraversal(TreeNode *root){    stack<TreeNode*> temp;    TreeNode *cur=root;    vector<int> res;    while(cur || !temp.empty()){        if(cur){            temp.push(cur);            res.insert(res.begin(),cur->val);            cur=cur->right;        }else{            cur=temp.top();            temp.pop();            cur=cur->left;        }    }    return res;}

迭代-层次遍历

vector<vector<int>> levelTraversal(TreeNode *root){    if(!root) return {};    vector<vector<int> > nodes;    vector<int> row;        queue<TreeNode*> q;    q.push(root);    int cnt=1;    while(!q.empty()){        if(q.front()->left) q.push(q.front()->left);        if(q.front()->right) q.push(q.front()->right);        row.push_back(q.front()->val);        q.pop();        if(--cnt==0){            nodes.push_back(row);            row.clear();            cnt=q.size();        }    }    return nodes;}

二叉树的计算：最大和最小深度、完全二叉树的结点个数、翻转二叉树

最大深度

int maxDepth(TreeNode* root){    if(!root) return 0;    return 1+max(maxDepth(root->left),maxDepth(root->right));}

最小深度

int minDepth(TreeNode* root){    if(!root) return 0;    if(!root->left && !root->right) return 1;    if(!root->left) return 1+minDepth(root->right);    if(!root->right) return 1+minDepth(root->left);    return 1+min(minDepth(root->left),minDepth(root->right));}

完全二叉树的结点

int CountCompleteTreeNodes(TreeNode* root){    if(!root) return 0;    int lheight=subtreeHeight(root->left);    int rheight=subtreeHeight(root->right);    if(lheight==rheight)    return (1<<lheight)+CountCompleteTreeNodes(root->right);    else return (1<<rheight)+CountCompleteTreeNodes(root->left);}int subtreeHeight(TreeNode *root){    if(root==NULL) return 0;    return 1+subtreeHeight(root->left);}

翻转二叉树

TreeNode* InvertBinaryTree(TreeNode * root){    if(!root) return root;    swap(root->left,root->right);    InvertBinaryTree(root->left);    InvertBinaryTree(root->right);    return root;}

二叉树的判断：等价二叉树、对称树、平衡树

等价二叉树

bool isIdentical(TreeNode* p,TreeNode* q){    if(!p && !q) return true;    else if(p && q)     return (p->val==q->val) && isIdentical(p->left,q->left) && isIdentical(p->right,q->right);    else return false;}

对称树

bool isSymmetrical(TreeNode* root){    if(!root) return true;    return judge(root->left,root->right);}bool judge(TreeNode * a, TreeNode *b){    if(!a && !b) return true;    if(!a && b || a&&!b) return false;    if(a->val!=b->val) return false;    return judge(a->left,b->left)&&judge(a->right,b->right);}

平衡二叉树

bool isBalanced(TreeNode* root){    return judgeBalance(root)!=-1;}int judgeBalance(TreeNode * root){    if(!root) return 0;    int lheight=judgeBalance(root->left);    if(lheight==-1) return -1;     int rheight=judgeBalance(root->right);    if(rheight==-1) return -1;    if(abs(lheight-rheight)>1) return -1;    return 1+max(judgeBalance(root->left),judgeBalance(root->right));}

0 0