C++程序员Carea

二叉查找树（binary search tree）（难度7）

C++数据结构与算法实现（目录）

答案在此：二叉查找树（binary search tree）（答案）

写在前面

部分内容参《算法导论》

基本接口实现

1 删除

删除值为value的第一个节点

删除叶子节点1

删除叶子节点1

（3）删除叶子节点1

删除有两个孩子的节点z

分成下面几个步骤进行：

1 找到z的后继，y是z的后继。这时候可以确定y是不可能有左孩子的。

2 删除y，让y的右孩子x取代自己的位置。删除只有一个孩子的节点上面已经讨论过。

3 让y的值覆盖z的值。

待实现代码

#pragma once
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

//------下面的代码是用来测试你的代码有没有问题的辅助代码，你无需关注------
#include 
#include 
#include  
#include 
#include 
using namespace std;
struct Record { Record(void* ptr1, size_t count1, const char* location1, int line1, bool is) :ptr(ptr1), count(count1), line(line1), is_array(is) { int i = 0; while ((location[i] = location1[i]) && i < 100) { ++i; } }void* ptr; size_t count; char location[100] = { 0 }; int line; bool is_array = false; bool not_use_right_delete = false; }; bool operator==(const Record& lhs, const Record& rhs) { return lhs.ptr == rhs.ptr; }std::vector myAllocStatistic; void* newFunctionImpl(std::size_t sz, char const* file, int line, bool is) { void* ptr = std::malloc(sz); myAllocStatistic.push_back({ ptr,sz, file, line , is }); return ptr; }void* operator new(std::size_t sz, char const* file, int line) { return newFunctionImpl(sz, file, line, false); }void* operator new [](std::size_t sz, char const* file, int line)
{
    return newFunctionImpl(sz, file, line, true);
}void operator delete(void* ptr) noexcept { Record item{ ptr, 0, "", 0, false }; auto itr = std::find(myAllocStatistic.begin(), myAllocStatistic.end(), item); if (itr != myAllocStatistic.end()) { auto ind = std::distance(myAllocStatistic.begin(), itr); myAllocStatistic[ind].ptr = nullptr; if (itr->is_array) { myAllocStatistic[ind].not_use_right_delete = true; } else { myAllocStatistic[ind].count = 0; }std::free(ptr); } }void operator delete[](void* ptr) noexcept { Record item{ ptr, 0, "", 0, true }; auto itr = std::find(myAllocStatistic.begin(), myAllocStatistic.end(), item); if (itr != myAllocStatistic.end()) { auto ind = std::distance(myAllocStatistic.begin(), itr); myAllocStatistic[ind].ptr = nullptr; if (!itr->is_array) { myAllocStatistic[ind].not_use_right_delete = true; } else { myAllocStatistic[ind].count = 0; }std::free(ptr); } }
#define new new(__FILE__, __LINE__)
struct MyStruct { void ReportMemoryLeak() { std::cout << "Memory leak report: " << std::endl; bool leak = false; for (auto& i : myAllocStatistic) { if (i.count != 0) { leak = true; std::cout << "leak count " << i.count << " Byte" << ", file " << i.location << ", line " << i.line; if (i.not_use_right_delete) { cout << ", not use right delete. "; }	cout << std::endl; } }if (!leak) { cout << "No memory leak." << endl; } }~MyStruct() { ReportMemoryLeak(); } }; static MyStruct my; void check_do(bool b, int line = __LINE__) { if (b) { cout << "line:" << line << " Pass" << endl; } else { cout << "line:" << line << " Ohh! not passed!!!!!!!!!!!!!!!!!!!!!!!!!!!" << " " << endl; exit(0); } }
#define check(msg)  check_do(msg, __LINE__);
//------上面的代码是用来测试你的代码有没有问题的辅助代码，你无需关注------

template
class binary_search_tree
{
private:
    struct tree_node//OK
    {
        tree_node() :data(T()){}
        tree_node(const T& t) :data(t){}
        bool exist_parent(void) const { return parent != nullptr; }
        T data;
        tree_node* parent = nullptr;
        tree_node* left = nullptr;
        tree_node* right = nullptr;
    };
public:
    binary_search_tree(void) :m_root(nullptr) {}//默认构造函数：什么也不需要做，因为成员定义的时候就已经初始化了
    binary_search_tree(const T*, const int);//从数组构造一颗二叉树
    binary_search_tree(const binary_search_tree&);//拷贝构造函数
    binary_search_tree& operator = (const binary_search_tree&);
    ~binary_search_tree(void) { clear(); }//析构函数
public:
    int size(void) const;//元素数量
    bool empty(void) const { return size() == 0; }//二叉树是否为空
    bool insert(const T& data);//插入一个元素

    T minmum(void) const;//最小值
    T maxmum(void) const;//最大值

    bool exists(const T& data) const;//判断元素是否存在
    void clear(void);//非递归清空二叉树
    void erase(const T& data);

    template
    friend ostream& operator<<(ostream& out, const binary_search_tree& tree);//输出二叉树
    void print_pre_order_nonrecursive(void) const;//非递归:先序遍历输出二叉树
    void print_in_order_nonrecursive(void) const;//非递归:中序遍历输出二叉树
    void print_post_order_nonrecursive(void) const;//非递归:后续遍历输出二叉树

