rh_Jameson
rh_Jameson

程序员面试之算法备忘录（四） | 二叉树

前言

本文是题主准备面试时记录下的笔记整理而来，稍显粗陋，还请各位撸友勿喷哈！

Topic

  • 目录

    • 数组
    • 字符串
    • 链表
    • 二叉树
    • 排序

  • 目标

    • 熟练使用常用数据结构的基本操作
    • 加深对常用算法与技巧的理解
    • 面试

  • 参考

    • 《程序员面试金典》
    • 《剑指offer》
    • Leetcode
    • 《结构之法 --July》

二叉树篇

BTree ADT

  • 构建二叉树

    • TreeNode* createBTree(const string &s, int &i, int method);
    • 递归构建
      • 判断传入字符串参数是否为空
      • 遇“#”返回NULL
      • 遇其他字符，new一个二叉树结点
        a. data域是该字符
        b. 左孩子递归调用该函数，所传标志变量i加1
        c. 右孩子同b
    • 根据先序遍历序列构建二叉树（非递归）
      • 判空
      • 向左深搜构造，并将结点入栈
      • 重复执行B直至最左叶子节点的左指针
      • 逐一访问栈顶结点，向右深搜构造
      • 执行D时，检测是否有左结点，有则执行C
    • 根据后序遍历序列构建二叉树（非递归）
      • 同先序类似，顺序颠倒一下就可以了

  • 销毁二叉树

    • void delBTree(TreeNode* &p);

  • 先序遍历

    • void PreOrder(TreeNode* p, int method);
    • 迭代策略一：
      • 向左深搜直至BTree的最左叶子节点的l_child指针
      • 搜的同时，访问每一结点，并将结点入栈
      • 逐一获取栈中结点的右孩子，重复A，B
      • 每获取一个栈中结点，就将该结点弹出，直至栈空
    • 迭代策略二：
      • 将根节点入栈
      • 访问栈顶结点，并弹出栈顶结点
      • 将该栈顶结点的右孩子入栈,如果有的话
      • 将该栈顶结点的左孩子入栈,如果有的话
      • 重复BCD,直至栈空

  • 中序遍历

    • void InOrder(TreeNode* p, int method);
    • 迭代策略：
      • 向左深搜直至BTree的最左叶子节点的l_child指针
      • 搜的同时，将结点入栈
      • 逐一访问栈顶结点，并将栈顶结点的右孩子入栈
      • 重复ABC，直至栈空

  • 后序遍历

    • void PostOrder(TreeNode* p, int method);

    • 策略一：

      • 向左深搜直至BTree的最左叶子节点的l_child指针
      • 搜的同时，将结点入栈
      • 向右深搜栈顶元素的右孩子，直至最右叶子节点，
        • 每搜一个节点时，先重复AB
      • 将栈中元素逐个弹出，并访问之
      • 执行D时，需注意将p指针置空

    • 策略二：双栈法

      • 构建两个栈s1,s2
      • 将根节点入栈s1
      • 弹出s1的栈顶元素，并将该元素入栈s2
      • 将该元素的左孩子入栈，如果有的话
      • 将该元素的右孩子入栈，如果有的话
      • 重复CDE,直至栈s1空
      • 通过栈顶指针逐一遍历栈s2的元素

  • 层次遍历

    • void LayerOrder(TreeNode *p);

  • 查找值为et_value的二叉树结点

    • TreeNode* findNode(TreeNode *p, T et_value);

  • 获得二叉树的深度

    • int getBTDepth(TreeNode *p);

BST ADT

  • 构建二叉排序树
    • TreeNode* createBST(int v[], int start, int end);
  • 插入新结点
    • void insertNode(T &et_value, TreeNode* &p);
  • 删除指定结点
    • void removeNode(T et_value, TreeNode* &p);
  • 查找最大值
    • TreeNode* findMax(TreeNode *p);
  • 查找最小值
    • TreeNode* findMin(TreeNode *p);
  • 查找二叉树是否包含指定值的结点
    • bool contains(T et_value, TreeNode *p);

代码示例：

/*******************************************************************************
    @ Title:            实现二叉树基本操作   

    @ Description:      
                        1.C++实现二叉树模板类（递归）
                        2.C++实现二叉树模板类（非递归）
                        3.C++实现二叉排序树模板类（递归）
                        4.C++实现二叉排序树模板类（非递归）
    @ Conclusion:           
            1.构建二叉树（递归）：
                A.判断传入字符串参数是否为空
                B.遇“#”返回NULL
                C.遇其他字符，new一个二叉树结点
                    a.data域是该字符
                    b.左孩子递归调用该函数，所传标志变量i加1
                    c.右孩子同b
            
            2.先序遍历（非递归）：
                策略一：
                    A.向左深搜直至BTree的最左叶子节点的l_child指针
                    B.搜的同时，访问每一结点，并将结点入栈
                    C.逐一获取栈中结点的右孩子，重复A，B
                    D.每获取一个栈中结点，就将该结点弹出，直至栈空
                
                策略二：
                    A.将根节点入栈
                    B.访问栈顶结点，并弹出栈顶结点
                    C.将该栈顶结点的右孩子入栈,如果有的话
                    D.将该栈顶结点的左孩子入栈,如果有的话
                    E.重复BCD,直至栈空

            3.中序遍历（非递归）
                策略一：
                    A.向左深搜直至BTree的最左叶子节点的l_child指针
                    B.搜的同时，将结点入栈
                    C.逐一访问栈顶结点，并将栈顶结点的右孩子入栈
                    D.重复ABC，直至栈空

            4.后序遍历（非递归）
                策略一：
                    A.向左深搜直至BTree的最左叶子节点的l_child指针
                    B.搜的同时，将结点入栈
                    C.向右深搜栈顶元素的右孩子，直至最右叶子节点，
                        *、每搜一个节点时，先重复AB
                    D.将栈中元素逐个弹出，并访问之
                        E.执行D时，需注意将p指针置空
                
                策略二：双栈法
                    A.构建两个栈s1,s2
                    B.将根节点入栈s1
                    C.弹出s1的栈顶元素，并将该元素入栈s2
                    D.将该元素的左孩子入栈，如果有的话
                    E.将该元素的右孩子入栈，如果有的话
                    F.重复CDE,直至栈s1空
                    G.通过栈顶指针逐一遍历栈s2的元素

                        5.根据先序遍历序列构建二叉树（非递归）：
                            策略：
                                A.判空
                                B.向左深搜构造，并将结点入栈
                                C.重复执行B直至最左叶子节点的左指针
                                D.逐一访问栈顶结点，向右深搜构造
                                E.执行D时，检测是否有左结点，有则执行C

                        6.根据后序遍历序列构建二叉树（非递归）：
                            策略：
                                A.同5类似，顺序颠倒一下就可以了
                        
                        7.求二叉树深度（非递归实现）
                        8.前中后Morris遍历测试
                        9.测试BST相关操作 + 创建二叉排序树（递归 & 非递归）
                        10.二叉树findnode（非递归实现）
            11.BST insertNode非递归 & removeNode非递归


    @ Author:       rh_Jameson

    @ Date:         2014/12/22
**********************************************************************************/

