R-Tree的简单介绍

一、R-Tree简介

R-Tree，全称是“Real Tree”，是一种专门为处理多维空间数据（尤其是二维空间数据，如地理坐标）设计的树形数据结构。

简单来说，它就像是一个特殊的目录，将空间数据按照它们的位置和大小进行分组，存储在一系列的矩形区域（称为“节点”）中。每个节点不仅包含空间数据本身，还包含一个能完全覆盖其内部所有数据的矩形边界。这样，当我们查询某个特定区域内的数据时，R-Tree可以通过比较查询区域与节点矩形边界的关系，快速筛选出可能包含所需数据的节点，再逐层深入到更细粒度的节点进行精确查找，大大减少了需要检查的数据量。

二、R-Tree的结构特点

1. 分层结构：R-Tree就像一棵倒立的树，根节点在最上方，叶节点在最下方。根节点包含最少的数据，而叶节点包含最多的数据。每个非叶节点（内部节点）代表一个矩形区域，其子节点（可能是内部节点或叶节点）的矩形区域完全被父节点的矩形区域所覆盖。

2. 节点填充因子：为了保证查询效率，R-Tree通常会限制每个节点容纳的数据数量或其矩形区域的面积。这个比例被称为“填充因子”。合理的填充因子既能减少查询时需要检查的节点数量，又能避免树的高度过高，导致查询效率下降。

3. 超矩形划分：R-Tree的核心在于如何将空间数据划分为大小适中、相互覆盖关系合理的超矩形。常见的划分方法有最小边界矩形（MBR，Minimum Bounding Rectangle）、最小面积包围盒（Min-Area Bounding Box）等。

三、R-Tree的底层实现

1. 插入操作：当向R-Tree插入一个新数据时，需要找到一个合适的叶节点来存放。首先从根节点开始，沿着树向下遍历，直到找到一个与新数据边界有重叠的叶节点。然后，检查该节点是否已满（根据填充因子判断）。如果不满，直接将新数据加入；如果已满，则需要对该节点进行分裂，形成两个新的节点，将部分数据和新数据均匀分配到这两个节点中，并向上更新父节点的超矩形边界。如果父节点也因此满员，继续分裂和更新的过程，直至到达根节点。如果根节点也需要分裂，那么就创建一个新的根节点，将原来的根节点和新分裂的节点作为其子节点。

2. 查询操作：查询时，提供一个目标区域，从根节点开始，依次检查其子节点的超矩形边界是否与目标区域有重叠。如果有重叠，继续深入到子节点及其子孙节点进行相同的操作，直到到达叶节点。最后，收集所有与目标区域有重叠的叶节点中的数据，即为查询结果。

3. 删除操作：删除一个数据时，先找到包含该数据的叶节点，将其从节点中移除。如果移除后节点的数据量低于某个阈值（通常为填充因子的一半），可能需要进行节点合并或兄弟节点间的元素重平衡操作，以保持树的结构稳定和查询效率。

四、示例说明

示例1：插入操作

假设我们有一个空的R-Tree，现在要插入四个城市的位置（矩形边界）：北京、上海、广州、深圳。

  1. 首先，根节点为空，直接将北京插入，作为第一个叶节点。
  2. 插入上海，由于根节点未满，直接放入同一叶节点。
  3. 插入广州，根节点依然未满，放入同一叶节点。
  4. 插入深圳，此时叶节点已满（假设填充因子为1），需要分裂。将北京、上海分为一组，广州、深圳分为另一组，形成两个新的叶节点。更新根节点的超矩形边界，使其覆盖这两个新叶节点。

示例2：查询操作

假设我们要查询所有位于长江以南的城市。

  1. 从根节点开始，其超矩形边界包含了整个中国，与查询区域（长江以南）有重叠。
  2. 深入到包含广州和深圳的叶节点，其超矩形边界与查询区域有重叠，所以返回这两个城市。
  3. 继续深入到包含北京和上海的叶节点，其超矩形边界与查询区域无重叠，结束搜索。