    void print_in_order_recursive(std::ostream& os) const;//递归中序遍历输出二叉树
    void print_element_order(void) const;//非递归按元素顺序输出二叉树
    std::string to_string_in_order(void) const;
    int max_length_between_node(void) const;//最大节点距离
    int hight(void) const;//树高度
    bool operator==(const binary_search_tree& other) const;//两个树相等：结构相同，对应元素相同
    bool operator!=(const binary_search_tree& other) const { return !equal(other); }//两个树不相等
    bool equal(const binary_search_tree& other) const;//两个树相等：结构相同，对应元素相同
private:
    void print_binary_tree(ostream&, const tree_node* bt, int depth) const;//二叉树形式打印二叉树
    tree_node* find(const T& data);//查找
    tree_node* maxmum(tree_node*) const;//最大节点
    tree_node* minmum(tree_node*) const;//最小节点
    tree_node* successor(tree_node* t) const;//后继节点
    //节点的深度与高度：对于树中相同深度的每个结点来说，它们的高度不一定相同，这取决于每个结点下面的叶结点的深度
    int hight(const tree_node* _t) const;
    bool equal(const tree_node* lhs, const tree_node* rhs) const;//两个树相等：结构相同，对应元素相同
    bool is_node_leaf(const tree_node* node) const;
    bool is_left_child(const tree_node* parent, const tree_node* node);
    bool is_leaf_node_equal(const tree_node* lhs, const tree_node* rhs) const;
    void copy(const binary_search_tree& other);
    void copy_node_from(tree_node*& dest, tree_node* dest_parent, const tree_node* from);
    void print_in_order_recursive(std::ostream& os
        , const tree_node* node) const;//递归中序遍历输出二叉树
    void erase_node(tree_node*& pnode);//参数是引用类型，主要是为了：erase_node(m_root) 时，更新m_root;
    void erase_and_reconnect(tree_node*& pnode, tree_node* pnode_child);
    void update_parent(tree_node* pnode);//删除叶子结点后，让父节点指向空指针
private:
    tree_node* left(tree_node* p)
    {
        assert(p != nullptr);
        return p->left;
    }
private:
    tree_node* m_root = nullptr;//OK
    int m_size = 0;
};
template
std::string binary_search_tree::to_string_in_order(void) const
{
    std::stringstream oss;
    this->print_in_order_recursive(oss);
    auto str = oss.str();
    return str;
}
template
binary_search_tree::binary_search_tree(const T* arr, const int length) : binary_search_tree()
{
    //(4) your code 
    //可以使用成员函数insert(const T& data) 来实现这个函数
}
template
inline binary_search_tree::binary_search_tree(const binary_search_tree & from) :m_root(nullptr)
{
    //(5) your code 
    //可以使用成员函数copy来实现
}
template
binary_search_tree& binary_search_tree::operator=(const binary_search_tree & from)
{
    //(5) your code 
    //可以使用成员函数copy来实现。
    //从这里可以看出copy函数应该先用clear成员函数清空自己原有的全部节点


    return *this;
}
template
void binary_search_tree::copy(const binary_search_tree& other)
{
    if (this == &other)//如果拷贝自己，则什么也不做
    {
        return;//直接返回
    }
    clear();//先清空自己的内容
    m_size = other.m_size;//成员变量赋值
    if (other.m_root)//从根节点开始拷贝；递归的拷贝二叉树的每一个节点，照葫芦画瓢
    {
        copy_node_from(m_root/*需要被创建的节点*/, nullptr/*需要被创建的节点的父节点：用户指向孩子*/, other.m_root/*提供节点存储的数据*/);
    }
}
template
bool binary_search_tree::insert(const T& data)
{
    if (m_root != nullptr)
    {
        tree_node *fast, *slow, *ptemp;
        fast = slow = ptemp = m_root;

        while (fast != 0)
        {
            slow = fast;
            if (data < slow->data)
            {
                fast = slow->left;
            }
            else if (data > slow->data)
            {
                fast = slow->right;
            }
            else
            //esle equal do nothing 元素不允许重复
            //，元素如果已经存在，什么也不做
            {
                fast = 0;
                return false;//直接退出，不再插入相同的元素的
            }
        }
        if (data < slow->data)
        {
            slow->left = new tree_node(data);
            slow->left->parent = slow;
        }
        else if (data > slow->data)
        {
            slow->right = new tree_node(data);
            slow->right->parent = slow;
        }
        else
        {
            return false;
        }
        //esle equal do nothing
    }
    else
    {
        m_root = new tree_node(data);
    }
    ++m_size;
    return true;
}
template
int binary_search_tree::hight(void) const
{
    return hight(m_root);
}
template
int binary_search_tree::hight(const tree_node* _t) const
{
    //树的高度，也是树的层树，最大层的层数就是树的高度
    //(7) your code 如果没有元素，返回0
    // 如果只有一个根节点，没有孩子节点高度为1
    // 如果有孩子节点，树的高度就 = 1 + 孩子节点的高度（左右子树高度较大的那一个）


    return -1;
}
template
bool binary_search_tree::operator==(const binary_search_tree & other) const
{
    return this->equal(other);//两个二叉树相等，当且仅当两颗树长的一模一样
}
template
bool binary_search_tree::equal(const binary_search_tree & other) const
{
    return equal(m_root, other.m_root);
}
template
bool binary_search_tree::equal(const tree_node* lhs, const tree_node* rhs) const
{
    // 先判断两个树是否为空

    //再判断两个树是否都是叶子节点  可以使用 is_leaf_node_equal 成员函数

    //再判断两个树的两个左右子树是否同时相等  可以递归调用当前equal函数

    //(8) your code

    return false;
}
template
inline bool binary_search_tree::is_leaf_node_equal(const tree_node* lhs
    , const tree_node* rhs) const
{
    if (is_node_leaf(lhs) && is_node_leaf(rhs))
    {
        return lhs->data == rhs->data;
    }
    return false;
}
template
inline bool binary_search_tree::is_node_leaf(const tree_node * node) const
{
    return node != nullptr && node->left == nullptr && node->right == nullptr;
}


template
///*需要被创建的节点*/, nullptr/*需要被创建的节点*/, other.m_root/*提供节点存储的数据*/
void binary_search_tree::copy_node_from(tree_node *& dest, tree_node* dest_parent, const tree_node * from)
{
    //(9) your code 深度拷贝from节点，并切递归拷贝，从而完成整棵树的拷贝

    //注意dest节点传递的是引用，这意味着你可以非常方便的对这个地址变量赋值，赋值就会修改传进来的外部变量

    //改函数使用递归调用自己的方式，完成整棵树的拷贝。注意对左子树和又子树可能需要分别调用一次递归函数才能完成。

}

