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++,开发语言,链表)

《数据结构与算法》知识点（四）游戏原画设计
第七章查找顺序查找、折半查找、索引查找、分块查找是静态查找，动态查找有二叉排序树查找，最优二叉树查找，键树查找，哈希表查找静态查找表顺序表的顺序查找：应用范围：顺序表或线性链表表示的表，表内元素之间无序。查找过程：从表的一端开始逐个进行记录的关键字和给定值的比较。顺序有序表的二分查找。平均查找时间(n+1)/nlog2(n+1)分块查找：将表分成几块，块内无序，块间有序，即前一块中的最大值小于后一
Interceptor拦截器+JWT令牌实现登陆验证 wy08success Interceptor springboot java 登陆验证
一、背景与过滤器的作用类似，不过拦截器是spring中的组件，只能拦截进入spring的请求；过滤器则可以拦截所有从前端页面发送来的请求。*拦截器和过滤器选一就可以实现登陆验证，过滤器的实现在以下这篇博客中，有需要可以自取：Filter过滤器+JWT令牌实现登陆验证-CSDN博客二、分析定义拦截器，实现HanderInterceptor接口，并重写其所有方法。注册拦截器三、实现1、目录结构：2、L
单例模式以及反射对单例模式的破坏及防御 CodeDunkster 单例模式 java javascript
单例模式（SingletonPattern）是一种确保类在应用程序生命周期内只存在一个实例的设计模式。它不仅提供了全局访问点，还能节省内存、控制实例的生命周期。但常见的单例模式实现方式如饿汉式、懒汉式、双重校验锁、静态内部类等，虽然设计良好，但都容易被Java的反射机制所破坏。本文将介绍这些单例实现方式的优缺点、反射如何破坏它们的唯一性，以及如何防御这种破坏。1.单例模式的常见实现方式1.1饿汉式
C++中的try与catch lpl还在学习的路上开发语言
try和catch的用法_trycatch-CSDN博客try和catch是用于处理异常的语句，它们构成了一种异常处理机制。在一个try语句中，程序执行一段代码，如果发生了异常，则会被捕获，并转到相应的catch语句中进行处理。------什么时候会出现异常？C++异常详细介绍-CSDN博客除0操作发生越界内存错误--------------异常不会终止程序，并且会将错误信息详细介绍。error:
Koa2——洋葱模型，简单实现三千数优一 javascript 1024程序员节
classapp{middleware=[];//装载中间件use(middleware){this.middleware.push(middleware);}compose(callback){//把要被触发的上一层洋葱壳作为下一层洋葱壳的next入参传入。//reducer的返回值，也就是下一层的next为()=>fn(next)。constreducer=(next,fn)=>()=>fn(
koa2 洋葱模型 gaearon koa2 js nodejs node.js koa2
示意图koa2是基于async和await实现的，使用next进行流程控制。这样就可以使用awaitnext()进行一种特殊的执行顺序，等下一个路由执行完毕之后，再执行当前路由，通常称为“洋葱模型”。何谓“洋葱模型”就像那首歌一样，“一层一层剥开我的心”，koa2中的“洋葱模型”也是这样，匹配到的路由，可以一层一层进去，进入最内层之后，再一层一层出来。例如这个demo：api.get("/",as
C++vector类 Ssorrymaker C++c++
系列文章目录C++入门C++类和对象（上）C++类和对象（中）C++类和对象（下）C/C++内存管理C++string类文章目录系列文章目录一、vector是什么？二、常用接口说明1.常见的构造函数2.vectoriterator的使用3.关于vector的容量4.vector的增删改查5.迭代器失效一、vector是什么？vector是表示可变大小数组的序列容器，类似于数组，vector也采用连
算法练习——迷宫问题（Java）bfs广搜流萤点火算法 bfs java
问题描述：小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。小明只能向上下左右四个方向移动。输入输入包含多组测试数据。输入的第一行是一个整数T，表示有T组测试数据。每组输入的第一行是两个整数N和M（1que,intgx,intgy,intn,intm,char[][]arr){Qq=newQ();q.x=sx;q.y=sy;q.dept=0;que.add(q);//添加intfinish
平滑法时间序列模型原理及Python实践 AI智博信息数据分析与挖掘 python 人工智能
平滑法时间序列模型原理主要涉及通过一定的算法对时间序列数据进行平滑处理，以消除或减弱数据中的随机波动和噪声，从而揭示出数据中的长期趋势和季节性变化，进而对未来数据进行预测。以下是平滑法时间序列模型的详细原理：一、基本原理平滑法时间序列模型基于对历史数据的平滑处理，通过对数据的平均或加权平均，去除数据中的随机波动，使得时间序列数据更加平滑，便于分析和预测。这种方法能够帮助我们更好地理解数据的长期趋势
C++中的管道和信号量详细教程及示例 shuai_258 c++c++全套攻略 c++多线程 c++linux
在现代多进程、多线程编程中，管道和信号量是两种常用的进程间通信（IPC）和同步机制。本文将详细介绍这两者的概念、工作原理，并通过C++示例演示如何实现和使用它们。一、管道（Pipe）1.1什么是管道？管道是一种进程间通信（IPC）机制，用于在两个进程之间传递数据。管道是半双工通信方式，意味着数据只能沿一个方向流动：一端写入，另一端读取。管道使用两个文件描述符（fd）：读端：用于从管道中读取数据。写
C++线程、多线程教程详解（全网最全、示例最多、最详细）（第一篇） shuai_258 c++c++全套攻略 c++多线程 c++
目录A、线程/多线程基础一、C++11创建线程的几种方式1.1使用函数指针1.2使用lambda表达式1.3使用成员函数1.4使用可调用对象(Functor)二、定义一个线程类三、join()与detach()的详细用法及区别3.1join()的用法3.2detach()的用法3.3join()与detach()的区别总结四、std::this_thread4.1、主要功能std::this_th
利用TCP编程实现FTP功能嵌入式----HR tcp/ip 网络协议网络
模拟FTP核心原理：客户端连接服务器后，向服务器发送一个文件。文件名可以通过参数指定，服务器端接收客户端传来的文件（文件名随意），如果文件不存在自动创建文件，如果文件存在，那么清空文件然后写入。项目功能介绍：均有服务器和客户端代码，基于TCP写的。在同一路径下，将客户端可执行代码复制到其他的路径下，接下来在不同的路径下运行服务器和客户端。相当于另外一台电脑在访问服务器。客户端和服务器链接成功后出现
【C++】手把手教你写出自己的vector类 Ornamrr C++c++vector
在上一篇博客中，我们学习了vector的基本使用，以及迭代器的失效问题：【C++】深入理解vector类(一)今天我们来模拟实现以下vector类。目录成员变量接口实现构造函数迭代器拷贝构造赋值reserveresizepush_backpop_back实现[]访问成员变量我们先从原码中找出其成员变量：可以看到，原码中有三个成员变量：startfinishend_of_storage数据类型是it
赵玉芳，焦点解决网络初级九期。坚持分享100天百合花开2018
100天即是终点，我是起点。在第一次上课时候，刘老师就告诉我们，坚持写分享100天，可以……，那时就下决心要写到100天，平时即使在忙，也要把分享写完在睡。今天终于写分享写到了100天。实现了愿望。100天是一个时期结束，是另一个时期的开始。即将参加新的课程的学习，在来100天，希望自己收获满满。
Koa2 的洋葱模型是什么？它是如何实现的？极客李华 Koa koa
Koa2的洋葱模型是什么？它是如何实现的？Koa2的洋葱模型是一种中间件执行流程的设计模式，它允许开发者在请求的处理过程中，按照特定的顺序依次执行一系列中间件函数。洋葱模型的实现基于Koa2框架的特性和原理。下面我将通过一个具体的案例来解释洋葱模型的概念和实现。假设我们有一个简单的Koa2应用，用于处理用户的HTTP请求。首先，我们需要创建一个Koa应用实例：constKoa=require('k
登录校验实现——Jwt、Filter/Interceptor 应起忆 java spring
Jwt令牌生成引入依赖，JDK8之后的版本需要引入JAXBjavax.xml.bindjaxb-api2.3.1org.glassfish.jaxbjaxb-runtime2.3.1io.jsonwebtokenjjwt0.9.1写JwtUtilsimportio.jsonwebtoken.Claims;importio.jsonwebtoken.Jwts;importio.jsonwebtoke
动态库静态库制作 Yengi Linux-c linux
文章目录库(函数库)动态库动态库的制作动态库编译命令:静态库静态库的制作库(函数库)将已经实现的某些功能函数封装到一起形成函数库,方便调用,并对代码进行加密保护.(将功能函数封装,不要将main函数封装进去)动态库libname.so特点:(1)库里面的代码并不会编译到可执行文件中,动态库的可执行程序相对较小.(2)由动态库编译的程序,需要运行这个程序的系统环境变量中需要有这个库文件,否则运行不了
设计模式-单例模式 SAO&asuna 设计模式学习设计模式单例模式开发语言
文章目录1.为什么要学习单例模式2.单例模式的类型2.1饿汉式单例2.2懒汉式单例2.2.1一般实现2.2.2sync.once实现2.2.3sync.Mutex实现2.2.4原子引用2.2.5极致性能优化3单例模式的优缺点1.为什么要学习单例模式单例模式，就是在整个进程的过程中，只会存在一个实例。这样做的好处主要是两个：访问控制：访问控制也就是只有这一个口子可以得到该实例，一般是通过全局变量达到
Vue 图片预览功能实现指南繁依Fanyi vue.js 前端 javascript python 人工智能算法开发语言
1.介绍在现代web应用程序中，图片预览功能提升了用户体验，使用户可以在上传图片之前查看图片内容。本文将详细介绍如何在Vue.js应用中实现图片预览功能，包括基本实现、进阶功能、与ElementUI的集成、常见优化技巧以及与其他库的结合使用。2.基本功能实现2.1环境准备确保你的开发环境已经配置好，包括VueCLI和Node.js。如果还没有安装VueCLI，你可以通过以下命令安装：npminst
springboot宠物咖啡馆平台的设计与实现然然学长 spring boot 宠物 java 后端 intellij-idea 开发语言
运行环境环境说明:开发语言:java框架:springboot，vueJDK版本:JDK1.8数据库:mysql5.7+(推荐5.7，8.0也可以)数据库工具:Navicat11+开发软件:idea/eclipse(推荐idea)Maven包:Maven3.3.9+系统详细实现管理员模块的实现用户信息管理基于SpringBoot的宠物咖啡馆平台的设计与实现的系统管理员可以管理用户，可以对用户信息添
【大型网站技术实践】初级篇：借助LVS+Keepalived实现负载均衡爱代码也爱生活 linux运维系统架构 Keepalived lvs
一、负载均衡：必不可少的基础手段1.1找更多的牛来拉车吧当前大多数的互联网系统都使用了服务器集群技术，集群即将相同服务部署在多台服务器上构成一个集群整体对外提供服务，这些集群可以是Web应用服务器集群，也可以是数据库服务器集群，还可以是分布式缓存服务器集群等等。古人有云：当一头牛拉不动车的时候，不要去寻找一头更强壮的牛，而是用两头牛来拉车。在实际应用中，在Web服务器集群之前总会有一台负载均衡服务
写作!我的又一个梦想写不出什么好东西
从小到大，老师总会问我们梦想是什么，如果想实现梦想就要好好学习。我的梦想是当上宇航员，看看外太空。我也为了这个梦想而好好读书过，直到后来大了一些才发现这个梦想是多么遥不可及。当我得知宇航员的必备条件之后，我就彻底放弃了，肯定有人会说，不拼一把，你怎么知道会不会成功。我生活在一般的家庭，一般的环境，城市也是那么一般。中国人杰地灵，能人无数，怎么排也排不到我，所以我就放弃了。就这样我时常问自己，自己的
华南农业大学 OJ数据结构迷宫问题2(C、C++) 打架戴手表、
18720迷宫问题（最短路径）时间限制:1000MS代码长度限制:10KB提交次数:0通过次数:0题型:编程题语言:不限定Description迷宫是一个n*m的矩阵，玩家需要迷宫入口(坐标1,1)出发，寻找路径走到出口(n,m)。请判断玩家能否从迷宫中走出，如果能走出迷宫输出，输出最短的路径长度，否则输出-1。输入格式第一行两个整数n和m，代表n行m列。(1typedefstruct{intro
登录校验，会话技术，Cookie，Session，JWT令牌，统一拦截技术，过滤器FIlter，拦截器Interceptor，全局异常处理器暖阳爱学计算机 springboot spring boot web java
目录1登录校验2会话技术2.1会话技术介绍2.2Cookie2.2Session2.4令牌技术2.5JWT令牌2.5.1介绍2.5.2生成和校验2.5.3登录下发令牌3统一拦截技术3.1过滤器Filter3.1.1过滤器的使用步骤3.1.2代码实现3.1.3细节3.2拦截器Interceptor3.2.1拦截器的使用步骤3.2.2代码实现3.2.3细节4登录功能具体实现步骤5异常处理5.1异常的解
代码随想录算法训练营第三天| 链表01 咕咕鹄鹄算法
一、链表基础链表是一种通过指针串联在一起的线性结构。每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针）。最后一个节点的指针域指向null（空指针的意思）。链表的入口节点称为链表的头结点也就是head。链表类型：单链表、双链表、循环链表单链表：双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。双链表既可以向前查询也可以向后查询。循环链表，就是链表首尾相
静态库制作与使用罗古洞的女婿 Linux与C++
目录1静态库概念2静态库制作3静态库使用4优劣点1静态库概念其实库的概念。就是把一系列函数封装在一个二进制文件中，这一系列的函数的声明可以放在一个头文件中，写代码的时候直接包含头文件然后就可以直接使用库中的函数。在编译的时候要指定库，这样生成的二进制可执行文件是可以直接使用的。这样做有什么好处呢？比如我们发明了某种新的算法，但是我们又不想把源码给别人，那么就可以把它们封装成库，然后通过头文件提供接
Cookie & Session & JWT认证 & Filter & Interceptor aDreamerOutOfTheSky java spring spring boot
文章目录前言一、Cookie和Session二、JWT1.三部分2.使用3.另外一种使用3.1引入依赖3.1定义工具类三、Filter过滤器3.1实现Filter接口，并且增加@WebFilter注解3.2启动类上增加注解3.3Filter过滤实现登陆校验3.4拦截器实现登陆校验总结前言本文介绍了Cookie，Session，JWT，过滤器，拦截器的相关知识一、Cookie和Session浏览器请
用手机赚钱的正规平台有哪些？（分享3款真实靠谱的手机赚钱软件）帮忙赚赏金
用手机赚钱的正规平台有哪些？（分享3款真实靠谱的手机赚钱软件）随着智能手机的普及，许多人已经发现了手机赚钱的潜力。然而，选择正规可靠的手机赚钱平台并不容易。在这篇文章中，我将为您分享三款真实可靠的手机赚钱软件，帮助您实现轻松赚钱的目标。第一款手机赚钱软件是“任务赚钱”。这款软件提供了丰富多样的任务，包括下载APP、观看广告、参与问卷调查等。您只需根据要求完成任务，即可获得相应的酬劳。任务赚钱拥有良
大二上学期详细学习计划学会沉淀。学习
本学习完成目标：项目：书籍：《mysql必知必会》《java核心技术卷》（暂时）加强JavaSE的学习，掌握Java核心Mysql+sql（把牛客上的那50道sql语句题写完）git+maven完成springboot项目（跟着黑马敲）对于每天的Java学习进行记录算法：刷题（多去刷cf上的题，每周15道）针对最近比赛薄弱的地方加强练习（图论，字符串，动态规划，搜索）cf先上1400，牛客和atc
深入解析C++单例模式：从基础到线程安全的高效实现 shuai_258 c++全套攻略 c++c++多线程开发语言 c++qt
引言在C++开发中，单例模式（SingletonPattern）是一种常见且重要的设计模式。它确保类的实例在整个程序生命周期中唯一，并提供一个全局访问点。这在日志管理、配置管理等场景中尤为常见。本篇博客将带你深入了解单例模式的实现原理，并介绍如何在多线程环境下实现线程安全的单例模式。什么是单例模式？单例模式是一种设计模式，其核心思想是确保某个类只能有一个实例，并提供一个全局的访问点。其应用场景包括
用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开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： /** * 获取文本的所有分词结果, 对比