示例3：删除操作

假设我们要删除广州。

  1. 找到包含广州的叶节点，将其从节点中移除。
  2. 由于该节点只剩下深圳一个数据，低于填充因子的一半，考虑合并或重平衡。假设选择合并，将相邻的北京、上海节点合并到此节点，形成一个新的叶节点，包含北京、上海、深圳三个城市，并更新父节点的超矩形边界。

 简单作答：

（简化的示例，没有涵盖完整的R-Tree实现细节（如节点分裂的具体算法、填充因子的管理等），旨在展示基本的插入逻辑。实际应用中，建议使用成熟的R-Tree库（如JTS Topology Suite或GeoTools））

Java版：

import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
import java.util.List;

// 城市位置用矩形表示
class City {
    String name;
    Rectangle2D.Float rectangle;

    public City(String name, float x1, float y1, float x2, float y2) {
        this.name = name;
        this.rectangle = new Rectangle2D.Float(x1, y1, x2 - x1, y2 - y1);
    }

    @Override
    public String toString() {
        return name;
    }
}

// R-Tree节点
class RTreeNode {
    Rectangle2D.Float boundingBox;
    List<RTreeNode> children = new ArrayList<>();
    List<City> cities = new ArrayList<>();

    public RTreeNode(Rectangle2D.Float boundingBox) {
        this.boundingBox = boundingBox;
    }

    public void insertCity(City city) {
        // 此处仅模拟插入操作，简化版R-Tree直接将城市添加到当前节点
        cities.add(city);
        boundingBox = calculateBoundingBox(cities);
    }

    private static Rectangle2D.Float calculateBoundingBox(List<City> cities) {
        float xmin = Float.MAX_VALUE, ymin = Float.MAX_VALUE, xmax = Float.MIN_VALUE, ymax = Float.MIN_VALUE;
        for (var city : cities) {
            xmin = Math.min(xmin, (float) city.rectangle.getMinX());
            ymin = Math.min(ymin, (float) city.rectangle.getMinY());
            xmax = Math.max(xmax, (float) city.rectangle.getMaxX());
            ymax = Math.max(ymax, (float) city.rectangle.getMaxY());
        }
        return new Rectangle2D.Float(xmin, ymin, xmax - xmin, ymax - ymin);
    }

    public void addChild(RTreeNode child) {
        children.add(child);
        boundingBox = combineBoundingBoxes(boundingBox, child.boundingBox);
    }

    private static Rectangle2D.Float combineBoundingBoxes(Rectangle2D.Float bbox1, Rectangle2D.Float bbox2) {
        float xmin = Math.min(bbox1.getMinX(), bbox2.getMinX());
        float ymin = Math.min(bbox1.getMinY(), bbox2.getMinY());
        float xmax = Math.max(bbox1.getMaxX(), bbox2.getMaxX());
        float ymax = Math.max(bbox1.getMaxY(), bbox2.getMaxY());
        return new Rectangle2D.Float(xmin, ymin, xmax - xmin, ymax - ymin);
    }

    public List<City> query(Rectangle2D.Float queryArea) {
        var result = new ArrayList<City>();
        searchNodes(this, queryArea, result);
        return result;
    }

    private void searchNodes(RTreeNode node, Rectangle2D.Float queryArea, List<City> result) {
        if (queryArea.intersects(node.boundingBox)) {
            for (var child : node.children) {
                searchNodes(child, queryArea, result);
            }

            for (var city : node.cities) {
                if (queryArea.contains(city.rectangle)) {
                    result.add(city);
                }
            }
        }
    }

    public void removeCity(City city) {
        cities.remove(city);
        boundingBox = calculateBoundingBox(cities);
        if (cities.size() < 2) {  // 假设填充因子为1，最多容纳两个城市
            // 合并相邻节点（简化版R-Tree仅考虑相邻节点合并）
            if (!children.isEmpty()) {
                var firstChild = children.get(0);
                children.clear();
                cities.addAll(firstChild.cities);
                boundingBox = combineBoundingBoxes(boundingBox, firstChild.boundingBox);
                for (var grandchild : firstChild.children) {
                    addChild(grandchild);
                }
            }
        }
    }
}