template
int binary_search_tree::max_length_between_node(void) const
{
    int max_length = 0;

    const tree_node* ptree = m_root;

    list listNode;

    listNode.push_back(m_root);
    while (!listNode.empty())
    {
        auto pnode = listNode.front();
        listNode.pop_front();
        if (pnode->left != nullptr)
        {
            listNode.push_back(pnode->left);
        }
        if (pnode->right != nullptr)
        {
            listNode.push_back(pnode->right);
        }
        int tempBetween = hight(pnode->left) + hight(pnode->right);

        max_length = std::max(tempBetween, max_length);
    }


    return max_length;
}
template
void binary_search_tree::clear(void)
{
    //使用一个辅助队列(或者栈)，层次遍历删除所有节点。
    //遍历到一个节点A就把孩子BC放到队列，并把这个节点A从队列里取出释放
    //(10) your code


}
template
void binary_search_tree::print_binary_tree(ostream& out, const tree_node* bt, int depth) const
{
    //用右左孩子的方式输出一颗树,先输出右孩子后输出左孩子
    if (bt)
    {
        print_binary_tree(out, bt->right, depth + 1);

        if (depth == 0)
        {
            out << bt->data << endl;
        }
        else if (depth == 1)
        {
            out << " --" << bt->data << endl;
        }
        else
        {
            int n = depth;
            while (--n)
            {
                cout << "    ";
            }
            out << " --" << bt->data << endl;
        }

        print_binary_tree(out, bt->left, depth + 1);
    }
}
template
void binary_search_tree::print_in_order_nonrecursive(void) const
{
    cout << "print_in_order_nonrecursive : ";
    stack tempstack;
    tree_node* t = m_root;
    if (t != NULL)
    {
        do
        {
            tempstack.push(t);
            t = t->left;
        } while (t != NULL);
    }
    while (!tempstack.empty())
    {
        tree_node* p = tempstack.top();
        cout << p->data << " ";
        tempstack.pop();
        if (p->right != NULL)
        {
            p = p->right;
            do
            {
                tempstack.push(p);
                p = p->left;
            } while (p != NULL);
        }
    }
    cout << endl;
}
template
inline void binary_search_tree::print_in_order_recursive(std::ostream & os) const
{
    print_in_order_recursive(os, m_root);
}
template
void binary_search_tree::print_in_order_recursive(std::ostream & os, const tree_node * node) const
{
    if (node == nullptr)
    {
        return;
    }
    print_in_order_recursive(os, node->left);
    os << node->data << " ";
    print_in_order_recursive(os, node->right);
}
template
ostream& operator<<(ostream& out, const binary_search_tree& tree)
{
    tree.print_binary_tree(out, tree.m_root, 0);
    return out;
}
template
void binary_search_tree::print_post_order_nonrecursive(void) const
{
    //后续序序遍历输出一颗树的全部结点值2,3,1
    //广度优先遍历
    cout << "print_post_order_nonrecursive : ";
    typedef pair multinode;
    stack tempstack;
    if (m_root)
    {
        tempstack.push(make_pair(m_root, false));
    }
    while (!tempstack.empty())
    {
        multinode m = tempstack.top(); tempstack.pop();
        if (m.first->left == NULL && m.first->right == NULL)
        {//叶子节点直接输出
            cout << m.first->data << " ";
        }
        else if (m.second == true)
        {//所有孩子都遍历完了才会到这一步
            cout << m.first->data << " ";
        }
        else
        {//非终结点，并且孩子还没遍历完。
            m.second = true; tempstack.push(m);
            if (m.first->right != NULL)
            {
                tempstack.push(make_pair(m.first->right, false));
            }
            if (m.first->left != NULL)
            {
                tempstack.push(make_pair(m.first->left, false));
            }
        }
    }
    cout << endl;
}
template
void binary_search_tree::print_pre_order_nonrecursive(void) const
{
    //先序遍历输出一颗树的全部结点值1,2,3,先根遍历
    cout << "print_pre_order_nonrecursive : ";
    stack node_stack;
    if (m_root)
    {
        node_stack.push(m_root);
        tree_node* t;
        while (!node_stack.empty())
        {
            t = node_stack.top();
            node_stack.pop();
            cout << t->data << " ";
            if (t->right != 0)
            {
                node_stack.push(t->right);
            }
            if (t->left != 0)
            {
                node_stack.push(t->left);
            }
        }
        cout << endl;
    }
}
template
bool binary_search_tree::exists(const T& data) const
{
    bool result = false;
    if (m_root)
    {
        tree_node* pfind = m_root;
        while (pfind)
        {
            if (pfind->data == data)
            {
                result = true;
                break;
            }
            else if (data < pfind->data)
            {
                pfind = pfind->left;
            }
            else
                pfind = pfind->right;
        }
    }
    return result;
}
template
typename binary_search_tree::tree_node* binary_search_tree::find(const T& data)
{
    //(11) your code 利用find，非递归实现：查找某个值是否存在于树中
    return nullptr;
}

template
int binary_search_tree::size(void) const
{
    return m_size;
}
template
T binary_search_tree::minmum(void) const
{
    //(12) your code 返回最小值 ，请使用成员函数 minmum(tree_node* p) const  来实现
    return T();
}
template
typename binary_search_tree::tree_node* binary_search_tree::minmum(tree_node* p) const
{
    //(13) your code 返回最小值：非递归实现
    return nullptr;
}
template
T binary_search_tree::maxmum(void) const
{
    //(14) your code 返回最大值 ，请使用成员函数 maxmum(tree_node* p) const  来实现
    return T();
}
template
typename binary_search_tree::tree_node* binary_search_tree::maxmum(tree_node* t) const
{
    //(14) your code 返回最大值：非递归实现
    return nullptr;
}
template
typename binary_search_tree::tree_node* binary_search_tree::successor(tree_node* t) const
{
    //(15) your code  找到一个节点的后继结点，这个函数是顺序迭代遍历二叉树的关键函数。
    //具体思路为，如果这个节点有右子树，那么右子树的minmum节点就是后继结点。
    //如果，这个节点没有右子树，比该节点大的值，一定是往右上方去的第一个节点。
    //参考《算法导论》


    return nullptr;
}
template
void binary_search_tree::print_element_order(void) const
{
    cout << "print_element_order by order: ";
    if (!empty())
    {
        //(16) your code 使用后继节点成员函数作为顺序迭代的依据，实现顺序遍历一颗二次函数。
        //循环获取后继，只要有后继，就输出这个后继。


        cout << endl;
    }
}

