封装红黑树代码

已于 2022-11-24 14:33:43 修改
阅读量408 收藏
点赞数 1
分类专栏： 二叉树 文章标签： 算法 c++ 数据结构
于 2022-11-24 14:28:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DefiniteGoal/article/details/128017525
版权
这篇博客介绍了C++中使用红黑树数据结构的实现，包括初始化、插入节点、删除节点、遍历以及大小计算等功能。作者展示了如何在遍历过程中安全删除节点，并提供了完整的C接口和回调函数。此外，还讨论了后续可能的封装方向，如转换为类和迭代器结构。
摘要由CSDN通过智能技术生成

首先展示测试结果

/*************************************************************************
    > File Name: test_rbtree_api.cc
    > Author: hsz
    > Brief:
    > Created Time: Thu 24 Nov 2022 11:08:34 AM CST
 ************************************************************************/

#include <utils/rbtree_api.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

struct RBData {
    rb_node rbNode;
    int data;
};

rb_root root;

#define rbdata_entry(node) rb_entry(node, RBData, rbNode)

void free_node(rb_node *node)
{
    RBData *data = rbdata_entry(node);
    printf("%s() free(%p) data = %d\n", __func__, data, data->data);
    delete data;
}

bool processData(rb_node *node)
{
    RBData *data = rbdata_entry(node);
    printf("\t%s() data = %d\n", __func__, data->data);
    if (data->data == 4) {
        free_node(rbtree_erase_node(&root, node)); // 测试在遍历时删除节点是否产生异常
    }
    return false;
}

int compare_key(rb_node *node, const void *seed)
{
    int key = *static_cast<const int *>(seed);
    RBData *data = rbdata_entry(node);
    if (data->data < key) {
        return -1;
    }
    if (data->data > key) {
        return 1;
    }

    return 0;
}

int compare_node(rb_node *left, rb_node *right)
{
    RBData *l = rbdata_entry(left);
    RBData *r = rbdata_entry(right);

    if (l->data < r->data) {
        return -1;
    }
    if (l->data > r->data) {
        return 1;
    }

    return 0;
}

int main(int argc, char **argv)
{
    rbtree_init(&root);
    rbtree_foreach(&root, processData);

    printf("\n--->rbtree size = %zu\n", rbtree_size(&root));

    printf("insert to(%p) 1, 3, 5\n", &root);
    RBData *newNode = new RBData;
    newNode->data = 1;
    rbtree_insert(&root, &newNode->rbNode, compare_node);

    newNode = new RBData;
    newNode->data = 3;
    rbtree_insert(&root, &newNode->rbNode, compare_node);

    newNode = new RBData;
    newNode->data = 5;
    rbtree_insert(&root, &newNode->rbNode, compare_node);

    printf("\nforeach rbtree(%p)\n", &root);
    rbtree_foreach(&root, processData);

    printf("\ninsert to(%p) 2, 4\n", &root);
    newNode = new RBData;
    newNode->data = 2;
    rbtree_insert(&root, &newNode->rbNode, compare_node);

    newNode = new RBData;
    newNode->data = 4;
    rbtree_insert(&root, &newNode->rbNode, compare_node);

    printf("\n--->rbtree size = %zu\n", rbtree_size(&root));

    printf("\nforeach rbtree(%p) and will erase data 4\n", &root);
    rbtree_foreach(&root, processData);

    printf("\n--->rbtree size = %zu\n", rbtree_size(&root));

    int num = 3;
    printf("\nerase %d from rbtree(%p)\n", num, &root);
    rbtree_erase(&root, &num, compare_key);

    printf("\nforeach rbtree(%p)\n", &root);
    rbtree_foreach(&root, processData);

    printf("\nclear rbtree\n");
    rbtree_clear(&root, free_node);
    printf("\n--->rbtree size = %zu\n", rbtree_size(&root));
    return 0;
}

在这里插入图片描述

目前是以C接口和回调形式给出，后续会封装成类和iterator，或将参考QMap的封装形式

完整代码