// R-Tree类，包含根节点和操作方法
class RTree {
    public RTreeNode root;

    public RTree() {
        root = new RTreeNode(new Rectangle2D.Float(0, 0, .png, 1000));  // 假设根节点包含整个中国
    }

    public void insertCity(City city) {
        root.insertCity(city);
    }

    public List<City> query(Rectangle2D.Float queryArea) {
        return root.query(queryArea);
    }

    public void removeCity(City city) {
        root.removeCity(city);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建R-Tree实例并插入城市（与示例1相同）
        RTree rTree = new RTree();
        rTree.insertCity(new City("北京", 100, 100, 200, 200));
        rTree.insertCity(new City("上海", 300, 300, 400, 400));
        rTree.insertCity(new City("广州", 500, 500, 600, 600));
        rTree.insertCity(new City("深圳", 700, 700, 800, 800));

        // 示例2查询操作
        // 假设长江以南的查询区域为：(x1, y1) = (0, 0), (x2, y2) = (1000, ½ height of China)
        float queryHeight = 500;  // 示例中未提供中国高度，此处假设为500
        Rectangle2D.Float queryArea = new Rectangle2D.Float(0, 0, 1000, queryHeight);

        var result = rTree.query(queryArea);
        System.out.println("Cities located in the south of the Yangtze River:");
        for (var city : result) {
            System.out.println(city);
        }

        // 示例3删除操作
        rTree.removeCity(new City("广州", 500, 500, 600, 600));
    }
}

我们创建了一个接近实际R-Tree结构的简化实现，包括节点的层级结构（尽管在这个简化版本中，所有城市都直接存储在根节点中）和插入、查询、删除方法。RTreeNode类包含节点的边界、子节点列表和城市列表，以及计算边界、搜索节点、合并边界、插入城市、查询、删除城市等方法。RTree类包含根节点和对应的插入、查询、删除方法。

在Main方法中，我们首先创建一个RTree实例并插入四个城市（与示例1相同）。然后，我们根据示例2的描述定义了一个查询区域，表示长江以南的部分。接着，我们调用query方法进行查询，并打印出位于查询区域内的城市名称。最后，我们根据示例3的描述删除城市广州，并触发节点合并。

C++版：

#include <iostream>
#include <vector>
#include <algorithm>
#include <limits>

// 城市位置用矩形表示
struct City {
    std::string name;
    float x1, y1, x2, y2;

    City(const std::string& name, float x1, float y1, float x2, float y2)
        : name(name), x1(x1), y1(y1), x2(x2), y2(y2) {}
};

// R-Tree节点
class RTreeNode {
public:
    struct BoundingBox {
        float xmin, ymin, xmax, ymax;

        BoundingBox(float xmin, float ymin, float xmax, float ymax)
            : xmin(xmin), ymin(ymin), xmax(xmax), ymax(ymax) {}

        bool intersects(const BoundingBox& other) const {
            return !(other.xmax <= xmin || xmax <= other.xmin ||
                     other.ymax <= ymin || ymax <= other.ymin);
        }
    };

    std::vector<RTreeNode> children;
    std::vector<City> cities;
    BoundingBox boundingBox;

    void insertCity(const City& city) {
        // 此处仅模拟插入操作，简化版R-Tree直接将城市添加到当前节点
        cities.push_back(city);
        updateBoundingBox();
    }

    void addChild(const RTreeNode& child) {
        children.push_back(child);
        updateBoundingBox();
    }

    std::vector<City> query(const BoundingBox& queryArea) const {
        std::vector<City> result;
        searchNodes(*this, queryArea, result);
        return result;
    }

