写一个删除数组中某三个数的c++算法

抱歉，这是一个编程问题。以下是一个简单的C语言算法可供参考：

void deleteElements(int arr[], int n) {
int i, j, k;
for (i = 0; i < n; i++) {
if (arr[i] == 10 && arr[i+1] == 20 && arr[i+2] == 30) {
for (j = i + 2; j < n-2; j++) {
arr[j] = arr[j+3];
}
n = n - 3;
}
}
}

此算法会查找数组中是否有连续的10、20和30的组合，并且如果有，则将它们从数组中删除。

相关问题

零起点学算法85——数组中插入一个数

题目描述：

给定一个有序数组和一个数，将这个数插入到数组中，并保证数组仍然有序。

输入格式：

第一行输入一个整数 n，表示数组的长度。

第二行输入 n 个整数，表示给定的有序数组。

第三行输入一个整数 x，表示要插入的数。

输出格式：

输出 n+1 个整数，表示插入新数后的数组。

输入样例：

5
1 3 4 6 8
5

输出样例：

1 3 4 5 6 8

算法1

(暴力枚举) $O(n)$

直接从头到尾遍历数组，找到第一个大于等于插入数的位置，然后将插入数插入到该位置。

时间复杂度

遍历一次数组，时间复杂度为 $O(n)$。

C++ 代码

算法2

(二分查找) $O(logn)$

由于数组是有序的，可以使用二分查找找到第一个大于等于插入数的位置，然后将插入数插入到该位置。

时间复杂度

二分查找的时间复杂度为 $O(logn)$。

C++ 代码

用C++写一个八叉数算法

八叉树算法是一种用于空间划分的数据结构，可以用于三维场景的碰撞检测、光照计算等。以下是一个简单的八叉树算法的实现：

#include <stdio.h>
#include <stdlib.h>

#define MAX_DEPTH 10

typedef struct {
    float x, y, z;
} Point;

typedef struct {
    Point min, max;
} AABB;

typedef struct OctreeNode {
    AABB bounds;
    struct OctreeNode* children[8];
} OctreeNode;

OctreeNode* createOctreeNode(AABB bounds, int depth) {
    OctreeNode* node = (OctreeNode*)malloc(sizeof(OctreeNode));
    node->bounds = bounds;
    for (int i = 0; i < 8; i++) {
        node->children[i] = NULL;
    }
    if (depth < MAX_DEPTH) {
        Point center = { (bounds.min.x + bounds.max.x) / 2,
                         (bounds.min.y + bounds.max.y) / 2,
                         (bounds.min.z + bounds.max.z) / 2 };
        float halfSize = (bounds.max.x - bounds.min.x) / 2;
        for (int i = 0; i < 8; i++) {
            AABB childBounds = {
                .min = { center.x + halfSize * ((i & 1) ? 1 : -1),
                         center.y + halfSize * ((i & 2) ? 1 : -1),
                         center.z + halfSize * ((i & 4) ? 1 : -1) },
                .max = { center.x + halfSize * ((i & 1) ? -1 : 1),
                         center.y + halfSize * ((i & 2) ? -1 : 1),
                         center.z + halfSize * ((i & 4) ? -1 : 1) }
            };
            node->children[i] = createOctreeNode(childBounds, depth + 1);
        }
    }
    return node;
}

void destroyOctreeNode(OctreeNode* node) {
    if (node) {
        for (int i = 0; i < 8; i++) {
            destroyOctreeNode(node->children[i]);
        }
        free(node);
    }
}

int main() {
    AABB bounds = { .min = { -1, -1, -1 }, .max = { 1, 1, 1 } };
    OctreeNode* root = createOctreeNode(bounds, 0);
    destroyOctreeNode(root);
    return 0;
}

这个实现中，我们定义了一个 AABB 结构体表示一个三维空间中的轴对齐包围盒，一个 Point 结构体表示一个三维空间中的点。OctreeNode 结构体表示八叉树的一个节点，包含了一个 AABB 表示节点的包围盒，以及一个指向八个子节点的指针数组。createOctreeNode 函数用于创建一个八叉树节点，它接受一个 AABB 表示节点的包围盒，以及一个深度参数。如果深度小于最大深度，它会递归地创建八个子节点，并将它们存储在 children 数组中。destroyOctreeNode 函数用于销毁一个八叉树节点及其所有子节点。在 main 函数中，我们创建了一个根节点，然后销毁它。