/*************************************************************************
    > File Name: rbtree_base.h
    > Author: hsz
    > Brief: linux rbtree source code
    > Created Time: Sat 11 Dec 2021 01:26:52 PM CST
 ************************************************************************/

#ifndef __RBTREE_H__
#define __RBTREE_H__

struct rb_node
{
    struct rb_node *rb_parent;
    struct rb_node *rb_right;
    struct rb_node *rb_left;
    char            rb_color;
#define RB_RED      0
#define RB_BLACK    1
};

struct rb_root
{
    struct rb_node *rb_node;
};

#define RB_ROOT (struct rb_root){ (struct rb_node *)0, }
#define rb_entry(ptr, type, member) \
    ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))

#ifdef __cplusplus
extern "C"
{
#endif

void rb_insert_color(struct rb_node *node, struct rb_root *root);
void rb_erase(struct rb_node *node, struct rb_root *root);

/* Find logical next and previous nodes in a tree */
struct rb_node *rb_next(struct rb_node *);
struct rb_node *rb_prev(struct rb_node *);
struct rb_node *rb_first(struct rb_root *);
struct rb_node *rb_last(struct rb_root *);

/* Fast replacement of a single node without remove/rebalance/add/rebalance */
void rb_replace_node(struct rb_node *victim, struct rb_node *newnode,
                struct rb_root *root);

#ifdef __cplusplus
}
#endif

static inline void rb_link_node(struct rb_node *node, struct rb_node *parent,
                struct rb_node **link)
{
    node->rb_parent = parent;
    node->rb_color = RB_RED;
    node->rb_left = node->rb_right = (struct rb_node *)0;
    *link = node;
}

#endif // __RBTREE_H__

/*************************************************************************
    > File Name: rbtree_base.cpp
    > Author: hsz
    > Brief:
    > Created Time: Sun 12 Dec 2021 11:11:06 PM CST
 ************************************************************************/

#include "rbtree_base.h"

static void __rb_rotate_left(struct rb_node *node, struct rb_root *root)
{
    struct rb_node *right = node->rb_right;

    if ((node->rb_right = right->rb_left))
        right->rb_left->rb_parent = node;
    right->rb_left = node;

    if ((right->rb_parent = node->rb_parent))
    {
        if (node == node->rb_parent->rb_left)
            node->rb_parent->rb_left = right;
        else
            node->rb_parent->rb_right = right;
    }
    else
        root->rb_node = right;
    node->rb_parent = right;
}

static void __rb_rotate_right(struct rb_node *node, struct rb_root *root)
{
    struct rb_node *left = node->rb_left;

    if ((node->rb_left = left->rb_right))
        left->rb_right->rb_parent = node;
    left->rb_right = node;

    if ((left->rb_parent = node->rb_parent))
    {
        if (node == node->rb_parent->rb_right)
            node->rb_parent->rb_right = left;
        else
            node->rb_parent->rb_left = left;
    }
    else
        root->rb_node = left;
    node->rb_parent = left;
}

void rb_insert_color(struct rb_node *node, struct rb_root *root)
{
    struct rb_node *parent, *gparent;

    while ((parent = node->rb_parent) && parent->rb_color == RB_RED)
    {
        gparent = parent->rb_parent;

        if (parent == gparent->rb_left)
        {
            {
                register struct rb_node *uncle = gparent->rb_right;
                if (uncle && uncle->rb_color == RB_RED)
                {
                    uncle->rb_color = RB_BLACK;
                    parent->rb_color = RB_BLACK;
                    gparent->rb_color = RB_RED;
                    node = gparent;
                    continue;
                }
            }

            if (parent->rb_right == node)
            {
                register struct rb_node *tmp;
                __rb_rotate_left(parent, root);
                tmp = parent;
                parent = node;
                node = tmp;
            }

            parent->rb_color = RB_BLACK;
            gparent->rb_color = RB_RED;
            __rb_rotate_right(gparent, root);
        } else {
            {
                register struct rb_node *uncle = gparent->rb_left;
                if (uncle && uncle->rb_color == RB_RED)
                {
                    uncle->rb_color = RB_BLACK;
                    parent->rb_color = RB_BLACK;
                    gparent->rb_color = RB_RED;
                    node = gparent;
                    continue;
                }
            }

            if (parent->rb_left == node)
            {
                register struct rb_node *tmp;
                __rb_rotate_right(parent, root);
                tmp = parent;
                parent = node;
                node = tmp;
            }

            parent->rb_color = RB_BLACK;
            gparent->rb_color = RB_RED;
            __rb_rotate_left(gparent, root);
        }
    }

    root->rb_node->rb_color = RB_BLACK;
}