    void removeCity(const City& city) {
        auto it = std::find(cities.begin(), cities.end(), city);
        if (it != cities.end()) {
            cities.erase(it);
            updateBoundingBox();

            if (cities.size() < 2) {  // 假设填充因子为1，最多容纳两个城市
                // 合并相邻节点（简化版R-Tree仅考虑相邻节点合并）
                if (!children.empty()) {
                    children[0].cities.insert(children[0].cities.end(), cities.begin(), cities.end());
                    cities.clear();
                    boundingBox = children[0].boundingBox;
                    children.clear();
                }
            }
        }
    }

private:
    static BoundingBox calculateBoundingBox(const std::vector<City>& cities) {
        float xmin = std::numeric_limits<float>::max(), ymin = std::numeric_limits<float>::max(),
              xmax = std::numeric_limits<float>::min(), ymax = std::numeric_limits<float>::min();
        for (const auto& city : cities) {
            xmin = std::min(xmin, city.x1);
            ymin = std::min(ymin, city.y1);
            xmax = std::max(xmax, city.x2);
            ymax = std::max(ymax, city.y2);
        }
        return BoundingBox{xmin, ymin, xmax, ymax};
    }

    void updateBoundingBox() {
        boundingBox = calculateBoundingBox(cities);
        for (const auto& child : children) {
            boundingBox.xmin = std::min(boundingBox.xmin, child.boundingBox.xmin);
            boundingBox.ymin = std::min(boundingBox.ymin, child.boundingBox.ymin);
            boundingBox.xmax = std::max(boundingBox.xmax, child.boundingBox.xmax);
            boundingBox.ymax = std::max(boundingBox.ymax, child.boundingBox.ymax);
        }
    }

    static void searchNodes(const RTreeNode& node, const BoundingBox& queryArea, std::vector<City>& result) {
        if (node.boundingBox.intersects(queryArea)) {
            for (const auto& child : node.children) {
                searchNodes(child, queryArea, result);
            }

            for (const auto& city : node.cities) {
                if (queryArea.xmin <= city.x1 && city.x2 <= queryArea.xmax &&
                    queryArea.ymin <= city.y1 && city.y2 <= queryArea.ymax) {
                    result.push_back(city);
                }
            }
        }
    }
};

// R-Tree类，包含根节点和操作方法
class RTree {
public:
    RTreeNode root;

    RTree() {
        // 假设根节点包含整个中国
        root.boundingBox = RTreeNode::BoundingBox{0, 0, 1000, 1000};
    }

    void insertCity(const City& city) {
        root.insertCity(city);
    }

    std::vector<City> query(const RTreeNode::BoundingBox& queryArea) const {
        return root.query(queryArea);
    }

    void removeCity(const City& city) {
        root.removeCity(city);
    }
};

int main() {
    // 创建R-Tree实例并插入城市（与示例1相同）
    RTree rTree;
    rTree.insertCity({ "北京", 100, 100, 200, 200 });
    rTree.insertCity({ "上海", 300, 300, 400, 400 });
    rTree.insertCity({ "广州", 500, 500, 600, 600 });
    rTree.insertCity({ "深圳", 700, 700, 800, 800 });

    // 示例2查询操作
    // 假设长江以南的查询区域为：(x1, y1) = (0, 0), (x2, y2) = (1000, ½ height of China)
    float queryHeight = 500;  // 示例中未提供中国高度，此处假设为500
    RTreeNode::BoundingBox queryArea{0, 0, 1000, queryHeight};

    auto result = rTree.query(queryArea);
    std::cout << "Cities located in the south of the Yangtze River:" << std::endl;
    for (const auto& city : result) {
        std::cout << city.name << std::endl;
    }

    // 示例3删除操作
    rTree.removeCity({ "广州", 500, 500, 600, 600 });
    return 0;
}

在这个示例中，我们创建了一个接近实际R-Tree结构的简化实现，包括节点的层级结构（尽管在这个简化版本中，所有城市都直接存储在根节点中）和插入、查询、删除方法。

