二叉树排序中实现查找算法c语言,算法_数据结构二叉树(排序的)插入、查找、删除代码...-程序员宅基地
技术标签： 二叉树排序中实现查找算法c语言
二叉树的关键概念：
每个节点是一个自引用结构体，形式如下：
struct TreeNode {
struct TreeNode *leftPtr;
int data;
struct TreeNode *rightPtr;
};
部节点开始，每个节点拥有两个子节点(NULL或者一个节点)，称为左节点与右节点，每个节点的左部分与右部分又分别称为该节点的左子树与右子树。
每个节点的键值大于左节点，小于右节点；每个节点的键值大于左子树所有节点的键值，小于右子树所有节点的键值。所以二叉树是按节点键值排序的数据结构。
二叉树的某个节点，如果不是叶节点，则有左子树或右子树，是一个更小的树，因此可以递归地处理关于树的一些问题。
二叉树的插入
思路：将要插入节点的键值与根节点键值比较，如果小于根节点键值，则插入根节点的左子树，如果大于根节点的键值，则插入根节点的右子树，插入子树相当于插入一个更小的树，因此可以用递归方法实现，直到找到没有子树的节点，将新节点插到其下面。注意，新节点插入后，最终只会成为叶节点。
函数代码如下(测试插入、删除、打印功能的源码在最后面，此处只给出插入函数代码)：
void insertNode(TreeNodePtr *treePtr, int value)
{
if (*treePtr == NULL) {
*treePtr = malloc(sizeof(TreeNode));
if (*treePtr != NULL) {
(*treePtr)->data = value;
(*treePtr)->leftPtr = NULL;
(*treePtr)->rightPtr = NULL;
}
else {
printf("%d not inserted. No memory available.\n", value);
}
}
else {
if (value < (*treePtr)->data) {
insertNode(&((*treePtr)->leftPtr), value);
}
else {
if (value >(*treePtr)->data) {
insertNode(&((*treePtr)->rightPtr), value);
}
else {
printf("dup");
}
}
}
}
1
二叉树的查找
思路：与插入类似，从根节点开始，将查找的键值与根节点键值比较，若相等，则返回指向该节点的指针，若查找的键值比它大，则从根节点的右子树开始查找，若查找的键值比它小，则从根节点的左子树开始查找。可以用递归方法实现，类似于插入。这里我用迭代实现，能用迭代还是用迭代，因为递归开销比较大。
函数代码如下：
TreeNode *binaryTreeSereach(TreeNode * const treePtr, int value)
{
TreeNode *tempPtr = treePtr;
while (tempPtr != NULL && tempPtr->data != value)
{
if (value > tempPtr->data)
tempPtr = tempPtr->rightPtr;
else
tempPtr = tempPtr->leftPtr;
}
return tempPtr;
}
1
2
3
4
二叉树的删除
相比于二叉树的插入和查找，删除一个节点要复杂一些，原因是要保证二叉树的排序性质。二叉树删除有如下三种情况：
1.
删除节点是叶节点，即没有子节点，或者说左右子节点都是NULL。这种情况下，只需要把删除节点的父节点中对应的指针指向NULL即可。然后释放掉删除节点的空间。
2.
删除节点有一个子节点(左子节点或右子节点)，这种情况下，把删除节点的父节点中对应的指针指向删除节点的子节点即可。然后释放掉删除节点的空间
3.
删除节点有两个子节点，这种情况下，必须要找到一个替代删除节点的替代节点，并且保证二叉树的排序性。根据二叉树的排序性，可知替代节点的键值必须最接近删除节点键值。比删除节点键值小的所有键值中最大那个，或者是比删除节点键值大的所有键值中最小的那个，是符合要求的。这两个键值所在的节点分别在删除节点的左子树中最右边的节点，删除节点右子树中最左边的节点。以从左子树中找最大键值节点为例，算法如下：
找到删除节点以及它的父节点
在删除节点的左子树中，向下向右遍历，找到替代节点以及它的父节点
删除节点的父节点中对应的指针指向替代节点
替代节点中的右子节点指针指向删除节点的右子树
如果替代节点的父节点不是删除节点，则将替代节点的左子节点指针指向删除节点的左子树，并且替代节点的父节点中对应的指针指向替代节点的左子节点
释放删除节点的空间 注意：第二步中找到的替代节点，可能会有左子树，但一定没有右子树。第五步要判断替代节点的父节点不是删除节点后，才将替代节点的左子节点指针指向删除节点的左子树，否则会出现替代节点左子节点指针指向自己的情况，从而丢失替代节点的左子树。
另外，还有一种实现相同效果的的方法，即将替代节点中的数据赋给删除节点，然后释放替代节点的空间。这种方法其实是删除了替代节点，并没有真正删除想要删除的节点。而且如果节点包括一个键值和很多其他的数据，则赋值语句会很多。在最后面的测试过程中，我也给出了这个函数的实现，void
deleteNode2(TreeNode **treePtrP, int value)
代码如下：
void deleteNode(TreeNode **treePtrP, int value)
{
TreeNode *deleteNodePtr = *treePtrP;
TreeNode *parentNodeOfDeletePtr = NULL;
TreeNode *substituteNodePtr;
TreeNode *parentNodeOfSubstitutePtr;
//find deleNode and its parentNode
while (deleteNodePtr != NULL && value != deleteNodePtr->data)
{
parentNodeOfDeletePtr = deleteNodePtr;
if (deleteNodePtr->data > value)
{
deleteNodePtr = deleteNodePtr->leftPtr;
}
else
{
deleteNodePtr = deleteNodePtr->rightPtr;
}
}
//case that can't find such Node
if (deleteNodePtr == NULL)
{
printf("no such Node, delete fail\n\n");
return;
}
//delete a leafNode
if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)
{
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = NULL;
}
else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
{
parentNodeOfDeletePtr->leftPtr = NULL;
}
else
{
parentNodeOfDeletePtr->rightPtr = NULL;
}
}
//delete a Node which has a left child Node
else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)
{
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = deleteNodePtr->leftPtr;
}
else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;
else
parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;
}
//delete a Node which has a right child Node
else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)
{
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = deleteNodePtr->rightPtr;
}
else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;
else
parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;
}
//delete a Node which has a left and a right child Node
else
{
parentNodeOfSubstitutePtr = deleteNodePtr;
substituteNodePtr = deleteNodePtr->leftPtr;
//search down and right to find substituteNode and its parentNode
while (substituteNodePtr->rightPtr != NULL)
{
parentNodeOfSubstitutePtr = substituteNodePtr;
substituteNodePtr = substituteNodePtr->rightPtr;
}
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = substituteNodePtr;
}
else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
{
parentNodeOfDeletePtr->leftPtr = substituteNodePtr;
}
else
{
parentNodeOfDeletePtr->rightPtr = substituteNodePtr;
}
substituteNodePtr->rightPtr = deleteNodePtr->rightPtr;
if (parentNodeOfSubstitutePtr != deleteNodePtr)
{
substituteNodePtr->leftPtr = deleteNodePtr->leftPtr;
if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)
{
parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;
}
else
{
parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;
}
}
}
free(deleteNodePtr);
}
二叉树的打印
从根节点开始，先输出右子树，再输出节点键值，再输出左子树。采用递归法 代码如下：
void outputTree(TreeNodePtr treePtr, int spaces)
{
int loop;
while (treePtr != NULL) {
outputTree(treePtr->rightPtr, spaces + 4);
for (loop = 1; loop <= spaces; loop++) {
printf(" ");
}
printf("%d\n", treePtr->data);
outputTree(treePtr->leftPtr, spaces + 4);
treePtr = NULL;
}
}
1
2
3
4
5
6
测试结果截图
测试插入、删除、打印树源码
#include
#include
#include
struct TreeNode {
struct TreeNode *leftPtr;
int data;
struct TreeNode *rightPtr;
};
typedef struct TreeNode TreeNode;
void insertNode(TreeNode **treePtr, int value);
TreeNode * binaryTreeSereach(TreeNode * const treePtr, int value);
void deleteNode(TreeNode **treePtrP, int value);
void outputTree(TreeNode *treePtr, int spaces);
void deleteNode2(TreeNode **treePtrP, int value);
int main(void)
{
int arr[] = { 45, 83, 28, 97, 71, 40, 18, 77, 99, 92, 72, 69, 44, 32, 19, 11 };
int i;
int item;
int totalSpaces = 0;
TreeNode *rootPtr = NULL;
srand(time(NULL));
printf("The numbers being placed in the tree are:\n\n");
for (i = 0; i < sizeof(arr) / sizeof(int); i++) {
item = arr[i];
printf("=", item);
insertNode(&rootPtr, item);
}
printf("\n\n\nnow the tree is:\n\n");
if (rootPtr == NULL)
printf("empty tree\n");
else
outputTree(rootPtr, totalSpaces);
//random delete Nodes, then output the tree
while (rootPtr != NULL)
{
item = rand() % 16;
printf("\n\nafter delete %d:\n\n", arr[item]);
deleteNode2(&rootPtr, arr[item]);
if (rootPtr == NULL)
printf("empty tree\n");
else
outputTree(rootPtr, totalSpaces);
}
return 0;
}
void insertNode(TreeNode **treePtr, int value)
{
if (*treePtr == NULL) {
*treePtr = malloc(sizeof(TreeNode));
if (*treePtr != NULL) {
(*treePtr)->data = value;
(*treePtr)->leftPtr = NULL;
(*treePtr)->rightPtr = NULL;
}
else {
printf("%d not inserted. No memory available.\n", value);
}
}
else {
if (value < (*treePtr)->data) {
insertNode(&((*treePtr)->leftPtr), value);
}
else {
if (value >(*treePtr)->data) {
insertNode(&((*treePtr)->rightPtr), value);
}
else {
printf("dup");
}
}
}
}
TreeNode *binaryTreeSereach(TreeNode * const treePtr, int value)
{
TreeNode *tempPtr = treePtr;
while (tempPtr != NULL && tempPtr->data != value)
{
if (value > tempPtr->data)
tempPtr = tempPtr->rightPtr;
else
tempPtr = tempPtr->leftPtr;
}
return tempPtr;
}
void deleteNode(TreeNode **treePtrP, int value)
{
TreeNode *deleteNodePtr = *treePtrP;
TreeNode *parentNodeOfDeletePtr = NULL;
TreeNode *substituteNodePtr;
TreeNode *parentNodeOfSubstitutePtr;
//find deleNode and its parentNode
while (deleteNodePtr != NULL && value != deleteNodePtr->data)
{
parentNodeOfDeletePtr = deleteNodePtr;
if (deleteNodePtr->data > value)
{
deleteNodePtr = deleteNodePtr->leftPtr;
}
else
{
deleteNodePtr = deleteNodePtr->rightPtr;
}
}
//case that can't find such Node
if (deleteNodePtr == NULL)
{
printf("no such Node, delete fail\n\n");
return;
}
//delete a leafNode
if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)
{
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = NULL;
}
else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
{
parentNodeOfDeletePtr->leftPtr = NULL;
}
else
{
parentNodeOfDeletePtr->rightPtr = NULL;
}
}
//delete a Node which has a left child Node
else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)
{
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = deleteNodePtr->leftPtr;
}
else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;
else
parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;
}
//delete a Node which has a right child Node
else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)
{
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = deleteNodePtr->rightPtr;
}
else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;
else
parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;
}
//delete a Node which has a left and a right child Node
else
{
parentNodeOfSubstitutePtr = deleteNodePtr;
substituteNodePtr = deleteNodePtr->leftPtr;
//search down and right to find substituteNode and its parentNode
while (substituteNodePtr->rightPtr != NULL)
{
parentNodeOfSubstitutePtr = substituteNodePtr;
substituteNodePtr = substituteNodePtr->rightPtr;
}
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = substituteNodePtr;
}
else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
{
parentNodeOfDeletePtr->leftPtr = substituteNodePtr;
}
else
{
parentNodeOfDeletePtr->rightPtr = substituteNodePtr;
}
substituteNodePtr->rightPtr = deleteNodePtr->rightPtr;
if (parentNodeOfSubstitutePtr != deleteNodePtr)
{
substituteNodePtr->leftPtr = deleteNodePtr->leftPtr;
if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)
{
parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;
}
else
{
parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;
}
}
}
free(deleteNodePtr);
}
void outputTree(TreeNode *treePtr, int spaces)
{
int loop;
while (treePtr != NULL) {
outputTree(treePtr->rightPtr, spaces + 4);
for (loop = 1; loop <= spaces; loop++) {
printf(" ");
}
printf("%d\n", treePtr->data);
outputTree(treePtr->leftPtr, spaces + 4);
treePtr = NULL;
}
}
void deleteNode2(TreeNode **treePtrP, int value)
{
TreeNode *deleteNodePtr = *treePtrP;
TreeNode *parentNodeOfDeletePtr = NULL;
TreeNode *substituteNodePtr;
TreeNode *parentNodeOfSubstitutePtr;
//find deleNode and its parentNode
while (deleteNodePtr != NULL && value != deleteNodePtr->data)
{
parentNodeOfDeletePtr = deleteNodePtr;
if (deleteNodePtr->data > value)
{
deleteNodePtr = deleteNodePtr->leftPtr;
}
else
{
deleteNodePtr = deleteNodePtr->rightPtr;
}
}
//case that can't find such Node
if (deleteNodePtr == NULL)
{
printf("no such Node, delete fail\n\n");
return;
}
// delete a leafNode
if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)
{
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = NULL;
}
else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
{
parentNodeOfDeletePtr->leftPtr = NULL;
}
else
{
parentNodeOfDeletePtr->rightPtr = NULL;
}
}
//delete a Node which has a left child Node
else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)
{
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = deleteNodePtr->leftPtr;
}
else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;
else
parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;
}
//delete a Node which has a right child Node
else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)
{
//delete Node is root
if (parentNodeOfDeletePtr == NULL)
{
*treePtrP = deleteNodePtr->rightPtr;
}
else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;
else
parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;
}
//delete a Node which has a left and a right child Node
else
{
//find substituteNode and its parentNode
parentNodeOfSubstitutePtr = deleteNodePtr;
substituteNodePtr = deleteNodePtr->leftPtr;
//search down and right
while (substituteNodePtr->rightPtr != NULL)
{
parentNodeOfSubstitutePtr = substituteNodePtr;
substituteNodePtr = substituteNodePtr->rightPtr;
}
if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)
{
parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;
}
else
{
parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;
}
deleteNodePtr->data = substituteNodePtr->data;
deleteNodePtr = substituteNodePtr;
}
free(deleteNodePtr);
}
智能推荐
分布式光纤传感器的全球与中国市场2022-2028年：技术、参与者、趋势、市场规模及占有率研究报告_预计2026年中国分布式传感器市场规模有多大-程序员宅基地
文章浏览阅读3.2k次。本文研究全球与中国市场分布式光纤传感器的发展现状及未来发展趋势，分别从生产和消费的角度分析分布式光纤传感器的主要生产地区、主要消费地区以及主要的生产商。重点分析全球与中国市场的主要厂商产品特点、产品规格、不同规格产品的价格、产量、产值及全球和中国市场主要生产商的市场份额。主要生产商包括：FISO TechnologiesBrugg KabelSensor HighwayOmnisensAFL GlobalQinetiQ GroupLockheed MartinOSENSA Innovati_预计2026年中国分布式传感器市场规模有多大
07_08 常用组合逻辑电路结构——为IC设计的延时估计铺垫_基4布斯算法代码-程序员宅基地
文章浏览阅读1.1k次，点赞2次，收藏12次。常用组合逻辑电路结构——为IC设计的延时估计铺垫学习目的：估计模块间的delay，确保写的代码的timing 综合能给到多少HZ，以满足需求！_基4布斯算法代码
OpenAI Manager助手（基于SpringBoot和Vue）_chatgpt网页版-程序员宅基地
文章浏览阅读3.3k次，点赞3次，收藏5次。OpenAI Manager助手（基于SpringBoot和Vue）_chatgpt网页版
关于美国计算机奥赛USACO，你想知道的都在这_usaco可以多次提交吗-程序员宅基地
文章浏览阅读2.2k次。USACO自1992年举办，到目前为止已经举办了27届，目的是为了帮助美国信息学国家队选拔IOI的队员，目前逐渐发展为全球热门的线上赛事，成为美国大学申请条件下，含金量相当高的官方竞赛。USACO的比赛成绩可以助力计算机专业留学，越来越多的学生进入了康奈尔，麻省理工，普林斯顿，哈佛和耶鲁等大学，这些同学的共同点是他们都参加了美国计算机科学竞赛（USACO)，并且取得过非常好的成绩。适合参赛人群USACO适合国内在读学生有意向申请美国大学的或者想锻炼自己编程能力的同学，高三学生也可以参加12月的第_usaco可以多次提交吗
MySQL存储过程和自定义函数_mysql自定义函数和存储过程-程序员宅基地
文章浏览阅读394次。1.1 存储程序1.2 创建存储过程1.3 创建自定义函数1.3.1 示例1.4 自定义函数和存储过程的区别1.5 变量的使用1.6 定义条件和处理程序1.6.1 定义条件1.6.1.1 示例1.6.2 定义处理程序1.6.2.1 示例1.7 光标的使用1.7.1 声明光标1.7.2 打开光标1.7.3 使用光标1.7.4 关闭光标1.8 流程控制的使用1.8.1 IF语句1.8.2 CASE语句1.8.3 LOOP语句1.8.4 LEAVE语句1.8.5 ITERATE语句1.8.6 REPEAT语句。_mysql自定义函数和存储过程
半导体基础知识与PN结_本征半导体电流为0-程序员宅基地
文章浏览阅读188次。半导体二极管——集成电路最小组成单元。_本征半导体电流为0
随便推点
【Unity3d Shader】水面和岩浆效果_unity 岩浆shader-程序员宅基地
文章浏览阅读2.8k次，点赞3次，收藏18次。游戏水面特效实现方式太多。咱们这边介绍的是一最简单的UV动画（无顶点位移），整个mesh由4个顶点构成。实现了水面效果（左图），不动代码稍微修改下参数和贴图可以实现岩浆效果（右图）。有要思路是1，uv按时间去做正弦波移动2，在1的基础上加个凹凸图混合uv3，在1、2的基础上加个水流方向4，加上对雾效的支持，如没必要请自行删除雾效代码(把包含fog的几行代码删除)S..._unity 岩浆shader
广义线性模型——Logistic回归模型（1）_广义线性回归模型-程序员宅基地
文章浏览阅读5k次。广义线性模型是线性模型的扩展，它通过连接函数建立响应变量的数学期望值与线性组合的预测变量之间的关系。广义线性模型拟合的形式为：其中g(μY)是条件均值的函数（称为连接函数）。另外，你可放松Y为正态分布的假设，改为Y 服从指数分布族中的一种分布即可。设定好连接函数和概率分布后，便可以通过最大似然估计的多次迭代推导出各参数值。在大部分情况下，线性模型就可以通过一系列连续型或类别型预测变量来预测正态分布的响应变量的工作。但是，有时候我们要进行非正态因变量的分析，例如：（1）类别型.._广义线性回归模型
HTML+CSS大作业 环境网页设计与实现(垃圾分类) web前端开发技术 web课程设计 网页规划与设计_垃圾分类网页设计目标怎么写-程序员宅基地
文章浏览阅读69次。环境保护、 保护地球、 校园环保、垃圾分类、绿色家园、等网站的设计与制作。 总结了一些学生网页制作的经验：一般的网页需要融入以下知识点：div+css布局、浮动、定位、高级css、表格、表单及验证、js轮播图、音频 视频 Flash的应用、ul li、下拉导航栏、鼠标划过效果等知识点，网页的风格主题也很全面：如爱好、风景、校园、美食、动漫、游戏、咖啡、音乐、家乡、电影、名人、商城以及个人主页等主题，学生、新手可参考下方页面的布局和设计和HTML源码（有用点赞△） 一套A+的网_垃圾分类网页设计目标怎么写
C# .Net 发布后,把dll全部放在一个文件夹中,让软件目录更整洁_.net dll 全局目录-程序员宅基地
文章浏览阅读614次，点赞7次，收藏11次。之前找到一个修改 exe 中 DLL地址 的方法, 不太好使,虽然能正确启动, 但无法改变 exe 的工作目录,这就影响了.Net 中很多获取 exe 执行目录来拼接的地址 ( 相对路径 ),比如 wwwroot 和 代码中相对目录还有一些复制到目录的普通文件 等等,它们的地址都会指向原来 exe 的目录, 而不是自定义的 “lib” 目录,根本原因就是没有修改 exe 的工作目录这次来搞一个启动程序,把 .net 的所有东西都放在一个文件夹,在文件夹同级的目录制作一个 exe._.net dll 全局目录
BRIEF特征点描述算法_breif description calculation 特征点-程序员宅基地
文章浏览阅读1.5k次。本文为转载，原博客地址：http://blog.csdn.net/hujingshuang/article/details/46910259简介 BRIEF是2010年的一篇名为《BRIEF:Binary Robust Independent Elementary Features》的文章中提出，BRIEF是对已检测到的特征点进行描述，它是一种二进制编码的描述子，摈弃了利用区域灰度..._breif description calculation 特征点
房屋租赁管理系统的设计和实现，SpringBoot计算机毕业设计论文_基于spring boot的房屋租赁系统论文-程序员宅基地
文章浏览阅读4.1k次，点赞21次，收藏79次。本文是《基于SpringBoot的房屋租赁管理系统》的配套原创说明文档，可以给应届毕业生提供格式撰写参考，也可以给开发类似系统的朋友们提供功能业务设计思路。_基于spring boot的房屋租赁系统论文