#ifndef BINARYTREE_H
#define BINARYTREE_H

#include 
#include 
//#include 
#include
#include
#include
#include

using namespace std;

//二叉树类声明
templateclass BinaryTree;

//二叉树结点类
template
class TreeNode{
private:
    TreeNode *l_child,*r_child;
    T data;

public:
    TreeNode(){l_child = NULL;r_child = NULL;}
    TreeNode(T value,TreeNode *left = NULL,TreeNode *right = NULL){
        data = value;
        l_child = left;
        r_child = right;
    }
    friend class BinaryTree;     // 将二叉树类声明为友元类，方便访问该类私有变量
};

//二叉树类
template
class BinaryTree{
public:
    
    /* 二叉树常用操作 */

    // 构造函数
    BinaryTree(const string &s, int method);                
    // 拷贝构造函数
    //BinaryTree(BinaryTree &tree);
    // 析构函数
    ~BinaryTree();
    // 外部删除二叉树函数
    bool pubForDelBTree();      
    // 外部访问先序遍历
    void pubForPreOrder(int method);
    // 外部访问中序遍历
    void pubForInOrder(int method);
    // 外部访问后序遍历
    void pubForPostOrder(int method);
    // 外部访问层次遍历
    void pubForLayerOrder();
    // 外部查找值为et_value的二叉树结点
    void pubForFindNode(T et_value);
    // 获得二叉树的根
    TreeNode* getRoot();
    // 外部获得二叉树的深度
    int pubForGetBTDepth();

    /* 二叉排序树常用操作 */
    
    // 二叉排序树构造函数
    //BinaryTree(vector v);              
    BinaryTree(int v[]);                
    // 外部插入新结点
    void pubForInsertNode(T &et_value);
    // 外部删除指定结点
    void pubForRemoveNode(T et_value);
    // 外部查找最大值
    void pubForFindMax();
    // 外部查找最小值
    void pubForFindMin();
    // 外部查找二叉树是否包含指定值的结点
    bool pubForContains(T et_value);

private:
    TreeNode *root;                  //二叉树的根指针
    
    /* 二叉树常用操作 */

    //构建二叉树
    TreeNode* createBTree(const string &s, int &i, int method);
    //销毁二叉树
    void delBTree(TreeNode* &p);
    //内部先序遍历
    void PreOrder(TreeNode* p, int method);
    //内部中序遍历
    void InOrder(TreeNode* p, int method);
    //内部后序遍历
    void PostOrder(TreeNode* p, int method);
    //内部层次遍历
        void LayerOrder(TreeNode *p);  
    //内部查找值为et_value的二叉树结点
    TreeNode* findNode(TreeNode *p, T et_value);    
    //内部获得二叉树的深度
    int getBTDepth(TreeNode *p);

    /* 二叉排序树常用操作 */

        // 构建二叉排序树
    TreeNode* createBST(int v[], int start, int end);
    //TreeNode* createBST(int v[], int start, int end);
    // 插入新结点
    void insertNode(T &et_value, TreeNode* &p);
    // 删除指定结点
    void removeNode(T et_value, TreeNode* &p);
    // 查找最大值
    TreeNode* findMax(TreeNode *p);
    // 查找最小值
    TreeNode* findMin(TreeNode *p);
    // 查找二叉树是否包含指定值的结点
    bool contains(T et_value, TreeNode *p);
};

// 构造函数
template 
BinaryTree::BinaryTree(const string &s, int method){
    root = NULL;
    int i = 0;
    root = createBTree(s, i, method);
} 
//构建二叉树 
template 
TreeNode* BinaryTree::createBTree(const string &s, int &i,int method){
    switch(method){
        case 1:     //递归构建
        {
            TreeNode* BTree; 
            if(s.empty() ){
                return NULL;
            }

            if(s[i] == '#'){
                return NULL;
            }
            else{
                BTree = new TreeNode();
                BTree->data = s[i];
                BTree->l_child = createBTree(s,++i, method);
                BTree->r_child = createBTree(s,++i, method);
                return BTree;
            }
        }
        case 2:     //根据先序遍历序列构建（非递归）
        {
            if(s.empty()){
                return NULL;
            }
            TreeNode *BTNode = new TreeNode, *head = BTNode;
            BTNode->data = s[i++];
            stack* > SForBTree;
            while(BTNode || !SForBTree.empty() ){
                if(s[i] == '\0'){
                    break;
                }
                if(BTNode){             //向左深搜
                    SForBTree.push(BTNode);
                    if(s[i] == '#'){    //遇#置NULL
                        BTNode->l_child = NULL;
                    }
                    else{               //遇其他符号则新建结点
                        BTNode->l_child = new TreeNode();
                        BTNode->l_child->data = s[i];
                    }
                    BTNode = BTNode->l_child;
                }
                else{                   //反过来，向右深搜
                    BTNode = SForBTree.top();
                    SForBTree.pop();
                    if(s[i] == '#'){
                        BTNode->r_child = NULL;
                    }
                    else{
                        BTNode->r_child = new TreeNode();
                        BTNode->r_child->data = s[i];
                    }
                    BTNode = BTNode->r_child;
                }
                i++;
            }
            return head;
        }
        case 3:     //根据后序遍历序列构建二叉树
        {
            if(s.empty()){
                return NULL;
            }
            int cur = s.size() - 1;
            stack* > SForBTree;
            TreeNode *node = new TreeNode(), *head = node;
            node->data = s[cur--];
            while(node || !SForBTree.empty()){
                if(cur < 0){
                    break;
                }
                if(node){                   //向右深搜
                    SForBTree.push(node);
                    if(s[cur] == '#'){      //遇#置NULL
                        node->r_child = NULL;
                    }
                    else{                   //其他符号新建一个结点
                        node->r_child = new TreeNode();
                        node->r_child->data = s[cur];
                    }
                    node = node->r_child;
                }
                else{                       //反过来，向左深搜
                    node = SForBTree.top();
                    SForBTree.pop();
                    if(s[cur] == '#'){
                        node->l_child = NULL;
                    }
                    else{
                        node->l_child = new TreeNode();
                        node->l_child->data = s[cur];
                    }
                    node = node->l_child;
                }
                --cur;
            }
            return head;
        }
    }
}