RTreeNode类包含节点的边界、子节点列表和城市列表，以及计算边界、搜索节点、插入城市、查询、删除城市等方法。RTree类包含根节点和对应的插入、查询、删除方法。

在main方法中，我们首先创建一个RTree实例并插入四个城市（与示例1相同）。然后，我们根据示例2的描述定义了一个查询区域，表示长江以南的部分。接着，我们调用query方法进行查询，并打印出位于查询区域内的城市名称。最后，我们根据示例3的描述删除城市广州，并触发节点合并。

C#版：

using System;
using System.Collections.Generic;
using System.Drawing;

// 城市位置用矩形表示
class City
{
    public string Name { get; set; }
    public RectangleF Rectangle { get; set; }

    public City(string name, float x1, float y1, float x2, float y2)
    {
        Name = name;
        Rectangle = new RectangleF(x1, y1, x2 - x1, y2 - y1);
    }
}

// R-Tree节点
class RTreeNode
{
    public RectangleF BoundingBox { get; set; }
    public List<RTreeNode> Children { get; } = new List<RTreeNode>();
    public List<City> Cities { get; } = new List<City>();

    public void InsertCity(City city)
    {
        // 此处仅模拟插入操作，简化版R-Tree直接将城市添加到当前节点
        Cities.Add(city);
        UpdateBoundingBox();
    }

    public void AddChild(RTreeNode child)
    {
        Children.Add(child);
        UpdateBoundingBox();
    }

    public List<City> Query(RectangleF queryArea)
    {
        var result = new List<City>();
        SearchNodes(this, queryArea, result);
        return result;
    }

    public void RemoveCity(City city)
    {
        Cities.Remove(city);
        UpdateBoundingBox();

        if (Cities.Count < 2)  // 假设填充因子为1，最多容纳两个城市
        {
            // 合并相邻节点（简化版R-Tree仅考虑相邻节点合并）
            if (Children.Count > 0)
            {
                Children[0].Cities.AddRange(Cities);
                Cities.Clear();
                BoundingBox = Children[0].BoundingBox;
                Children.Clear();
            }
        }
    }

    private void UpdateBoundingBox()
    {
        BoundingBox = CalculateBoundingBox(Cities);
        foreach (var child in Children)
        {
            BoundingBox = RectangleF.Union(BoundingBox, child.BoundingBox);
        }
    }

    private static RectangleF CalculateBoundingBox(List<City> cities)
    {
        float xmin = float.MaxValue, ymin = float.MaxValue, xmax = float.MinValue, ymax = float.MinValue;
        foreach (var city in cities)
        {
            xmin = Math.Min(xmin, city.Rectangle.X);
            ymin = Math.Min(ymin, city.Rectangle.Y);
            xmax = Math.Max(xmax, city.Rectangle.Right);
            ymax = Math.Max(ymax, city.Rectangle.Bottom);
        }
        return new RectangleF(xmin, ymin, xmax - xmin, ymax - ymin);
    }

    private static void SearchNodes(RTreeNode node, RectangleF queryArea, List<City> result)
    {
        if (queryArea.IntersectsWith(node.BoundingBox))
        {
            foreach (var child in node.Children)
            {
                SearchNodes(child, queryArea, result);
            }

            foreach (var city in node.Cities)
            {
                if (queryArea.Contains(city.Rectangle))
                {
                    result.Add(city);
                }
            }
        }
    }
}

// R-Tree类，包含根节点和操作方法
class RTree
{
    public RTreeNode Root { get; }

    public RTree()
    {
        // 假设根节点包含整个中国
        Root = new RTreeNode { BoundingBox = new RectangleF(0, 0, 1000, 1000) };
    }

    public void InsertCity(City city)
    {
        Root.InsertCity(city);
    }

    public List<City> Query(RectangleF queryArea)
    {
        return Root.Query(queryArea);
    }