static void __rb_erase_color(struct rb_node *node, struct rb_node *parent,
                 struct rb_root *root)
{
    struct rb_node *other;

    while ((!node || node->rb_color == RB_BLACK) && node != root->rb_node)
    {
        if (parent->rb_left == node)
        {
            other = parent->rb_right;
            if (other->rb_color == RB_RED)
            {
                other->rb_color = RB_BLACK;
                parent->rb_color = RB_RED;
                __rb_rotate_left(parent, root);
                other = parent->rb_right;
            }
            if ((!other->rb_left ||
                 other->rb_left->rb_color == RB_BLACK)
                && (!other->rb_right ||
                other->rb_right->rb_color == RB_BLACK))
            {
                other->rb_color = RB_RED;
                node = parent;
                parent = node->rb_parent;
            }
            else
            {
                if (!other->rb_right ||
                    other->rb_right->rb_color == RB_BLACK)
                {
                    register struct rb_node *o_left;
                    if ((o_left = other->rb_left))
                        o_left->rb_color = RB_BLACK;
                    other->rb_color = RB_RED;
                    __rb_rotate_right(other, root);
                    other = parent->rb_right;
                }
                other->rb_color = parent->rb_color;
                parent->rb_color = RB_BLACK;
                if (other->rb_right)
                    other->rb_right->rb_color = RB_BLACK;
                __rb_rotate_left(parent, root);
                node = root->rb_node;
                break;
            }
        }
        else
        {
            other = parent->rb_left;
            if (other->rb_color == RB_RED)
            {
                other->rb_color = RB_BLACK;
                parent->rb_color = RB_RED;
                __rb_rotate_right(parent, root);
                other = parent->rb_left;
            }
            if ((!other->rb_left ||
                 other->rb_left->rb_color == RB_BLACK)
                && (!other->rb_right ||
                other->rb_right->rb_color == RB_BLACK))
            {
                other->rb_color = RB_RED;
                node = parent;
                parent = node->rb_parent;
            }
            else
            {
                if (!other->rb_left ||
                    other->rb_left->rb_color == RB_BLACK)
                {
                    register struct rb_node *o_right;
                    if ((o_right = other->rb_right))
                        o_right->rb_color = RB_BLACK;
                    other->rb_color = RB_RED;
                    __rb_rotate_left(other, root);
                    other = parent->rb_left;
                }
                other->rb_color = parent->rb_color;
                parent->rb_color = RB_BLACK;
                if (other->rb_left)
                    other->rb_left->rb_color = RB_BLACK;
                __rb_rotate_right(parent, root);
                node = root->rb_node;
                break;
            }
        }
    }
    if (node)
        node->rb_color = RB_BLACK;
}