//根据前序遍历序列和中序遍历序列构建二叉树
//失败，模板类惹的祸，只允许TreeNode,待另写一个cpp实现
/*template
TreeNode* createBTreeByPreAndInOrder(string &PreOrder, string &InOrder){
    if(PreOrder.empty() || InOrder.empty()) return NULL;
    TreeNode *tmp; 
    if(PreOrder.size()){
        tmp = new TreeNode();
        tmp->data = PreOrder[0];
        int idx = InOrder.find(PreOrder[0]);
        
        string PreLeft = PreOrder.substr(1, idx);
        string PreRight = PreOrder.substr(idx + 1);
        string InLeft = InOrder.substr(0, idx);
        string InRight = InOrder.substr(idx + 1);

        tmp->l_child = createBTreeByPreAndInOrder(PreLeft, InLeft);
        tmp->r_child = createBTreeByPreAndInOrder(PreRight,InRight);
    }
    return tmp;
}*/

//// 拷贝构造函数
//template 
//BinaryTree::BinaryTree(BinaryTree &tree){
//  
//} 

//析构函数
template 
BinaryTree::~BinaryTree(){
    delBTree(root);
}
//外部销毁二叉树
template 
bool BinaryTree::pubForDelBTree(){
    delBTree(root);
    if(root){
        return false;
    }
    return true;
            
}
//内部销毁二叉树
template
void BinaryTree::delBTree(TreeNode* &p){
    
    /* 递归销毁
     if(p != NULL){
        delBTree(p->l_child);
        delBTree(p->r_child);
        delete(p);
        p = NULL;
    }*/
    //待实现：自上而下层次遍历销毁
    //
    //非递归实现(自下而上后续遍历销毁)
    stack* > SForBTree;
    TreeNode *pre;
    while(p || !SForBTree.empty() ){
        if(p){
            SForBTree.push(p);
            p = p->l_child;
        }
        else{
            p = SForBTree.top();
            if(p->r_child && p->r_child != pre ){   //有右子树且右子树未被访问过
                p = p->r_child;
            }
            else{
                pre = p;
                SForBTree.pop();
                delete p;
                p = NULL;           //!!!须置空，否则陷入死循环
                                    //反复出栈 / 入栈
            }
        }
    }
}

//外部访问先序遍历
template
void BinaryTree::pubForPreOrder(int method){
    if(!root){
        cout << "空二叉树！" << endl;
    }
    PreOrder(root, method);
}
//内部访问先序遍历
template
void BinaryTree::PreOrder(TreeNode* p, int method){
    switch(method){
        case 1:     //递归形式
            if(p != NULL){
                cout << p->data << "\t";
                PreOrder(p->l_child, method);
                PreOrder(p->r_child, method);
            }
            break;
        case 2:     //栈的实现形式
            {   
                stack* > SForBTree;
                while(p != NULL || !SForBTree.empty() ){
                    if(p != NULL){
                        cout << p->data << "\t";
                        SForBTree.push(p);
                        p = p->l_child;
                    }
                    else{
                        p = SForBTree.top();
                        SForBTree.pop();
                        p = p->r_child;
                    }
                }
                break;
            }
        case 3:     //栈实现形式二
            {   
                stack* > SForBTree;
                if(p != NULL)
                    SForBTree.push(p);
                while( !SForBTree.empty() ){
                    p = SForBTree.top();
                    cout << p->data << "\t";
                    SForBTree.pop();

                    if(p->r_child){
                        SForBTree.push(p->r_child);
                    }
                    if(p->l_child){
                        SForBTree.push(p->l_child);
                    }
                }
                break;
            }
            case 4:     //Morris遍历
            {
            TreeNode *cur = p, *pre;
            while(cur){
                if(!cur->l_child){      //左孩子为空时，输出当前结点，cur指向其右孩子
                    cout << cur->data << "\t";
                    cur = cur->r_child;
                }
                else{                   //左孩子不为空时
                    pre = cur->l_child;
                    //找该结点的中序遍历序列的前驱结点
                    while(pre->r_child != NULL && pre->r_child != cur){     
                        pre = pre->r_child;
                    }
                    //前驱结点的右孩子指向当前结点，并输出当前节点，cur指向其左孩子
                    if(pre->r_child == NULL){   
                        pre->r_child = cur;
                        cout << cur->data << "\t";  //与中序遍历唯一的不同！
                        cur = cur->l_child;
                    }
                    //将前驱结点右孩子指向当前结点的连接断开，cur指向其右孩子
                    else{
                        pre->r_child = NULL;
                        cur = cur->r_child;
                    }
                }
            }
            break;
        }
    }
}