    public void RemoveCity(City city)
    {
        Root.RemoveCity(city);
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建R-Tree实例并插入城市（与示例1相同）
        RTree rTree = new RTree();
        rTree.InsertCity(new City("北京", 100, 100, 200, 200));
        rTree.InsertCity(new City("上海", 300, 300, 400, 400));
        rTree.InsertCity(new City("广州", 500, 500, 600, 600));
        rTree.InsertCity(new City("深圳", 700, 700, 800, 800));

        // 示例2查询操作
        // 假设长江以南的查询区域为：(x1, y1) = (0, 0), (x2, y2) = (1000, ½ height of China)
        float queryHeight = 500;  // 示例中未提供中国高度，此处假设为500
        RectangleF queryArea = new RectangleF(0, 0, 1000, queryHeight);

        var result = rTree.Query(queryArea);
        Console.WriteLine("Cities located in the south of the Yangtze River:");
        foreach (var city in result)
        {
            Console.WriteLine(city.Name);
        }

        // 示例3删除操作
        rTree.RemoveCity(new City("广州", 500, 500, 600, 600));
    }
}

在这个示例中，我们创建了一个接近实际R-Tree结构的简化实现，包括节点的层级结构（尽管在这个简化版本中，所有城市都直接存储在根节点中）和插入、查询、删除方法。

RTreeNode类包含节点的边界、子节点列表和城市列表，以及计算边界、搜索节点、插入城市、查询、删除城市等方法。RTree类包含根节点和对应的插入、查询、删除方法。

在Main方法中，我们首先创建一个RTree实例并插入四个城市（与示例1相同）。然后，我们根据示例2的描述定义了一个查询区域，表示长江以南的部分。接着，我们调用Query方法进行查询，并打印出位于查询区域内的城市名称。最后，我们根据示例3的描述删除城市广州，并触发节点合并。

注意：实际应用中，请使用成熟的R-Tree库以获得完整的功能和优化。

以上就是对R-Tree的详细介绍，包括其基本概念、结构特点、底层实现以及通过示例说明其插入、查询、删除操作。R-Tree作为一种高效的空间索引结构，极大地提升了大规模空间数据的检索效率，广泛应用于地理信息系统、搜索引擎、图像处理等领域。希望这次口语化的讲解能让大家对R-Tree有更深刻的理解。

如果有任何疑问，欢迎随时提问！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/529510.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【C语言】扫雷小游戏

【C语言】扫雷小游戏

文章目录 前言一、游戏玩法二、创建文件test.c文件menu()——打印菜单game()——调用功能函数&#xff0c;游戏的实现main()主函数 game.c文件初始化棋盘打印棋盘随机布置雷的位置统计周围雷的个数展开周围一片没有雷的区域计算已排查位置的个数排查雷(包括检测输赢): game.h文…
阅读更多...
RK3568---4G模块驱动实验

RK3568---4G模块驱动实验

作者简介&#xff1a; 一个平凡而乐于分享的小比特&#xff0c;中南民族大学通信工程专业研究生在读&#xff0c;研究方向无线联邦学习 擅长领域&#xff1a;驱动开发&#xff0c;嵌入式软件开发&#xff0c;BSP开发 作者主页&#xff1a;一个平凡而乐于分享的小比特的个人主页…
阅读更多...
什么是电子邮件组，为什么要使用它们？

什么是电子邮件组，为什么要使用它们？

在当今时代&#xff0c;电子邮件无处不在&#xff0c;尤其是对于商业活动而言。电子邮件的重要性不容忽视&#xff0c;因为它在沟通中极为高效。然而&#xff0c;电子邮件也存在降低工作效率和阻碍流程的风险。在这种情况下&#xff0c;电子邮件群组就是最佳的解决方案。什么是…
阅读更多...
蓝桥杯刷题-15-异或和之和-拆位+贡献法⭐⭐(⊙o⊙)

蓝桥杯刷题-15-异或和之和-拆位+贡献法⭐⭐(⊙o⊙)