template
void binary_search_tree::erase(const T& data)
{
    tree_node* itr = find(data);
    assert(itr != nullptr);
    --m_size;
    if (itr == m_root)
    {
        /*删除根节点，可能需要释放根节点本身，这个时候m_root的指向需要更新。
        * 所以erase_node的参数是引用类型，希望可以在erase_node内部对m_root重新
        * 赋值来打到更新根节点指向的目的。
        */
        erase_node(m_root);
        return;
    }
    else
    {
        erase_node(itr);
    }
}
template
void binary_search_tree::erase_node(tree_node*& pnode)
{
    //pnode如果没有parent，那么它就是root，这个时候，删除pnode
    // ，无需考虑pnode的parent需要更新的问题。
    //只需要处理其孩子替代自己的问题

    if (pnode->left == nullptr && pnode->right == nullptr)
    {
        //叶子结点被删除了的话，被删除节点的父亲应该指向空指针。
        update_parent(pnode);//内部会先判断pnode有没有parent
        delete pnode;
        //这里会更新传进来的引用参数，比如，如果传进来的是m_root的话。
        pnode = nullptr;//如果pnode是m_root的话，这句话就会变得必不可少（更新m_root）
    }
    //如果被删除的节点p只有左孩子：让p的左孩子p_left_child取代自己作为p的parent节点的做孩子
    else if (pnode->left != nullptr && pnode->right == nullptr)
    {
        //让pnode的父亲节点和pnode的孩子建立连接
        erase_and_reconnect(pnode, pnode->left);
    }
    //如果只有右孩子：让右孩子取代自己
    else if (pnode->left == nullptr && pnode->right != nullptr)
    {
        //让pnode的父亲节点和pnode的孩子建立连接
        erase_and_reconnect(pnode, pnode->right);
    }
    else
    {
        //https://zhuanlan.zhihu.com/p/640863892
        //分成下面几个步骤进行：
        //1 找到z的后继，y是z的后继。这时候可以确定y是不可能有左孩子的。
        //2 删除y，让y的右孩子x取代自己的位置。删除只有一个孩子的节点上面已经讨论过。
        //3 让y的值覆盖z的值。
        tree_node* psuccessor = successor(pnode);
        pnode->data = psuccessor->data;//3 让y的值覆盖z的值。
        //2 删除y, y只有一个孩子，只有一个孩子的节点删除此函数的开始部分已经实现了。只需要调用此函数即可。
        //(17) your code
    }
}
template
void binary_search_tree::update_parent(tree_node* pnode)
{//删除叶子结点后，让父节点指向空指针
    if (pnode->parent)
    {
        auto parent = pnode->parent;
        is_left_child(parent, pnode) ? (parent->left = nullptr) : (parent->right = nullptr);
    }
}
template
void binary_search_tree::erase_and_reconnect(tree_node*& delete_pnode, tree_node* pnode_child)
{
    //让左孩子取代自己，同时考虑parent不存在的情况下取代自己。
    if (delete_pnode->exist_parent())
    {
        //拿到父节点
        auto parent = delete_pnode->parent;
        auto is_left = is_left_child(parent, delete_pnode);
        //先备份地址，将来用于释放内存
        auto pbackup = delete_pnode;
        //指向新节点：自己的左孩子替代自己
        // reconnect1 ->
        delete_pnode = pnode_child;
        // <- reconnect2 
        pnode_child->parent = parent;//指向新的父亲
        //删除自己原来的内存
        delete pbackup;

        //父节点和自己的左孩子建立连接
        is_left ? parent->left = delete_pnode : parent->right = delete_pnode;
    }
    else //删除根节点， 删除根节点可不是删除整个树哦
    {
        //先备份地址，将来用于释放内存
        auto pbackup = delete_pnode;
        //指向新节点：自己的左孩子替代自己
        delete_pnode = pnode_child;
        //删除自己原来的内存
        delete pbackup;
    }
}
template
bool binary_search_tree::is_left_child(const tree_node* parent, const tree_node* pnode)
{
    assert(parent != nullptr);
    assert(pnode != nullptr);
    return (parent->left == pnode);
}