//外部访问中序遍历
template
void BinaryTree::pubForInOrder(int method){
    if(!root){
        cout << "空二叉树" << endl;
    }
    InOrder(root, method);
}
//内部访问中序遍历
template
void BinaryTree::InOrder(TreeNode* p, int method){
    switch(method){
        case 1:     //递归形式
        {   if(p != NULL){
                InOrder(p->l_child, method);
                cout << p->data << "\t";                
                InOrder(p->r_child, method);
            }
            break;
        }
        case 2:     //栈的实现形式
        {
            stack* > SForBTree;
            while(p != NULL || !SForBTree.empty() ){
                if(p != NULL){
                    SForBTree.push(p);
                    p = p->l_child;
                }
                else{
                    p = SForBTree.top();
                    cout << p->data << "\t";
                    SForBTree.pop();
                    p = p->r_child;
                }
            }
            break;
        }
        case 3:     //morris遍历
        {
            TreeNode *cur = p, *pre;
            while(cur){
                if(cur->l_child == NULL){
                    cout << cur->data << "\t";
                    cur = cur->r_child;
                }
                else{
                    pre = cur->l_child;
                    while(pre->r_child != NULL && pre->r_child != cur){
                        pre = pre->r_child;
                    }
                    if(pre->r_child == NULL){
                        pre->r_child = cur;
                        cur = cur->l_child;
                    }
                    else{
                        pre->r_child = NULL;
                        cout << cur->data << "\t";      //与前序遍历代码的不同！
                        cur = cur->r_child;
                    }
                }
            }
            break;
        }
    }
    
}

//外部访问后序遍历
template
void BinaryTree::pubForPostOrder(int method){
    if(!root){
        cout << "空二叉树！" << endl;
    }
    PostOrder(root, method);
}
//内部访问后序遍历
template
void BinaryTree::PostOrder(TreeNode *p, int method){
    switch(method){
        case 1:     //递归形式实现
            if(p != NULL){
                PostOrder(p->l_child, method);
                PostOrder(p->r_child, method);
                cout << p->data << "\t";
            }
            break;

        case 2:     //栈形式实现，该代码应该可以转作非递归销毁二叉树
        {
            stack* > SForBTree;
            TreeNode *pre;
            while(p || !SForBTree.empty() ){
                if(p){
                    SForBTree.push(p);
                    p = p->l_child;
                }
                else{
                    p = SForBTree.top();
                    if(p->r_child && p->r_child != pre ){   //有右子树且右子树未被访问过
                        p = p->r_child;
                    }
                    else{
                        cout << p->data << "\t";    
                        pre = p;
                        SForBTree.pop();
                        p = NULL;           //!!!须置空，否则陷入死循环
                                            //反复出栈 / 入栈
                    }
                }
            }
            break;
        }
        case 3:     //双栈形式实现
        {
            stack* > s1, s2;
            if(p != NULL)   s1.push(p);
            while(!s1.empty()){
                p = s1.top();
                s1.pop();
                s2.push(p);

                if(p->l_child){
                    s1.push(p->l_child);
                }
                if(p->r_child){
                    s1.push(p->r_child);
                }
            }
            while(!s2.empty()){
                p = s2.top();
                cout << p->data << "\t";
                s2.pop();
            }
            break;
        }
        case 4:     //morris遍历
        {
            TreeNode *cur = p, *pre;
            while(cur != NULL){
                if(cur->l_child == NULL){
                    cur = cur->r_child;
                }
                else{
                    pre = cur->l_child;
                    while(pre->r_child != NULL && pre->r_child != cur){
                        pre = pre->r_child;
                    }
                    if(pre->r_child == NULL){
                        pre->r_child = cur;
                        cur = cur->l_child;
                    }
                    else{
                        //printReverse(cur->l_child, pre);
                        pre->r_child = NULL;
                        cur = cur->r_child;
                    }
                }
            }
            break;
        }
    }
}
/*Morris 后续遍历相关函数
 * template
void reverse(TreeNode *from, TreeNode *to){
    if(from = to){
        return;
    }
    TreeNode  =
}
template
void printReverse(TreeNode *from, TreeNode *to){
    TreeNode *p = to;
    reverse(from, to);
    while(true){
        cout << p->data << "\t";
        if(p == from){
            break;
        }
        p = p->r_child;
    }
    reverse(to, from); 
}*/

//外部查找值为et_value的二叉树结点
template
void BinaryTree::pubForFindNode(T et_value){
    TreeNode *res = findNode(root, et_value);
    if(res == NULL){
        cout << "找不到相应结点" << endl;
    }
    else{
        cout << "找到该结点，该结点值为:" << res->data << endl;
    }
    
}
//查找值为et_value的二叉树结点
template
TreeNode* BinaryTree::findNode(TreeNode *p, T et_value){
    //递归实现
/*  if(p == NULL){
        return NULL;
    }
    if(p->data == et_value){
        return p;
    }   
    TreeNode *tmp = findNode(p->l_child, et_value);
    if(tmp != NULL){
        return tmp;
    }
    else{
        return findNode(p->r_child, et_value);
    }
*/
    //非递归实现
    stack*> s;
    while(p != NULL || !s.empty()){
        if(p != NULL){
            s.push(p);
            p = p->l_child;
        }
        else{
            p = s.top();
            s.pop();
            if(p->data == et_value) break;
            p = p->r_child;
        }
    }
    return p;
}

//外部获得二叉树的深度
template
int BinaryTree::pubForGetBTDepth(){
    return getBTDepth(root);
}
//获得二叉树的深度
template
int BinaryTree::getBTDepth(TreeNode *p){
    /* 递归实现1 
    int depth = 0;
    if(p != NULL){
        int l_child_depth = getBTDepth(p->l_child);
        int r_child_depth = getBTDepth(p->r_child);
        depth =  (l_child_depth >= r_child_depth) ? (l_child_depth + 1) : (r_child_depth + 1);
        //depth = 1 + (l_child_depth >= r_child_depth ? l_child_depth : r_child_depth);
    }
    return depth;   
    */
    /* 递归实现2 
    if(p == NULL) return 0;
    return 1 + max(getBTDepth(p->l_child), getBTDepth(p->r_child));
    */
    //非递归实现
/*    int depth = 0, maxDepth = 0;
    stack*> *s = new stack*>();
    while(p != NULL || !s->empty()){
        if(p != NULL){
            s->push(p);
            ++depth;
            p = p->l_child;
        }
        else{
            p = s->top();
            s->pop();
            p = p->r_child;
            if(p == NULL){
                if(depth > maxDepth){
                    maxDepth = depth;
                }   
                depth--;
            }
        }
    }
    return maxDepth - 1;
*/
    /* 双栈形式 
    if (p == NULL) return 0;
    stack *> gray;
    stack depth;
    int maxDepth = 0;

    gray.push(p);
    depth.push(1);
    while (!gray.empty()) {
        TreeNode *tmp = gray.top();
        int num = depth.top();
        gray.pop();
        depth.pop();
        if (tmp->l_child == NULL && tmp->r_child == NULL) {
            maxDepth = num > maxDepth ? num : maxDepth;
        }
        else {
            if (tmp->l_child != NULL) {
                gray.push(tmp->l_child);
                depth.push(num + 1);
            }
            if (tmp->r_child != NULL) {
                gray.push(tmp->r_child);
                depth.push(num + 1);
            }
        }
    }
    return maxDepth;
    */

    /* 队列层次遍历实现 
    int height = 0,rowCount = 1;
    if(root == NULL){
        return 0;
    }
    queue*> queue;
    queue.push(p);
    while(!queue.empty()){
        TreeNode *node = queue.front();
        queue.pop();
        //一层的元素个数减1，一层遍历完高度加1
        rowCount --;
        if(node->l_child){
            queue.push(node->l_child);
        }
        if(node->r_child){
            queue.push(node->r_child);
        }
        //一层遍历完
        if(rowCount == 0){
            //高度加1
            height++;
            //下一层元素个数
            rowCount = queue.size();
        }
    }
    return height;
    */
    /* 层次遍历树的层数,NULL为每一层节点的分割标志 */
    if(p == NULL)return 0;
    int res = 0;
    queue*> Q;
    Q.push(p);
    Q.push(NULL);
    while(Q.empty() == false)
    {
        TreeNode *p = Q.front();
        Q.pop();
        if(p != NULL)
        {
            if(p->l_child)Q.push(p->l_child);
            if(p->r_child)Q.push(p->r_child);
        }
        else
        {
            res++;
            if(Q.empty() == false)Q.push(NULL);
        }
    }
    return res;
}