void rb_erase(struct rb_node *node, struct rb_root *root)
{
    struct rb_node *child, *parent;
    int color;

    if (!node->rb_left)
        child = node->rb_right;
    else if (!node->rb_right)
        child = node->rb_left;
    else
    {
        struct rb_node *old = node, *left;

        node = node->rb_right;
        while ((left = node->rb_left))
            node = left;
        child = node->rb_right;
        parent = node->rb_parent;
        color = node->rb_color;

        if (child)
            child->rb_parent = parent;
        if (parent)
        {
            if (parent->rb_left == node)
                parent->rb_left = child;
            else
                parent->rb_right = child;
        }
        else
            root->rb_node = child;

        if (node->rb_parent == old)
            parent = node;
        node->rb_parent = old->rb_parent;
        node->rb_color = old->rb_color;
        node->rb_right = old->rb_right;
        node->rb_left = old->rb_left;

        if (old->rb_parent)
        {
            if (old->rb_parent->rb_left == old)
                old->rb_parent->rb_left = node;
            else
                old->rb_parent->rb_right = node;
        } else
            root->rb_node = node;

        old->rb_left->rb_parent = node;
        if (old->rb_right)
            old->rb_right->rb_parent = node;
        goto color;
    }

    parent = node->rb_parent;
    color = node->rb_color;

    if (child)
        child->rb_parent = parent;
    if (parent)
    {
        if (parent->rb_left == node)
            parent->rb_left = child;
        else
            parent->rb_right = child;
    }
    else
        root->rb_node = child;

 color:
    if (color == RB_BLACK)
        __rb_erase_color(child, parent, root);
}

/*
 * This function returns the first node (in sort order) of the tree.
 */
struct rb_node *rb_first(struct rb_root *root)
{
    struct rb_node *n;

    n = root->rb_node;
    if (!n)
        return (struct rb_node *)0;
    while (n->rb_left)
        n = n->rb_left;
    return n;
}

struct rb_node *rb_last(struct rb_root *root)
{
    struct rb_node *n;

    n = root->rb_node;
    if (!n)
        return (struct rb_node *)0;
    while (n->rb_right)
        n = n->rb_right;
    return n;
}

struct rb_node *rb_next(struct rb_node *node)
{
    /* If we have a right-hand child, go down and then left as far
       as we can. */
    if (node->rb_right) {
        node = node->rb_right;
        while (node->rb_left)
            node = node->rb_left;
        return node;
    }

    /* No right-hand children.  Everything down and left is
       smaller than us, so any 'next' node must be in the general
       direction of our parent. Go up the tree; any time the
       ancestor is a right-hand child of its parent, keep going
       up. First time it's a left-hand child of its parent, said
       parent is our 'next' node. */
    while (node->rb_parent && node == node->rb_parent->rb_right)
        node = node->rb_parent;

    return node->rb_parent;
}

struct rb_node *rb_prev(struct rb_node *node)
{
    /* If we have a left-hand child, go down and then right as far
       as we can. */
    if (node->rb_left) {
        node = node->rb_left;
        while (node->rb_right)
            node = node->rb_right;
        return node;
    }

    /* No left-hand children. Go up till we find an ancestor which
       is a right-hand child of its parent */
    while (node->rb_parent && node == node->rb_parent->rb_left)
        node = node->rb_parent;

    return node->rb_parent;
}

void rb_replace_node(struct rb_node *victim, struct rb_node *newnode,
             struct rb_root *root)
{
    struct rb_node *parent = victim->rb_parent;

    /* Set the surrounding nodes to point to the replacement */
    if (parent) {
        if (victim == parent->rb_left)
            parent->rb_left = newnode;
        else
            parent->rb_right = newnode;
    } else {
        root->rb_node = newnode;
    }
    if (victim->rb_left)
        victim->rb_left->rb_parent = newnode;
    if (victim->rb_right)
        victim->rb_right->rb_parent = newnode;

    /* Copy the pointers/colour from the victim to the replacement */
    *newnode = *victim;
}

/*************************************************************************
    > File Name: rbtree_api.h
    > Author: hsz
    > Brief:
    > Created Time: Wed 23 Nov 2022 11:10:12 AM CST
 ************************************************************************/

#ifndef __UTILS_RBTREE_API_H__
#define __UTILS_RBTREE_API_H__

#include "rbtree_base.h"
#include "utils.h"

EXTERN_C_BEGIN

void rbtree_init(rb_root *root);
void rbtree_clear(rb_root *root, void (*free_node_cb)(rb_node *));

/**
 * @brief 将node插入到红黑树root
 * 
 * @param root 红黑树
 * @param node 红黑树节点
 * @param compare_callback 比较回调。返回0表示相等，返回1往右子树放，返回-1往左子树放。
 * @return rb_node* 成功返回插入的节点地址，失败返回nullptr
 */