蓝桥杯2023年第十四届省赛真题-异或和之和 题目描述 给定一个数组 Ai&#xff0c;分别求其每个子段的异或和&#xff0c;并求出它们的和。或者说&#xff0c;对于每组满足 1 ≤ L ≤ R ≤ n 的 L, R &#xff0c;求出数组中第 L 至第 R 个元素的异或和。然后输出每组 L, R 得到…
阅读更多...
C++初阶：stack和queue使用及模拟实现

C++初阶：stack和queue使用及模拟实现

stack的介绍和使用 stack的介绍 堆栈 - C 参考 (cplusplus.com) 翻译 : 1. stack 是一种容器适配器&#xff0c;专门用在具有后进先出操作的上下文环境中&#xff0c;其删除只能从容器的一端进行元素的插入与提取操作。 2. stack 是作为容器适配器被实现的&#xff0c;容器…
阅读更多...
基于单片机和ICL7135多档位数字电压表设计

基于单片机和ICL7135多档位数字电压表设计

**单片机设计介绍&#xff0c;基于单片机和ICL7135多档位数字电压表设计 文章目录 一 概要二、功能设计设计思路 三、 软件设计原理图 五、 程序六、 文章目录 一 概要 基于单片机和ICL7135的多档位数字电压表设计是一个结合了硬件与软件技术的综合性项目。这种设计旨在实现一…
阅读更多...
数据库的基本使用

数据库的基本使用

一、数据库的简介 RDBMS简介&#xff1a; Relational Database Management System,通过表来表示关系类型。当前主要使用两种类型的数据库:关系型数据库和非关系型数据库。所谓的关系型数据库RDBMS是建立在关系模型基础上的数据库&#xff0c;借助于集合代数等数学概念和方法来…
阅读更多...
使用手动连接，将登录框中的取消按钮使用qt4版本的连接到自定义的槽函数中，在自定义的槽函数中调用关闭函数

使用手动连接，将登录框中的取消按钮使用qt4版本的连接到自定义的槽函数中，在自定义的槽函数中调用关闭函数

使用手动连接&#xff0c;将登录框中的取消按钮使用qt4版本的连接到自定义的槽函数中&#xff0c;在自定义的槽函数中调用关闭函数 将登录按钮使用qt4版本的连接到自定义的槽函数中&#xff0c;在槽函数中判断ui界面上输入的账号是否为"admin"&#xff0c;密码是否为…
阅读更多...
Spingboot落地国际化需求，Springboot按照请求的地区返回信息

Spingboot落地国际化需求，Springboot按照请求的地区返回信息

文章目录 一、国际化1、概述2、Spring国际化 二、springboot简单使用国际化1、定义MessageSource2、定义message配置文件3、测试 三、根据请求的地区获取信息1、定义message配置文件2、定义配置类3、基础模板工具4、消息模板定义枚举5、测试一下6、总结 一、国际化 1、概述 国…
阅读更多...
设计模式-结构型-装饰器模式-decorator

设计模式-结构型-装饰器模式-decorator