void test_tree(const binary_search_tree& _tree)
{
    cout << "test_tree:\n";
    cout << _tree;
    cout << "tree size : " << _tree.size() << endl;
    cout << "tree max length between node " << _tree.max_length_between_node() << endl;
    _tree.print_in_order_nonrecursive();
    _tree.print_element_order();
    _tree.print_post_order_nonrecursive();
    _tree.print_pre_order_nonrecursive();
    cout << "min element : " << _tree.minmum() << endl;
    cout << "max element : " << _tree.maxmum() << "\n" << endl;
}
void test1()
{
    binary_search_tree tree;
    check(tree.size() == 0);
    check(tree.empty());
    check(tree.hight() == 0);
}
void test2()
{
    int arr[1] = { 1 };
    binary_search_tree tree(arr, 1);
    check(tree.size() == 1);
    check(tree.to_string_in_order() == "1 ");
    check(!tree.empty());
}
void test3()
{
    int arr[2] = { 1, 2 };
    binary_search_tree tree(arr, 2);
    check(tree.size() == 2);
    check(tree.to_string_in_order() == "1 2 ");
    check(!tree.empty());
}
void test4()
{
    int arr[2] = { 2, 1 };
    binary_search_tree tree(arr, 2);
    check(tree.size() == 2);
    check(tree.to_string_in_order() == "1 2 ");
    check(!tree.empty());
}
void test5()
{
    constexpr int length = 3;
    int arr[length] = { 1, 2, 3 };
    binary_search_tree tree(arr, length);
    check(tree.size() == length);
    check(tree.to_string_in_order() == "1 2 3 ");
    check(!tree.empty());
}
void test6()
{
    constexpr int length = 3;
    int arr[length] = { 2, 1, 3 };
    binary_search_tree tree(arr, length);
    check(tree.size() == length);
    check(tree.to_string_in_order() == "1 2 3 ");
    check(!tree.empty());
}
void test7()
{
    constexpr int length = 3;
    int arr[length] = { 3, 2, 1, };
    binary_search_tree tree(arr, length);
    check(tree.size() == length);
    check(tree.to_string_in_order() == "1 2 3 ");
    check(!tree.empty());
}
void test8()
{
    constexpr int length = 3;
    int arr[length] = { 3, 1, 2, };
    binary_search_tree tree(arr, length);
    check(tree.size() == length);
    check(tree.to_string_in_order() == "1 2 3 ");
    check(!tree.empty());
}
void test9()
{
    constexpr int length = 10;
    int arr[length] = { 1,3,5,7,9,2,4,6,8,10 };
    binary_search_tree tree(arr, length);
    check(tree.size() == length);
    check(tree.to_string_in_order() ==
        "1 2 3 4 5 6 7 8 9 10 ");
    check(!tree.empty());
}
void test10()
{
    constexpr int length = 10;
    int arr[length] = { 2,4,6,8,10,1,3,5,7,9 };
    binary_search_tree tree(arr, length);
    check(tree.size() == length);
    check(tree.to_string_in_order() ==
        "1 2 3 4 5 6 7 8 9 10 ");
    check(!tree.empty());
}
void test11()
{
    constexpr int length = 10;
    int arr[length] = { 10,9,8,7,6,5,4,3,2,1 };
    binary_search_tree tree(arr, length);
    check(tree.size() == length);
    check(tree.to_string_in_order() ==
        "1 2 3 4 5 6 7 8 9 10 ");
    check(!tree.empty());
    check(tree.hight() == 10);
}
void test12()
{
    constexpr int length = 10;
    int arr[length] = { 5,4,3,2,1,10,9,8,7,6 };
    binary_search_tree tree(arr, length);
    check(tree.size() == length);
    check(tree.to_string_in_order() ==
        "1 2 3 4 5 6 7 8 9 10 ");
    check(!tree.empty());
    check(tree.hight() == 6);
}
void test13()
{
    constexpr int length = 1;
    int arr[length] = { 1 };
    binary_search_tree tree(arr, length);
    check(tree.minmum() == 1);
    check(tree.maxmum() == 1);
    check(tree.hight() == 1);
}
void test14()
{
    constexpr int length = 2;
    int arr[length] = { 1, 2 };
    binary_search_tree tree(arr, length);
    check(tree.minmum() == 1);
    check(tree.maxmum() == 2);
    check(tree.hight() == 2);
}
void test15()
{
    constexpr int length = 10;
    int arr[length] = { 5,4,3,2,1,10,9,8,7,6 };
    binary_search_tree tree(arr, length);
    check(tree.minmum() == 1);
    check(tree.maxmum() == 10);
}
void test16()
{
    constexpr int length = 1;
    int arr[length] = { 1 };
    binary_search_tree tree(arr, length);
    check(tree.exists(1));
    tree.erase(1);
    check(!tree.exists(1));
    check(tree.size() == 0);
}
void test17()
{
    int arr[] = { 3,2,1 };
    binary_search_tree tree(arr, sizeof(arr) / sizeof(int));
    check(tree.exists(1));
    cout << tree << endl;
    tree.erase(2);
    cout << tree << endl;
    check(!tree.exists(2));
    check(tree.size() == 2);
    check(!tree.empty());
    check(tree.to_string_in_order() == "1 3 ");
}
void test18()
{
    constexpr int length = 2;
    int arr[length] = { 1, 2 };
    binary_search_tree tree(arr, length);
    check(tree.exists(1));
    check(tree.exists(2));
    tree.erase(1);
    check(!tree.exists(1));
    check(tree.exists(2));
    tree.clear();
    check(tree.empty());
    check(tree.size() == 0);
    check(!tree.exists(2));
}
void test19()
{
    constexpr int length = 10;
    int arr[length] = { 5,3,4,1,2,10,8,9,7,6 };
    binary_search_tree tree(arr, length);
    cout << tree << endl << "-------------------" << endl;
    tree.erase(1);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "2 3 4 5 6 7 8 9 10 ");
    tree.erase(2);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "3 4 5 6 7 8 9 10 ");
    tree.erase(3);
    check(tree.to_string_in_order() == "4 5 6 7 8 9 10 ");
    cout << tree << endl << "-------------------" << endl;
    tree.erase(4);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "5 6 7 8 9 10 ");
    tree.erase(5);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "6 7 8 9 10 ");
    tree.erase(6);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "7 8 9 10 ");
    tree.erase(7);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "8 9 10 ");
    tree.erase(8);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "9 10 ");
    tree.erase(9);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "10 ");
    tree.erase(10);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "");
}
void test20()
{
    constexpr int length = 10;
    int arr[length] = { 5,3,4,1,2,10,8,9,7,6 };
    binary_search_tree tree(arr, length);
    cout << tree << endl << "-------------------" << endl;
    tree.erase(10);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "1 2 3 4 5 6 7 8 9 ");
    tree.erase(8);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "1 2 3 4 5 6 7 9 ");
}
void test21()
{
    constexpr int length = 10;
    int arr[length] = { 5,3,4,1,2,10,8,9,7,6 };
    binary_search_tree tree(arr, length);
    cout << tree << endl << "-------------------" << endl;
    tree.erase(5);
    cout << tree << endl << "-------------------" << endl;
    check(tree.to_string_in_order() == "1 2 3 4 6 7 8 9 10 ");
}
void test22()
{
    constexpr int length = 10;
    int arr[length] = { 2,4,6,8,10,1,3,5,7,9 };
    binary_search_tree tree(arr, length);
    check(tree.hight() == 6);
    tree.erase(1);
    check(!tree.exists(1));
    tree.erase(2);
    check(!tree.exists(2));
    tree.erase(3);
    check(!tree.exists(3));
    tree.erase(4);
    check(!tree.exists(4));
    tree.erase(5);
    check(!tree.exists(5));
    check(tree.to_string_in_order() == "6 7 8 9 10 ");
    tree.erase(6);
    check(!tree.exists(6));
    tree.erase(7);
    check(!tree.exists(7));
    tree.erase(8);
    check(!tree.exists(8));
    tree.erase(9);
    check(!tree.exists(9));
    tree.erase(10);
    check(!tree.exists(10));
    check(tree.empty());
}
void test23()
{
    //test equal
    int a[3] = { 15, 12, 14 };
    binary_search_tree tree(a, 3);
    check(tree.hight() == 3);
    cout << "tree:\n" << tree << endl;
    auto tree2 = tree;
    cout << "tree2:\n" << tree2 << endl;
    check(tree2.equal(tree));
}
void test24(binary_search_tree& tree)
{
    cout << "tree:\n" << tree << endl;
    auto tree2 = tree;
    cout << "tree2:\n" << tree2 << endl;
    check(tree2.equal(tree));
    check(tree2 == tree);
    tree.clear();
    cout << tree << endl;
    check(tree2.equal(tree) == false);
    check(tree2 != tree);
}
void test25()
{
    int a[3] = { 15, 12, 14 };
    binary_search_tree tree(a, 3);
    tree.print_in_order_recursive(cout);
}
int main()
{
    test1();//empty
    test2();//test create insert empty size
    test3();
    test4();
    test5();
    test6();
    test7();
    test8();
    test9();
    test10();
    test11();
    test12();
    test13();
    test14();//minmum maxmum
    test15();
    test16();//exists clear erase size empty
    test17();//erase
    test18();//erase
    test19();//erase
    test20();//erase
    test21();//erase
    test22();//erase
    test23();

    int maxLength = 0;
    int a[100] = { 15, 12, 14, 13, 16
                 , 34, 23, 24, 22, 21
                 , 20, 19, 18, 17, 35
                 , 36, 37, 38, 39, 40
                 , 41, 0 };

    binary_search_tree tree(a, 22);
    check(tree.size() == 22);
    check(tree.empty() == false);
    check(tree.maxmum() == 41);
    check(tree.minmum() == 0);
    test_tree(tree);

    binary_search_tree tree1(a, 3);
    test_tree(tree1);

    test24(tree);//test copy
    test25();//print

    return 0;
}