rb_node *rbtree_insert(rb_root *root, rb_node *newNode, int (*compare_callback)(rb_node *, rb_node *));

/**
 * @brief 从红黑树中删除等于seed的节点，但不释放此节点内存
 * 
 * @param root 红黑树根节点
 * @param seed 种子
 * @param equal_callback 判断相等回调
 * @return rb_node* 成功返回删除的节点，失败返回nullptr
 */
rb_node *rbtree_erase(rb_root *root, const void *seed, int (*compare_callback)(rb_node *, const void *));

rb_node *rbtree_erase_node(rb_root *root, rb_node *node);

/**
 * @brief 对红黑树进行有序遍历(在遍历中删除是不安全的?)
 * 
 * @param root 红黑树根节点
 * @param data_callback 数据处理回调. 从循环中退出返回true，不退出返回false
 * @return true 遍历成功
 * @return false 遍历失败
 */
bool rbtree_foreach(rb_root *root, bool (*data_callback)(rb_node *node));

/**
 * @brief 从红黑树中查找与seed相等的节点
 * 
 * @param root 红黑树根节点
 * @param seed 种子数据
 * @param compare_callback 同rbtree_erase的compare_callback
 * @return rb_node* 返回查找到的节点，失败返回nullptr
 */
rb_node *rbtree_search(rb_root *root, const void *seed, int (*compare_callback)(rb_node *, const void *));

size_t rbtree_size(rb_root *root);

EXTERN_C_END

#endif // __UTILS_RBTREE_API_H__


/*************************************************************************
    > File Name: rbtree_api.cpp
    > Author: hsz
    > Brief:
    > Created Time: Wed 23 Nov 2022 03:56:21 PM CST
 ************************************************************************/

#include "rbtree_api.h"
#include <assert.h>

void rbtree_init(rb_root *root)
{
    if (root) {
        root->rb_node = nullptr;
    }
}

void rbtree_clear(rb_root *root, void (*free_node_cb)(rb_node *))
{
    if (root == nullptr) {
        return;
    }
    struct rb_node *node = nullptr;
    while (node = root->rb_node) {
        rb_erase(node, root);
        if (eular_likely(free_node_cb != nullptr)) {
            free_node_cb(node);
        }
    }
}

rb_node *rbtree_insert(rb_root *root, rb_node *newNode, int (*compare_callback)(rb_node *, rb_node *))
{
    if (root == nullptr || compare_callback == nullptr) {
        return nullptr;
    }

    struct rb_node **node = &(root->rb_node);
    struct rb_node *parent = nullptr;
    bool exists = false;
    int compareResult = 0;
    while (nullptr != (*node)) {
        parent = *node;
        compareResult = compare_callback(parent, newNode);
        if (compareResult < 0) { // parent < newNode
            node = &(*node)->rb_right;
        } else if (compareResult > 0) {
            node = &(*node)->rb_left;
        } else {
            exists = true;
            break;
        }
    }

    if (!exists) {
        rb_link_node(newNode, parent, node);
        rb_insert_color(newNode, root);
    }

    return exists ? nullptr : newNode;
}

rb_node *rbtree_erase(rb_root *root, const void *seed, int (*compare_callback)(rb_node *, const void *))
{
    if (root == nullptr || seed == nullptr || compare_callback == nullptr) {
        return nullptr;
    }

    struct rb_node *eraseNode = rbtree_search(root, seed, compare_callback);
    if (eraseNode != nullptr) {
        rb_erase(eraseNode, root);
    }

    return eraseNode;
}

bool isValidNode(rb_root *root, rb_node *node)
{
    assert(root && node);
    rb_node *parent = node;
    bool valid = false;
    while (parent) {
        if (parent == root->rb_node) {
            valid = true;
            break;
        }
        if (parent == parent->rb_parent) { // 需确定根节点的rb_parent是否为空，不为空则会死循环
            break;
        }
        parent = parent->rb_parent;
    }

    return valid;
}