发票基本类 public class Invoice {public void printInvoice() {System.out.println("打印发票正文");} } 发票正文类 public class Decorator extends Invoice {protected Invoice ticket;public Decorator(Invoice ticket) {this.ticket ticket;}Overridepubl…
阅读更多...
Java配置自定义校验

Java配置自定义校验

1、自定义注解State message、groups、payload package com.zhang.anno;import com.zhang.validartion.StateValidation; import jakarta.validation.Constraint; import jakarta.validation.Payload;import java.lang.annotation.*;import static java.lang.annotation.Eleme…
阅读更多...
javaScript中原型链

javaScript中原型链

一、原型链 js 的对象分为普通对象和函数对象。每个对象都有__proto__ 但是只有函数对象 (非箭头函数) 才有 prototype 属性。 new的过程&#xff1a; 1、创建一个空的简单 javaScript对象 2、将空对象的 __proto__连接到该函数的 prototype 3、将函数的this指向新创建的对象…
阅读更多...
鲁棒线性模型估计(Robust linear model estimation)

鲁棒线性模型估计(Robust linear model estimation)

鲁棒线性模型估计 1.RANSAC算法1.1 算法的基本原理1.2 迭代次数N的计算1.3 参考代码 参考文献 当数据中出现较多异常点时&#xff0c;常用的线性回归OLS会因为这些异常点的存在无法正确估计线性模型的参数&#xff1a; W ( X T X ) − 1 X T Y \qquad \qquad W(X^TX)^{-1}X^T…
阅读更多...
【docker】Docker 简介

【docker】Docker 简介

Docker 简介 什么是虚拟化、容器化?为什么要虚拟化、容器化&#xff1f;虚拟化实现方式应用程序执行环境分层虚拟化常见类别虚拟机容器JVM 之类的虚拟机 常见虚拟化实现主机虚拟化(虚拟机)实现容器虚拟化实现容器虚拟化实现原理容器虚拟化基础之 NameSpace 什么是虚拟化、容器…
阅读更多...
人体跟随小车(旭日x3派、yolov5、目标检测)

人体跟随小车(旭日x3派、yolov5、目标检测)

人体跟随小车&#xff08;yolov5、目标检测&#xff09; 前言最终结果接线实现注意 前言 上板运行的后处理使用cython封装了&#xff0c;由于每个版本的yolo输出的形状不一样&#xff0c;这里只能用yolov5-6.2这个版本。 ①训练自己的模型并部署于旭日x3派参考&#xff1a; ht…
阅读更多...
RuntimeError: Library cublas64_12.dll is not found or cannot be loaded

RuntimeError: Library cublas64_12.dll is not found or cannot be loaded

运行guillaumekln/faster-whisper-large-v2模型进行语音识别的时候报错了 RuntimeError: Library cublas64_12.dll is not found or cannot be loaded 代码&#xff1a; from faster_whisper import WhisperModelmodel WhisperModel("H:\\model\\guillaumekln\\faster…
阅读更多...
【C++】优先级队列（priority_queue）的用法与实现

【C++】优先级队列（priority_queue）的用法与实现

目录 一、概念&#xff1a; 二、仿函数&#xff08;Functor&#xff09;&#xff1a; 概念&#xff1a; 应用&#xff1a; 三、底层实现&#xff1a; 基本操作&#xff1a; 完整代码&#xff1a; 测试示例&#xff1a; 一、概念&#xff1a; 优先级队列&#xff08;pri…
阅读更多...
PostgreSQL入门到实战-第六弹

PostgreSQL入门到实战-第六弹

PostgreSQL入门到实战 PostgreSQL查询语句(三)官网地址PostgreSQL概述PostgreSQL中ORDER BY理论PostgreSQL中ORDER BY实操更新计划 PostgreSQL查询语句(三) 官网地址 声明: 由于操作系统, 版本更新等原因, 文章所列内容不一定100%复现, 还要以官方信息为准 https://www.post…
阅读更多...
tcp的全连接队列和半连接队列满时，客户端再connect发生的情况

tcp的全连接队列和半连接队列满时，客户端再connect发生的情况

首先简单介绍下tcp的全连接队列(accept queue)和半连接队列(syn queue)&#xff0c; 1.客户端发起syn请求时&#xff0c;服务端收到该请求&#xff0c;将其放入到syn queue&#xff0c;然后回复acksyn给客户端。 2.客户端收到acksyn&#xff0c;再发送ack给服务端。 3. 服务端从…
阅读更多...
3、最大池化maxinmum pooling

3、最大池化maxinmum pooling

了解有关最大池化特征提取的更多信息。 简介 在第二课中，我们开始讨论卷积神经网络（convnet）的基础如何进行特征提取。我们了解了这个过程中的前两个操作是在带有 relu 激活的 Conv2D 层中进行的。 在这一课中，我们将看一下这个序列中的第三个（也是最后一个）操作：通过…
阅读更多...
最新文章

Copyright @ 2022~2023