正确输出

line:725 Pass
line:726 Pass
line:727 Pass
line:733 Pass
line:734 Pass
line:735 Pass
line:741 Pass
line:742 Pass
line:743 Pass
line:749 Pass
line:750 Pass
line:751 Pass
line:758 Pass
line:759 Pass
line:760 Pass
line:767 Pass
line:768 Pass
line:769 Pass
line:776 Pass
line:777 Pass
line:778 Pass
line:785 Pass
line:786 Pass
line:787 Pass
line:794 Pass
line:796 Pass
line:797 Pass
line:804 Pass
line:806 Pass
line:807 Pass
line:814 Pass
line:816 Pass
line:817 Pass
line:818 Pass
line:825 Pass
line:827 Pass
line:828 Pass
line:829 Pass
line:836 Pass
line:837 Pass
line:838 Pass
line:845 Pass
line:846 Pass
line:847 Pass
line:854 Pass
line:855 Pass
line:862 Pass
line:864 Pass
line:865 Pass
line:871 Pass
3
 --2
     --1

3
 --1

line:875 Pass
line:876 Pass
line:877 Pass
line:878 Pass
line:885 Pass
line:886 Pass
line:888 Pass
line:889 Pass
line:891 Pass
line:892 Pass
line:893 Pass
 --10
         --9
     --8
         --7
             --6
5
     --4
 --3
         --2
     --1

-------------------
 --10
         --9
     --8
         --7
             --6
5
     --4
 --3
     --2

-------------------
line:903 Pass
 --10
         --9
     --8
         --7
             --6
5
     --4
 --3

-------------------
line:906 Pass
line:908 Pass
 --10
         --9
     --8
         --7
             --6
5
 --4

-------------------
 --10
         --9
     --8
         --7
             --6
5

-------------------
line:912 Pass
10
     --9
 --8
     --7
         --6

-------------------
line:915 Pass
10
     --9
 --8
     --7

-------------------
line:918 Pass
10
     --9
 --8

-------------------
line:921 Pass
10
 --9

-------------------
line:924 Pass
10

-------------------
line:927 Pass

-------------------
line:930 Pass
 --10
         --9
     --8
         --7
             --6
5
     --4
 --3
         --2
     --1

-------------------
     --9
 --8
     --7
         --6
5
     --4
 --3
         --2
     --1

-------------------
line:940 Pass
 --9
     --7
         --6
5
     --4
 --3
         --2
     --1

-------------------
line:943 Pass
 --10
         --9
     --8
         --7
             --6
5
     --4
 --3
         --2
     --1

-------------------
 --10
         --9
     --8
         --7
6
     --4
 --3
         --2
     --1

-------------------
line:953 Pass
line:960 Pass
line:962 Pass
line:964 Pass
line:966 Pass
line:968 Pass
line:970 Pass
line:971 Pass
line:973 Pass
line:975 Pass
line:977 Pass
line:979 Pass
line:981 Pass
line:982 Pass
line:989 Pass
tree:
15
     --14
 --12

tree2:
15
     --14
 --12

line:993 Pass
line:1047 Pass
line:1048 Pass
line:1049 Pass
line:1050 Pass
test_tree:
                                 --41
                             --40
                         --39
                     --38
                 --37
             --36
         --35
     --34
             --24
         --23
             --22
                 --21
                     --20
                         --19
                             --18
                                 --17
 --16
15
     --14
         --13
 --12
     --0
tree size : 22
tree max length between node 14
print_in_order_nonrecursive : 0 12 13 14 15 16 17 18 19 20 21 22 23 24 34 35 36 37 38 39 40 41
print_element_order by order: 0 12 13 14 15 16 17 18 19 20 21 22 23 24 34 35 36 37 38 39 40 41
print_post_order_nonrecursive : 0 13 14 12 17 18 19 20 21 22 24 23 41 40 39 38 37 36 35 34 16 15
print_pre_order_nonrecursive : 15 12 0 14 13 16 34 23 22 21 20 19 18 17 24 35 36 37 38 39 40 41
min element : 0
max element : 41

test_tree:
15
     --14
 --12
tree size : 3
tree max length between node 2
print_in_order_nonrecursive : 12 14 15
print_element_order by order: 12 14 15
print_post_order_nonrecursive : 14 12 15
print_pre_order_nonrecursive : 15 12 14
min element : 12
max element : 15

tree:
                                 --41
                             --40
                         --39
                     --38
                 --37
             --36
         --35
     --34
             --24
         --23
             --22
                 --21
                     --20
                         --19
                             --18
                                 --17
 --16