rb_node *rbtree_erase_node(rb_root *root, rb_node *node)
{
    if (root == nullptr || node == nullptr) {
        return nullptr;
    }
    assert(isValidNode(root, node));
    
    rb_erase(node, root);
    return node;
}

bool rbtree_foreach(rb_root *root, bool (*data_callback)(rb_node *node))
{
    if (root == nullptr || data_callback == nullptr) {
        return false;
    }

    struct rb_node *begin = rb_first(root);
    struct rb_node *next = begin;
    struct rb_node *end = rb_last(root);

    if (begin == nullptr) { // no nodes
        return true;
    }

    // NOTE 由于遍历时是有序的，故保存next后，即使在回调中删除begin节点也不会导致循环出现问题，因为下一个节点本就应该是next
    while (begin != end) {
        next = rb_next(next);
        if (data_callback(begin)) {
            return true;
        }
        begin = next;
    }

    data_callback(end);
    return true;
}

rb_node *rbtree_search(rb_root *root, const void *seed, int (*compare_callback)(rb_node *, const void *))
{
    if (root == nullptr || compare_callback == nullptr) {
        return nullptr;
    }

    struct rb_node *curr = root->rb_node;
    bool exist = false;
    int compareResult = 0;
    while (curr) {
        compareResult = compare_callback(curr, seed);
        if (compareResult < 0) {
            curr = curr->rb_left;
        } else if (compareResult > 0) {
            curr = curr->rb_right;
        } else {
            exist = true;
            break;
        }
    }

    return exist ? curr : nullptr;
}