//外部访问层次遍历
template
void  BinaryTree::pubForLayerOrder(){
    LayerOrder(root);
}
//内部层次遍历
template
void  BinaryTree::LayerOrder(TreeNode *p){
    if(p == NULL){
        cout << "空树！" << endl;
        return;
    }
    queue *> queueTreeNode;
    queueTreeNode.push(p);
    while(queueTreeNode.size() ){
        TreeNode *tmp = queueTreeNode.front();
        queueTreeNode.pop();
        cout << tmp->data << "\t";

        if(tmp->l_child != NULL){
            queueTreeNode.push(tmp->l_child);
        }
        if(tmp->r_child != NULL){
            queueTreeNode.push(tmp->r_child);
        }
    }
    /*deque双向队列版
    deque *> dequeTreeNode;
    dequeTreeNode.push_back(p);
    while(dequeTreeNode.size() ){
        TreeNode *tmp = dequeTreeNode.front();
        dequeTreeNode.pop_front();
        cout << tmp->data << "\t";

        if(tmp->l_child != NULL){
            dequeTreeNode.push_back(tmp->l_child);
        }
        if(tmp->r_child != NULL){
            dequeTreeNode.push_back(tmp->r_child);
        }
    }*/
}

//获得二叉树的根
template
TreeNode* BinaryTree::getRoot(){
    return root;
}


/* 二叉排序树常用操作 */

// 二叉排序树构造函数
template
BinaryTree::BinaryTree(int v[]){
    //vector vv(v, v + sizeof(v)/sizeof(v[0]));
    /*vector vv(v, v + 10);
    if(!vv.size()){
        cout << "生成失败，原因：空数组" << "\t";
        return;
    }
    sort(vv.begin(), vv.end());
    */
    sort(v, v + 9);
    /*if(sizeof(v) / sizeof(int)){
        cout << "生成失败，原因：空数组" << "\t";
        return;
    }*/

    root = createBST(v, 0, 9 - 1);
}
 // 构建二叉排序树
template
TreeNode* BinaryTree::createBST(int sorted_Vec[],int start,int end){    
    //递归实现
    if(end < start){
        return NULL;
    }
    int mid = (start + end) / 2;
    TreeNode *node = new TreeNode();
    node->data = sorted_Vec[mid];
    node->l_child = createBST(sorted_Vec, start, mid - 1);
    node->r_child = createBST(sorted_Vec, mid + 1, end);
    return node;
    
    //非递归实现
/*失败，每个结点的start和end都需记住，该模板无相应属性
 * 为避免大量修改代码，放弃实现～～
 *  mid = (start + end) / 2;
    stack* > s = new stack* >();
    stack mid_s = new stack();
    TreeNode *node = new TreeNode();
    mid_s.push(end);
    while(mid >= 0 || !s.empty()){
        if(mid >= 0){
            node = new TreeNode();
            node->data = sorted_Vec[mid];
            mid_s.push(mid);
            s.push(node);
            node = node->l_child;
            mid = (0 + mid - 1) / 2;
        }
        else{
            mid = mid_s.top();
            node = s.top();
            mid_s.pop();
            s.pop();
            
        }
    }
*/
}


// 外部插入新结点
template
void BinaryTree::pubForInsertNode(T &et_value){
    insertNode(et_value, root);
}
// 插入新结点
template
void BinaryTree::insertNode(T &et_value, TreeNode* &p){
    //递归实现
/*  if(p == NULL){
        p = new TreeNode();
        p->data = et_value;
    }
    else if(et_value < p->data){
        insertNode(et_value, p->l_child);
    }
    else if(et_value > p->data){
        insertNode(et_value, p->r_child);
    }
    else    //相等（重复）则不做任何操作
        ;
    */
    //非递归实现
    TreeNode *cur = p, *parent = NULL, *newNode = new TreeNode();
    newNode->data = et_value;
    if(p == NULL){              //二叉树为空的情况
        p = newNode;
        return;
    }           
    while(true){
        if(cur == NULL){
            if(et_value < parent->data)         //插入到叶子节点的左孩子
                parent->l_child = newNode;
            else
                parent->r_child = newNode;
            return;
        }
        parent = cur;
        if(et_value < cur->data)
            cur = cur->l_child;
        else if(et_value > cur->data)
            cur = cur->r_child;
        else
            return;     //重复，不插入，直接退出
    }
}