15
     --14
         --13
 --12
     --0

tree2:
                                 --41
                             --40
                         --39
                     --38
                 --37
             --36
         --35
     --34
             --24
         --23
             --22
                 --21
                     --20
                         --19
                             --18
                                 --17
 --16
15
     --14
         --13
 --12
     --0

line:1000 Pass
line:1001 Pass

line:1004 Pass
line:1005 Pass
12 14 15 Memory leak report:
No memory leak.

你可能感兴趣的:(C++数据结构与算法实现,算法,c++,开发语言,链表)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
element实现动态路由+面包屑软件技术NINI vue案例 vue.js 前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
2021年12月19日，春蕾教育集团团建活动感受——黄晓丹黄错错加油
感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
消息中间件有哪些常见类型 xmh-sxh-1314 java
消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
腾讯云技术深度探索：构建高效云原生微服务架构我的运维人生云原生架构腾讯云运维开发技术共享
腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
从0到500+，我是如何利用自媒体赚钱？一列脚印
运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
使用LLaVa和Ollama实现多模态RAG示例 llzwxh888 python 人工智能开发语言
本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchain microsoft 数据库 python
利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
121. 买卖股票的最佳时机薄荷糖的味道_fb40
给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
MongoDB Oplog 窗口喝醉酒的小白 MongoDB 运维
在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
Faiss Tips：高效向量搜索与聚类的利器焦习娜Samantha
FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
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//三
Low Power概念介绍-Voltage Area 飞奔的大虎
随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
C++菜鸟教程 - 从入门到精通第二节 DreamByte c++
一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
道阻且长，行则将至 sweet橘子
本文参与书香澜梦主题征文“行”文章原创首发，文责自负。我们每一个人都应该有属于自己的愿望或者是理想，人一但有了理想也就算是有了方向，它就会像灯塔一样指引我们前进的方向，哪怕是再远大的理想，如果坚持，那么我相信它就一定有收获。屈原是我最喜欢的一个浪漫主义的诗人，他曾今说过：“路漫漫其修远兮，吾将上下而求索。”人生的道路很长，但是为了实现自己的理想抱负我愿意付出我毕生的精力，只专注这一件事，因为“道阻
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
用MiddleGenIDE工具生成hibernate的POJO（根据数据表生成POJO类） AdyZhang POJO eclipse Hibernate MiddleGenIDE
推荐:MiddlegenIDE插件, 是一个Eclipse 插件. 用它可以直接连接到数据库, 根据表按照一定的HIBERNATE规则作出BEAN和对应的XML ，用完后你可以手动删除它加载的JAR包和XML文件! 今天开始试着使用
.9.png Cb123456 android
“点九”是andriod平台的应用软件开发里的一种特殊的图片形式，文件扩展名为：.9.png 　　智能手机中有自动横屏的功能,同一幅界面会在随着手机(或平板电脑)中的方向传感器的参数不同而改变显示的方向,在界面改变方向后,界面上的图形会因为长宽的变化而产生拉伸,造成图形的失真变形。　　我们都知道android平台有多种不同的分辨率，很多控件的切图文件在被放大拉伸后，边
算法的效率天子之骄算法效率复杂度最坏情况运行时间大O阶平均情况运行时间
算法的效率效率是速度和空间消耗的度量。集中考虑程序的速度，也称运行时间或执行时间，用复杂度的阶(O)这一标准来衡量。空间的消耗或需求也可以用大O表示，而且它总是小于或等于时间需求。以下是我的学习笔记： 1.求值与霍纳法则，即为秦九韶公式。 2.测定运行时间的最可靠方法是计数对运行时间有贡献的基本操作的执行次数。运行时间与这个计数成正比。
java数据结构何必如此 java 数据结构
Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：枚举（Enumeration）位集合（BitSet）向量（Vector）栈（Stack）字典（Dictionary）哈希表（Hashtable）属性（Properties）以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collect
MybatisHelloWorld 3213213333332132
//测试入口TestMyBatis package com.base.helloworld.test; import java.io.IOException; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibat
Java|urlrewrite|URL重写|多个参数 7454103 java xml Web 工作
个人工作经验！如有不当之处，敬请指点 1.0 web -info 目录下建立 urlrewrite.xml 文件类似如下： <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE u
达梦数据库+ibatis darkranger sql mysql ibatis SQL Server
--插入数据方面如果您需要数据库自增... 那么在插入的时候不需要指定自增列. 如果想自己指定ID列的值, 那么要设置 set identity_insert 数据库名.模式名.表名; ----然后插入数据; example: create table zhabei.test( id bigint identity(1,1) primary key, nam
XML 解析四种方式 aijuans android
XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。 XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object
spring中配置文件占位符的使用 avords
1.类 <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.o
前端工程化-公共模块的依赖和常用的工作流 bee1314 webpack
题记：一个人的项目，还有工程化的问题嘛？我们在推进模块化和组件化的过程中，肯定会不断的沉淀出我们项目的模块和组件。对于这些沉淀出的模块和组件怎么管理？另外怎么依赖也是个问题？你真的想这样嘛？ var BreadCrumb = require(‘../../../../uikit/breadcrumb’); //真心ugly。
上司说「看你每天准时下班就知道你工作量不饱和」，该如何回应？ bijian1013 项目管理沟通 IT职业规划
问题：上司说「看你每天准时下班就知道你工作量不饱和」，如何回应正常下班时间6点，只要是6点半前下班的，上司都认为没有加班。 Eno-Bea回答，注重感受，不一定是别人的虽然我不知道你具体从事什么工作与职业，但是我大概猜测，你是从事一项不太容易出现阶段性成果的工作
TortoiseSVN，过滤文件征客丶 SVN
环境： TortoiseSVN 1.8 配置：在文件夹空白处右键选择 TortoiseSVN -> Settings 在 Global ignote pattern 中添加要过滤的文件：多类型用英文空格分开 *name ：过滤所有名称为 name 的文件或文件夹 *.name ：过滤所有后缀为 name 的文件或文件夹 --------
【Flume二】HDFS sink细说 bit1129 Flume
1. Flume配置 a1.sources=r1 a1.channels=c1 a1.sinks=k1 ###Flume负责启动44444端口 a1.sources.r1.type=avro a1.sources.r1.bind=0.0.0.0 a1.sources.r1.port=44444 a1.sources.r1.chan
The Eight Myths of Erlang Performance bookjovi erlang
erlang有一篇guide很有意思： http://www.erlang.org/doc/efficiency_guide 里面有个The Eight Myths of Erlang Performance： http://www.erlang.org/doc/efficiency_guide/myths.html Myth: Funs are sl
java多线程网络传输文件(非同步)-2008-08-17 ljy325 java 多线程 socket
利用 Socket 套接字进行面向连接通信的编程。客户端读取本地文件并发送；服务器接收文件并保存到本地文件系统中。使用说明:请将TransferClient, TransferServer, TempFile三个类编译，他们的类包是FileServer. 客户端: 修改TransferClient: serPort, serIP, filePath, blockNum,的值来符合您机器的系
读《研磨设计模式》-代码笔记-模板方法模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet;
配置心得 chenyu19891124 配置
时间就这样不知不觉的走过了一个春夏秋冬，转眼间来公司已经一年了，感觉时间过的很快，时间老人总是这样不停走，从来没停歇过。作为一名新手的配置管理员，刚开始真的是对配置管理是一点不懂，就只听说咱们公司配置主要是负责升级，而具体该怎么做却一点都不了解。经过老员工的一点点讲解，慢慢的对配置有了初步了解，对自己所在的岗位也慢慢的了解。做了一年的配置管理给自总结下： 1.改变从一个以前对配置毫无
对“带条件选择的并行汇聚路由问题”的再思考 comsci 算法工作软件测试嵌入式领域模型
2008年上半年，我在设计并开发基于”JWFD流程系统“的商业化改进型引擎的时候，由于采用了新的嵌入式公式模块而导致出现“带条件选择的并行汇聚路由问题”(请参考2009-02-27博文)，当时对这个问题的解决办法是采用基于拓扑结构的处理思想，对汇聚点的实际前驱分支节点通过算法预测出来，然后进行处理，简单的说就是找到造成这个汇聚模型的分支起点，对这个起始分支节点实际走的路径数进行计算，然后把这个实际
Oracle 10g 的clusterware 32位下载地址 daizj oracle
Oracle 10g 的clusterware 32位下载地址 http://pan.baidu.com/share/link?shareid=531580&uk=421021908 http://pan.baidu.com/share/link?shareid=137223&uk=321552738 http://pan.baidu.com/share/l
非常好的介绍：Linux定时执行工具cron dongwei_6688 linux
Linux经过十多年的发展，很多用户都很了解Linux了，这里介绍一下Linux下cron的理解，和大家讨论讨论。cron是一个Linux 定时执行工具，可以在无需人工干预的情况下运行作业，本文档不讲cron实现原理，主要讲一下Linux定时执行工具cron的具体使用及简单介绍。新增调度任务推荐使用crontab -e命令添加自定义的任务（编辑的是/var/spool/cron下对应用户的cr
Yii assets目录生成及修改 dcj3sjt126com yii
assets的作用是方便模块化，插件化的，一般来说出于安全原因不允许通过url访问protected下面的文件，但是我们又希望将module单独出来，所以需要使用发布，即将一个目录下的文件复制一份到assets下面方便通过url访问。 assets设置对应的方法位置 \framework\web\CAssetManager.php assets配置方法在m
mac工作软件推荐 dcj3sjt126com mac
mac上的Terminal + bash ＋ screen组合现在已经非常好用了，但是还是经不起iterm＋zsh＋tmux的冲击。在同事的强烈推荐下，趁着升级mac系统的机会，顺便也切换到iterm＋zsh＋tmux的环境下了。我为什么要要iterm2 切换过来也是脑袋一热的冲动，我也调查过一些资料，看了下iterm的一些优点： * 兼容性好，远程服务器 vi 什么的低版本能很好兼
Memcached(三)、封装Memcached和Ehcache frank1234 memcached ehcache spring ioc
本文对Ehcache和Memcached进行了简单的封装，这样对于客户端程序无需了解ehcache和memcached的差异，仅需要配置缓存的Provider类就可以在二者之间进行切换，Provider实现类通过Spring IoC注入。 cache.xml <?xml version="1.0" encoding="UTF-8"?>
Remove Duplicates from Sorted List II hcx2013 remove
Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. For example,Given 1->2->3->3->4->4->5,
Spring4新特性——注解、脚本、任务、MVC等其他特性改进 jinnianshilongnian spring4
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
MySQL安装文档 liyong0802 mysql
工作中用到的MySQL可能安装在两种操作系统中，即Windows系统和Linux系统。以Linux系统中情况居多。安装在Windows系统时与其它Windows应用程序相同按照安装向导一直下一步就即，这里就不具体介绍，本文档只介绍Linux系统下MySQL的安装步骤。 Linux系统下安装MySQL分为三种：RPM包安装、二进制包安装和源码包安装。二
使用VS2010构建HotSpot工程 p2p2500 HotSpot OpenJDK VS2010
1. 下载OpenJDK7的源码： http://download.java.net/openjdk/jdk7 http://download.java.net/openjdk/ 2. 环境配置 ▶
Oracle实用功能之分组后列合并 seandeng888 oracle 分组实用功能合并
1 实例解析由于业务需求需要对表中的数据进行分组后进行合并的处理，鉴于Oracle10g没有现成的函数实现该功能，且该功能如若用JAVA代码实现会比较复杂，因此，特将SQL语言的实现方式分享出来，希望对大家有所帮助。如下：表test 数据如下： ID,SUBJECTCODE,DIMCODE,VALUE 1&nbs
Java定时任务注解方式实现 tuoni java spring jvm xml jni
Spring 注解的定时任务，有如下两种方式：第一种： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http
11大Java开源中文分词器的使用方法和分词效果对比 yangshangchuan word分词器 ansj分词器 Stanford分词器 FudanNLP分词器 HanLP分词器
本文的目标有两个： 1、学会使用11大Java开源中文分词器 2、对比分析11大Java开源中文分词器的分词效果本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。 11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： /** * 获取文本的所有分词结果, 对比