size_t rbtree_size(rb_root *root)
{
    if (root == nullptr) {
        return 0;
    }

    size_t count = 0;
    struct rb_node *begin = rb_first(root);
    struct rb_node *next = begin;
    struct rb_node *end = rb_last(root);

    if (begin == nullptr) {
        return 0;
    }

    while (begin != end) {
        next = rb_next(next);
        begin = next;
        ++count;
    }

    ++count; // for end
    return count;
}
山有木兮啊
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树封装map&&set源代码
06-01
封装红黑树的Map和Set源代码通常会包括以下关键部分： 1. **节点定义**：首先，需要定义红黑树的节点结构，包括键、值、颜色属性、左子节点和右子节点。例如： ```java class Node { Key key; Value value; ...
linux kernel中提取并适配的红黑树的c代码，支持cpp混合环境中编译
08-12
在这个项目中，开发者可能已经解决了C和C++之间的 ABI 兼容性问题，使得C语言编写的红黑树代码能够在C++环境中无缝集成。 在C++中使用红黑树时，需要注意的一些关键点可能包括： 1. **命名约定**：由于C++有命名...
红黑树C++实现
01-27
在实际的C++实现中，我们通常会定义一个红黑树类，封装节点的创建、插入、删除、查找等方法，并提供友好的接口供用户使用。同时，为了提高代码的可读性和可维护性，可以采用模板类的方式，使红黑树可以处理不同类型...
红黑树算法的实现
06-05
为了在VS中运行，我们需要创建一个C#项目，将这些节点和操作封装在一个类库中，并编写测试用例来验证红黑树的正确性。可以创建一个`RedBlackTree`类，包含插入、删除、查找等方法，以及一些辅助方法如旋转和调整颜色...
红黑树：红黑树的Matlab实现-matlab开发
05-30
红黑树是一种自平衡二叉查找树，...通过阅读和分析这些代码，我们可以深入理解红黑树的内部工作机制和Matlab面向对象编程的应用。对于学习数据结构和算法，以及提升Matlab编程技能来说，这是一个非常有价值的实践案例。
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 397
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
递归、搜索与回溯算法
无聊_人的博客
08-29 4113
所谓的递归其实就是函数自己调用自己的情况。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 1266
分两种情况，一种是节点 i 到节点 j 的最短路径经过节点 k，grid[i][j][k] = grid[i][k][k-1] + grid[k][j][k-1]；另一种情况，节点 i 到节点 j 的最短路径不经过节点 k，grid[i][j][k] = grip[i][j][k-1]；刚开始初始化 k 是不确定的，如果赋值为1，那么不能知道节点 i 到节点 j 经过1个节点的最短距离，所以只能把 k 赋值为0，本题中节点0是无意义的，节点是从1到n。本题求的是最小值，所以其余值初始化为最大值。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 4510
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
精选算法编程题
A18937260063的博客
08-30 336
数组编程
冒泡排序算法
m0_74051652的博客
08-28 1252
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，这意味着数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（或说是排序的开头位置），就如同水中的气泡一样上升到水面。冒泡排序的写法可以简单分为两种方式，分别是：前同后异、前异后同。
[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
Y-puyu 的博客
08-31 190
【代码】[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
Java算法之插入排序（Insertion Sort）
weixin_38959316的博客
08-29 358
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这个过程像打牌时整理手中的牌一样，逐步将数据排列成有序。插入排序虽然在实际应用中的效率不如一些更高级的排序算法，但它的原理简单，易于实现，且对于部分有序的数据集表现良好。
977.有序数组的平方
argcargv的博客
08-31 116
将双指针l、r分别从头和尾向中间移动（简化了很多，不用再处理边界条件）：基本相同写法（将双指针从中将最小值的下表，向两边移动）组成的新数组，要求也按。
数据结构与算法——Java实现 2.衡量算法好坏的标准
m0_73983707的博客
08-27 457
为了对 f(n)进行化简，应当抓住主要矛盾，找到一个变化趋势与之相近的表示法。与时间复杂度类似，一般也使用大O表示法来衡量：一个算法执行随数据规模增大，而。假设算法要处理的数据规模是n，代码总的执行行数用函数 f(n)来表示。③ 不同底数的对数，渐进上界可以用一个对数函数 log n 表示。时间复杂度是用来衡量:一个算法的执行，随数据规模增大，而。② 多项式中数量规模更小(低次项)的表达式。① 表达式中相乘的常量，可以省略。④ 类似的，对数的常数次幂可省略。已知 f(n) ，求 g(n)
【0-1背包变种】力扣2787. 将一个数字表示成幂的和的方案数
sjsjs11的博客
08-31 247
0-1背包问题的变种，首先我们定义一个一维数组f，f[s]表示可以用不同整数的 x 次幂来表示 s 的所有组合方式的数量。这个公式的意思是：当前目标数 s 的组合方式 f[s] 应该包括所有能组合成 s-v 的组合方式 f[s-v]，因为你可以通过加上 v 来实现 s。最后返回 f[n]，它表示用 x 次幂的整数来组合成 n 的所有不同方案的数量。比方说，n = 160 且 x = 3 ，一个表示 n 的方法是 n = 23 + 33 + 53。输入：n = 10, x = 2。
基于用户的协同过滤以及ALS的混合召回算法
zhangdonghuirjdd的博客
08-28 1276
基于用户的协同过滤是一种经典的推荐算法，它通过寻找具有相似兴趣的用户来推荐物品，它关注的是用户之间的相似性而非物品之间的相似性。然而，在大规模数据集上，这种方法可能会因为计算用户相似度矩阵所需的大量计算资源而变得不太实用。基于用户之间的相似度来进行推荐。在基于用户的协同过滤中，系统寻找与目标用户兴趣相似的其他用户，然后推荐这些相似用户喜欢的物品给目标用户。ALS 的优点（如处理稀疏数据的能力）来改进基于用户的协同过滤。因为不同用户直接的评分范围差异比较大 使用余弦相似度来计算。
每天学习一个基础算法之二分查找
gybhh的博客
08-30 639
前一篇博客我们已经介绍学习了顺序查找法，它在对有序数据查找时效率较低，而当我们要对有序数据进行查找时就要用到二分查找法了，所以今天我们要学习的就是二分查找法。
132. 分割回文串 II
最新发布
m0_48711099的博客
09-01 79
【代码】132. 分割回文串 II。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值