// 外部删除指定结点
template
void BinaryTree::pubForRemoveNode(T et_value){
    removeNode(et_value, root);
}
// 删除指定结点
template
void BinaryTree::removeNode(T et_value, TreeNode * &p){
    //递归实现
/*  if(p == NULL){
        return;     //该值未找到，停止
    }
    if(et_value < p->data){
        removeNode(et_value, p->l_child);
    }
    else if(et_value > p->data){
        removeNode(et_value, p->r_child);
    }
    else if(p->l_child != NULL && p->r_child != NULL){      //待删结点有两个孩子的情况
        p->data = findMin(p->r_child)->data;        //需琢磨另一种写法
        removeNode(p->data, p->r_child);
    }
    else{       //无孩子或有一个孩子情况
        TreeNode *tmp = p;
        p = (p->l_child != NULL) ? p->l_child : p->r_child;
        delete tmp;
    }
*/

    //非递归实现 
/*  TreeNode *cur = p, *pre, *tmp, *child;
    if(p->data == et_value && !p->l_child && !p->r_child){  //只有一个节点的情况
        p = NULL;
        return;
    }
    while(true){        
        if(cur == NULL) break;
        if(et_value < cur->data){
            pre = cur;
            cur = cur->l_child;
        }else if(et_value > cur->data){ 
            pre = cur;
            cur = cur->r_child;
        }else if(cur->l_child != NULL && cur->r_child != NULL){     //待删结点有两个孩子的情况
            tmp = findMin(cur->r_child); 
            cur->data = tmp->data;
            child = tmp->r_child;           //暂存其右孩子
            pre = cur->r_child;
            while(pre->l_child != tmp)      //找倒数第二小的结点
                pre = pre->l_child;
            pre->l_child = child;
            delete tmp;
            break;
        }
        else{       //无孩子或有一个孩子情况
            tmp = cur;
            cur = (cur->l_child != NULL) ? cur->l_child : cur->r_child;
            (pre->l_child == tmp) ? pre->l_child = cur : pre->r_child = cur;
            delete tmp;
            break;
        }
    }
*/
    //非递归实现 
    TreeNode *cur = p, *pre, *tmp, *child;
    if(p->data == et_value && !p->l_child && !p->r_child){  //只有一个节点的情况
        p = NULL;
        return;
    }
    while(true){        
        if(cur == NULL) break;      //找不到或BST为空
        if(et_value < cur->data){
            pre = cur;
            cur = cur->l_child;
        }
        else if(et_value > cur->data){  
            pre = cur;
            cur = cur->r_child;
        }
        else{       
            if(cur->l_child != NULL && cur->r_child != NULL){   //待删结点有两个孩子的情况
                tmp = findMin(cur->r_child); 
                cur->data = tmp->data;
                child = tmp->r_child;           //暂存其右孩子
                pre = cur->r_child;
                while(pre->l_child != tmp)  pre = pre->l_child; //找倒数第二小的结点 
                pre->l_child = child;
            }
            else{       //无孩子或有一个孩子情况
                tmp = cur;
                cur = (cur->l_child != NULL) ? cur->l_child : cur->r_child;
                (pre->l_child == tmp) ? pre->l_child = cur : pre->r_child = cur;

            }
            delete tmp;
            break;
        }
    }
}

// 外部查找最大值
template
void BinaryTree::pubForFindMax(){
    cout << "该二叉树的最大值为：" << findMax(root)->data << endl;
}
// 查找最大值
template
TreeNode* BinaryTree::findMax(TreeNode *p){
    /* 递归实现 */
/*  if(p == NULL){
        return NULL;
    }
    if(p->r_child == NULL){
        return p;
    }
    return findMax(p->r_child);
*/  
    /* 非递归实现 */
/*  while(p != NULL){
        if(p->r_child == NULL){
            return p;
        }
        p = p->r_child;
    }
    return NULL; 
*/
    /* 非递归实现2 */
    if(p != NULL){
        while(p->r_child != NULL){
            p = p->r_child;
        }
    }
    return p;
    
}

// 外部查找最小值
template
void BinaryTree::pubForFindMin(){
    cout << "该二叉树的最小值为：" << findMin(root)->data << endl;
}
// 查找最小值
template
TreeNode* BinaryTree::findMin(TreeNode *p){
    /* 递归实现 */
/*  if(p == NULL){
        return NULL;
    }
    //if(p->l_child == NULL || *((unsigned int *)p->l_child) == 0xFEEEFEEE ){
    if(p->l_child == NULL){
        p->l_child = NULL;
        return p;
    }
    return findMin(p->l_child);
*/
    /* 非递归实现 
    while(p != NULL){
        if(p->l_child == NULL){
            return p;
        }
        p = p->l_child;
    }
    return NULL; 
*/
    /* 非递归实现2 */
    if(p != NULL){
        while(p->l_child != NULL){
            p = p->l_child;
        }
    }
    return p;
}

// 外部查找二叉树是否包含指定值的结点
template
bool BinaryTree::pubForContains(T et_value){
    return contains(et_value, root);
}
// 查找二叉树是否包含指定值的结点
template
bool BinaryTree::contains(T et_value, TreeNode *p){
    //递归实现
/*  if(p == NULL){
        return false;
    }
    if(et_value < p->data){
        contains(et_value, p->l_child);
    }
    else if(et_value > p->data){
        contains(et_value, p->r_child);
    }
    else{
        return true;
    }
*/
    //非递归实现
    while(p != NULL){
        if(et_value < p->data)
            p = p->l_child;
        else if(et_value > p->data)
            p = p->r_child;
        else
            return true;
    }
    return false;

}

#endif

你可能感兴趣的:(程序员面试之算法备忘录（四） | 二叉树)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 2022-04-18 Apbenz
    语重心长的和我说，不要老是说不行，人至而立之年危机四伏，内在的，外在的，感觉就是心力憔悴，让人无所适从。面对职场的无情，突然好羡慕干体力劳动的外卖小哥。难道命运是想让我去送外卖了吗？干体力活才能让我活下去？fastadmin打卡成功,淘宝金币任务完成。ㅏㅓㅗㅜㅡㅣㅐㅔㅑㅕㅛㅠㅢㅒㅖY行。야자여자요리우유의사얘기예
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖 陟彼高冈yu 基于Googleearthstudio的旅游规划和预览旅游
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • 我的黑历史 袖手围观有来有去
    孩子同学与我们一起共进晚餐，俩孩子加我三个人。小同学是一个大方率性礼貌的小孩，我们也都非常喜欢。好了，回到正题上来让我把这个故事讲完。俩孩子都喜欢吃鱼，所以就发生了小孩子之间常会发生的事。我狠狠的盯了我家孩子，孩子表情有些狼狈。和孩子单独一起的时候，见她尚未释怀，并谴责我不该狠盯她，让她没面子。也许是她触动了我的童年往事吧。由此，一狠心，给她讲了一段埋藏心里极深的黑历史：我奶奶有四个儿子，四个儿子
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 2020-04-12每天三百字之连接与替代 冷眼看潮
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
  • 东南林氏之九牧林候选父系 祖缘树TheYtree
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • 大伟说成语之唉声叹气 求索大伟
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集 高省APP珊珊
    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 百善孝为先 杜友顺
    2018年11月29日天气~晴星期四找点空闲找点时间领着孩子常回家看看带上笑容带上祝福陪同爱人常回家看看家，永远是儿女们幸福温暖的港湾，那里有我们日夜思念的父母，有着彼此的牵挂，无论走到哪里，家永远是避风雨的港湾。今天没事，和媳妇回了趟老家，看看父母，回到家，房间里不算凌乱，可是细心的我发现有的地方已经沾满了灰尘，桌子上父亲不离手的烟灰缸也弹满了烟灰。几个马上就要腐烂掉的水果蔫耷的搭拉着脑袋躺在了
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南） 诚芯微科技 社交电子
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法) 高省_飞智666600
    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 锁之缘 尘缘诗词原创作品
    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • Enum用法 不懂事的小屁孩 enum
    以前的时候知道enum，但是真心不怎么用，在实际开发中，经常会用到以下代码: protected final static String XJ = "XJ"; protected final static String YHK = "YHK"; protected final static String PQ = "PQ";
  • 【Spark九十七】RDD API之aggregateByKey bit1129 spark
    1. aggregateByKey的运行机制   /** * Aggregate the values of each key, using given combine functions and a neutral "zero value". * This function can return a different result type
  • hive创建表是报错： Specified key was too long; max key length is 767 bytes daizj hive
    今天在hive客户端创建表时报错，具体操作如下   hive> create table test2(id string); FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:javax.jdo.JDODataSto
  • Map 与 JavaBean之间的转换 周凡杨 java自省转换反射
    最近项目里需要一个工具类，它的功能是传入一个Map后可以返回一个JavaBean对象。很喜欢写这样的Java服务，首先我想到的是要通过Java 的反射去实现匿名类的方法调用，这样才可以把Map里的值set 到JavaBean里。其实这里用Java的自省会更方便，下面两个方法就是一个通过反射，一个通过自省来实现本功能。 1：JavaBean类 1 &nb
  • java连接ftp下载 g21121 java
    有的时候需要用到java连接ftp服务器下载，上传一些操作，下面写了一个小例子。 /** ftp服务器地址 */ private String ftpHost; /** ftp服务器用户名 */ private String ftpName; /** ftp服务器密码 */ private String ftpPass; /** ftp根目录 */ private String f
  • web报表工具FineReport使用中遇到的常见报错及解决办法（二） 老A不折腾 finereportweb报表java报表总结
      抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。   出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。   1、没有返回数据集： 在存储过程中的操作语句之前加上set nocount on 或者在数据集exec调用存储过程的前面加上这句。当S
  • linux 系统cpu 内存等信息查看 墙头上一根草 cpu内存liunx
    1 查看CPU 　　1.1 查看CPU个数 　　# cat /proc/cpuinfo | grep "physical id" | uniq | wc -l 　　2 　　**uniq命令：删除重复行;wc –l命令：统计行数** 　　1.2 查看CPU核数 　　# cat /proc/cpuinfo | grep "cpu cores" | u
  • Spring中的AOP aijuans springAOP
      Spring中的AOP Written by Tony Jiang @ 2012-1-18 （转）何为AOP AOP，面向切面编程。 在不改动代码的前提下，灵活的在现有代码的执行顺序前后，添加进新规机能。 来一个简单的Sample: 目标类： [java]  view plain copy print ? package&nb
  • placeholder(HTML 5) IE 兼容插件 alxw4616 JavaScriptjquery jQuery插件
    placeholder 这个属性被越来越频繁的使用. 但为做HTML 5 特性IE没能实现这东西. 以下的jQuery插件就是用来在IE上实现该属性的. /** * [placeholder(HTML 5) IE 实现.IE9以下通过测试.] * v 1.0 by oTwo 2014年7月31日 11:45:29 */ $.fn.placeholder = function
  • Object类,值域,泛型等总结(适合有基础的人看) 百合不是茶 泛型的继承和通配符变量的值域Object类转换
    java的作用域在编程的时候经常会遇到,而我经常会搞不清楚这个 问题,所以在家的这几天回忆一下过去不知道的每个小知识点   变量的值域;   package 基础; /** * 作用域的范围 * * @author Administrator * */ public class zuoyongyu { public static vo
  • JDK1.5 Condition接口 bijian1013 javathreadConditionjava多线程
    Condition 将 Object 监视器方法（wait、notify和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。 条件（也称为条件队列或条件变量）为线程提供了一
  • 开源中国OSC源创会记录 bijian1013 hadoopsparkMemSQL
    一.Strata+Hadoop World（SHW）大会         是全世界最大的大数据大会之一。SHW大会为各种技术提供了深度交流的机会，还会看到最领先的大数据技术、最广泛的应用场景、最有趣的用例教学以及最全面的大数据行业和趋势探讨。          二.Hadoop   &nbs
  • 【Java范型七】范型消除 bit1129 java
    范型是Java1.5引入的语言特性，它是编译时的一个语法现象，也就是说，对于一个类，不管是范型类还是非范型类，编译得到的字节码是一样的，差别仅在于通过范型这种语法来进行编译时的类型检查，在运行时是没有范型或者类型参数这个说法的。 范型跟反射刚好相反，反射是一种运行时行为，所以编译时不能访问的变量或者方法(比如private)，在运行时通过反射是可以访问的，也就是说，可见性也是一种编译时的行为，在
  • 【Spark九十四】spark-sql工具的使用 bit1129 spark
    spark-sql是Spark bin目录下的一个可执行脚本，它的目的是通过这个脚本执行Hive的命令，即原来通过 hive>输入的指令可以通过spark-sql>输入的指令来完成。 spark-sql可以使用内置的Hive metadata-store，也可以使用已经独立安装的Hive的metadata store   关于Hive build into Spark
  • js做的各种倒计时 ronin47 js 倒计时
    第一种：精确到秒的javascript倒计时代码      HTML代码:   <form name="form1">   <div align="center" align="middle"
  • java-37.有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接 bylijinnan java
    public class MaxCatenate { /* * Q.37 有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接， * 问这n 个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。 */ public static void main(String[] args){
  • mongoDB安装 开窍的石头 mongodb安装 基本操作
    mongoDB的安装          1:mongoDB下载   https://www.mongodb.org/downloads         2:下载mongoDB下载后解压     
  • [开源项目]引擎的关键意义 comsci 开源项目
         一个系统，最核心的东西就是引擎。。。。。       而要设计和制造出引擎，最关键的是要坚持。。。。。。       现在最先进的引擎技术，也是从莱特兄弟那里出现的，但是中间一直没有断过研发的    
  • 软件度量的一些方法 cuiyadll 方法
    软件度量的一些方法http://cuiyingfeng.blog.51cto.com/43841/6775/在前面我们已介绍了组成软件度量的几个方面。在这里我们将先给出关于这几个方面的一个纲要介绍。在后面我们还会作进一步具体的阐述。当我们不从高层次的概念级来看软件度量及其目标的时候，我们很容易把这些活动看成是不同而且毫不相干的。我们现在希望表明他们是怎样恰如其分地嵌入我们的框架的。也就是我们度量的
  • XSD中的targetNameSpace解释 darrenzhu xmlnamespacexsdtargetnamespace
    参考链接: http://blog.csdn.net/colin1014/article/details/357694 xsd文件中定义了一个targetNameSpace后，其内部定义的元素，属性，类型等都属于该targetNameSpace,其自身或外部xsd文件使用这些元素，属性等都必须从定义的targetNameSpace中找： 例如：以下xsd文件，就出现了该错误，即便是在一
  • 什么是RAID0、RAID1、RAID0+1、RAID5，等磁盘阵列模式? dcj3sjt126com raid
    RAID 1又称为Mirror或Mirroring，它的宗旨是最大限度的保证用户数据的可用性和可修复性。 RAID 1的操作方式是把用户写入硬盘的数据百分之百地自动复制到另外一个硬盘上。由于对存储的数据进行百分之百的备份，在所有RAID级别中，RAID 1提供最高的数据安全保障。同样，由于数据的百分之百备份，备份数据占了总存储空间的一半，因而，Mirror的磁盘空间利用率低，存储成本高。 Mir
  • yii2 restful web服务快速入门 dcj3sjt126com PHPyii2
    快速入门 Yii 提供了一整套用来简化实现 RESTful 风格的 Web Service 服务的 API。 特别是，Yii 支持以下关于 RESTful 风格的 API： 支持 Active Record 类的通用API的快速原型 涉及的响应格式（在默认情况下支持 JSON 和 XML) 支持可选输出字段的定制对象序列化 适当的格式的数据采集和验证错误
  • MongoDB查询(3)——内嵌文档查询（七） eksliang MongoDB查询内嵌文档MongoDB查询内嵌数组
    MongoDB查询内嵌文档 转载请出自出处：http://eksliang.iteye.com/blog/2177301 一、概述        有两种方法可以查询内嵌文档：查询整个文档；针对键值对进行查询。这两种方式是不同的，下面我通过例子进行分别说明。   二、查询整个文档 例如:有如下文档 db.emp.insert({ &qu
  • android4.4从系统图库无法加载图片的问题 gundumw100 android
    典型的使用场景就是要设置一个头像，头像需要从系统图库或者拍照获得，在android4.4之前，我用的代码没问题，但是今天使用android4.4的时候突然发现不灵了。baidu了一圈，终于解决了。 下面是解决方案： private String[] items = new String[] { "图库","拍照" }; /* 头像名称 */
  • 网页特效大全 jQuery等 ini JavaScriptjquerycsshtml5ini
    HTML5和CSS3知识和特效 asp.net ajax jquery实例 分享一个下雪的特效 jQuery倾斜的动画导航菜单 选美大赛示例 你会选谁 jQuery实现HTML5时钟 功能强大的滚动播放插件JQ-Slide 万圣节快乐！！！ 向上弹出菜单jQuery插件 htm5视差动画 jquery将列表倒转顺序 推荐一个jQuery分页插件 jquery animate
  • swift objc_setAssociatedObject block(version1.2 xcode6.4) 啸笑天 version
      import UIKit class LSObjectWrapper: NSObject { let value: ((barButton: UIButton?) -> Void)? init(value: (barButton: UIButton?) -> Void) { self.value = value
  • Aegis 默认的 Xfire 绑定方式，将 XML 映射为 POJO MagicMa_007 javaPOJOxmlAegisxfire
          Aegis 是一个默认的 Xfire 绑定方式，它将 XML 映射为 POJO, 支持代码先行的开发.你开发服 务类与 POJO,它为你生成 XML schema/wsdl XML 和 注解映射概览       默认情况下，你的 POJO 类被是基于他们的名字与命名空间被序列化。如果
  • js get max value in (json) Array qiaolevip 每天进步一点点学习永无止境max纵观千象
    // Max value in Array var arr = [1,2,3,5,3,2];Math.max.apply(null, arr); // 5 // Max value in Jaon Array var arr = [{"x":"8/11/2009","y":0.026572007},{"x"
  • XMLhttpRequest 请求 XML,JSON ,POJO 数据 Luob. POJOjsonAjaxxmlXMLhttpREquest
    在使用XMlhttpRequest对象发送请求和响应之前，必须首先使用javaScript对象创建一个XMLHttpRquest对象。 var xmlhttp； function getXMLHttpRequest(){ if(window.ActiveXObject){ xmlhttp:new ActiveXObject("Microsoft.XMLHTTP
  • jquery wuai jquery
    以下防止文档在完全加载之前运行Jquery代码，否则会出现试图隐藏一个不存在的元素、获得未完全加载的图像的大小 等等 $(document).ready(function(){ jquery代码; }); <script type="text/javascript" src="c:/scripts/jquery-1.4.2.min.js&quo
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他