AVL二叉平衡树的算法

最新推荐文章于 2022-07-24 13:28:39 发布
最新推荐文章于 2022-07-24 13:28:39 发布
阅读量226 收藏
点赞数
分类专栏： 笔记 文章标签： 算法 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47472749/article/details/122075500
版权 
/*二叉平衡树的算法（C语言）
二叉平衡树是一种特殊的二叉搜索树，
其在搜索上的时间复杂度基本上是线性表与二叉树中最小的，
因此是一个非常非常重要的知识点，且应用十分广泛。

本文的算法基于二叉搜索树的插入与删除算法演变而来。
另外构造了3个函数，而这三个函数
BFInitiate(), RightRotation(), LeftRotation()
在本算法中是十分最重要的。
本文采用三重链表，
可以从零开始构造二叉平衡树，
自动旋转保持树的平衡；
又可以删除二叉平衡树的某个节点（包括根节点），
删除后也可以多次自动旋转保持平衡。
注意是多次哦，
因为进行删作，即使进行自动旋转操作后，
有可能还是不平衡，所以还需要再次自动旋转操作。*/
#include<stdio.h>
#include<stdlib.h>
typedef struct btnode {
	int key;
	int bf;
	struct btnode* Lchild, * Rchild, * Father;
}BTNode;
typedef struct btree {
	struct btnode* Root;
}BTree;
BTNode* NewNode() {
	BTNode* p = (BTNode*)malloc(sizeof(BTNode));
	return p;
}
BTNode* NewNode2(int x) {
	BTNode* p = (BTNode*)malloc(sizeof(BTNode));
	p->key = x;
	p->bf = 0;
	p->Lchild = NULL;
	p->Rchild = NULL;
	p->Father = NULL;
	return p;
}
void CreateBT(BTree* bt) {
	bt->Root = NULL;
}
void MakeBT(BTree* bt, int x, BTree* lt, BTree* rt) {
	BTNode* p = NewNode();
	p->key = x;
	p->Father = NULL;
	if (rt->Root != NULL) {
		rt->Root->Father = p;
	}
	p->Rchild = rt->Root;
	if (lt->Root != NULL) {
		lt->Root->Father = p;
	}
	p->Lchild = lt->Root;
	lt->Root = rt->Root = NULL;
	bt->Root = p;
}
void BreakBT(BTree* bt, BTree* lt, BTree* rt) {
	BTNode* p = bt->Root;
	if (p) {
		lt->Root = p->Lchild;
		rt->Root = p->Rchild;
		bt->Root = NULL;
		free(p);
	}
}

int Size(BTNode* p) {
	int s, s1, s2;
	if (!p) {
		return 0;
	}
	else {
		s1 = Size(p->Lchild);
		s2 = Size(p->Rchild);
		s = s1 + s2 + 1;
		return s;
	}
}
int SizeofBT(BTree bt) {
	return Size(bt.Root);
}
int Depth(BTNode* p) {
	if (!p) {
		return 0;
	}
	else {
		return 1 + max(Depth(p->Lchild), Depth(p->Rchild));
	}
}
int DepthofBT(BTree bt) {
	return Depth(bt.Root);
}
int CountLeaf(BTNode* p, int count)
{
	if (p != NULL)
	{
		if (p->Lchild == NULL && p->Rchild == NULL) {
			count++;
		}
		count = CountLeaf(p->Lchild, count);
		count = CountLeaf(p->Rchild, count);
	}
	return count;
}
int NumberofLeaf(BTree bt, int count) {
	return CountLeaf(bt.Root, count);
}
void LevelOrd(BTree bt) {
	BTNode* p;
	BTNode* queue[256];
	int front = -1, rear = -1;
	if (bt.Root == NULL) {
		return;
	}
	p = bt.Root;
	rear++;
	queue[rear] = p;
	while (front != rear) {
		front++;
		p = queue[front];
		printf("%d_[%d] ", p->key, p->bf);
		if (p->Lchild != NULL) {
			rear++;
			queue[rear] = p->Lchild;
		}
		if (p->Rchild != NULL) {
			rear++;
			queue[rear] = p->Rchild;
		}
	}
	printf("\n");
}
//重新初始化树中结点的一个个balance值，和按层次遍历树的结点的算法相同，每遍历到一个结点，就会重新计算该节点的balance值
void BFInitiate(BTree bt) {
	BTNode* p;
	BTNode* queue[256];
	int front = -1, rear = -1;
	p = bt.Root;
	if (bt.Root == NULL) return;
	rear++;
	queue[rear] = p;
	while (front != rear) {
		front++;
		p = queue[front];
		p->bf = Depth(p->Lchild) - Depth(p->Rchild);
		if (p->Lchild != NULL) {
			rear++;
			queue[rear] = p->Lchild;
		}
		if (p->Rchild != NULL) {
			rear++;
			queue[rear] = p->Rchild;
		}
	}
	printf("\n");
}
//左旋转函数
void LeftRotation(BTNode* s, BTree* bt) {
	BTNode* r, * u;
	r = (BTNode*)malloc(sizeof(BTNode));
	u = (BTNode*)malloc(sizeof(BTNode));
	r = s->Lchild;
	if (r->bf == -1) {//执行LR旋转
		u = r->Rchild;
		r->Rchild = u->Lchild;
		if (u->Lchild != NULL) {
			u->Lchild->Father = r;
		}
		u->Lchild = r;
		s->Lchild = u->Rchild;
		if (u->Rchild != NULL) {
			u->Rchild->Father = s;
		}
		u->Rchild = s;
		if (s->Father != NULL) {
			if (s->Father->Lchild == s) {
				s->Father->Lchild = u;
			}
			if (s->Father->Rchild == s) {
				s->Father->Rchild = u;
			}
			u->Father = s->Father;//把s的父节点赋给u的父指针指向的结点
			s->Father = u;
			r->Father = u;
		}
		else {
			u->Father = NULL;
			bt->Root = u;
			r->Father = u;
			s->Father = u;
		}
	}
	else {//执行LL旋转，
		s->Lchild = r->Rchild;
		if (r->Rchild != NULL) {
			r->Rchild->Father = s;
		}
		r->Rchild = s;
		if (s->Father != NULL) {
			if (s->Father->Rchild == s) {
				s->Father->Rchild = r;
			}
			if (s->Father->Lchild == s) {
				s->Father->Lchild = r;
			}
			r->Father = s->Father;
			s->Father = r;
		}
		else {
			r->Father = NULL;
			bt->Root = r;
			s->Father = r;
		}
	}
}
//右旋转函数
void RightRotation(BTNode* s, BTree* bt) {
	BTNode* r, * u;
	r = (BTNode*)malloc(sizeof(BTNode));
	u = (BTNode*)malloc(sizeof(BTNode));
	r = s->Rchild;
	if (r->bf == 1) {//执行RL旋转
		u = r->Lchild;
		r->Lchild = u->Rchild;
		if (u->Rchild != NULL) {
			u->Rchild->Father = r;
		}
		u->Rchild = r;
		s->Rchild = u->Lchild;
		if (u->Lchild != NULL) {
			u->Lchild->Father = s;
		}
		u->Lchild = s;
		if (s->Father != NULL) {
			if (s->Father->Lchild == s) {
				s->Father->Lchild = u;
			}
			if (s->Father->Rchild == s) {
				s->Father->Rchild = u;
			}
			u->Father = s->Father;
			s->Father = u;
			r->Father = u;
		}
		else {
			u->Father = NULL;
			bt->Root = u;
			r->Father = u;
			s->Father = u;
		}
	}
	else {//执行RR旋转
		s->Rchild = r->Lchild;
		if (r->Lchild != NULL) {
			r->Lchild->Father = s;
		}
		r->Lchild = s;
		if (s->Father != NULL) {
			if (s->Father->Rchild == s) {
				s->Father->Rchild = r;
			}
			if (s->Father->Lchild == s) {
				s->Father->Lchild = r;
			}
			r->Father = s->Father;
			s->Father = r;
		}
		else {
			r->Father = NULL;
			bt->Root = r;
			s->Father = r;
		}
	}
}
//二叉平衡树的插入运算
void AVListInsert(BTree* bt, int k) {
	BTNode* q, * p, * s;
	s = (BTNode*)malloc(sizeof(BTNode));
	p = bt->Root;
	s = p;
	while (p) {
		s = p;
		if (k < p->key) {
			p = p->Lchild;
		}
		else if (k > p->key) {
			p = p->Rchild;
		}
		else {
			printf("Duplication! \n");
			return;
		}
	}
	//这里调用二叉搜索树的迭代算法，找到要插入的位置。
	//s指代插入的点的父节点，p如果不重复的话，到最后应该为null了。
	q = NewNode2(k);
	if (bt->Root) {//判断是不是头一次创建结点
		if (k < s->key) {
			s->Lchild = q;
			q->Father = s;
		}
		if (k > s->key) {
			s->Rchild = q;
			q->Father = s;
		}
	}
	else {
		bt->Root = q;
		return;//如果是的话，将新创建的q结点作为根节点。然后直接返回，退出该函数
	}
	while (1) {
		s->bf = Depth(s->Lchild) - Depth(s->Rchild);//插入q后，向上依次更新其父节点的balance。
		if (s->bf < -1 || s->bf>1) {//遇到的第一个更新完balance后不再平衡的父节点，就跳出循环，执行旋转操作，
			break;
		}
		if (s->Father == NULL) {//如果最后到达最顶层，则也跳出循环
			break;
		}
		s = s->Father;
	}
	if (s->Father == NULL && s->bf >= -1 && s->bf <= 1) {
		printf("\n二叉树已经平衡，无需再平衡！\n");
	}
	if (s->bf == 2) {//如果s的balance为2，代表左子树比较庞大，需要执行左旋转
		LeftRotation(s, bt);
	}
	if (s->bf == -2) {//如果s的balance为-2，代表右子树比较庞大，需要执行右旋转
		RightRotation(s, bt);
	}
}

void Visit(BTNode* p) {
	printf("%d_[%d] ", p->key, p->bf);
}
void PreOrd(void (*Visit)(BTNode* u), BTNode* t) {
	if (t) {
		(*Visit)(t);
		PreOrd(Visit, t->Lchild);
		PreOrd(Visit, t->Rchild);
	}
}
void InOrd(void (*Visit)(BTNode* u), BTNode* t) {
	if (t) {
		InOrd(Visit, t->Lchild);
		(*Visit)(t);
		InOrd(Visit, t->Rchild);
	}
}
void PostOrd(void (*Visit)(BTNode* u), BTNode* t) {
	if (t) {
		PostOrd(Visit, t->Lchild);
		PostOrd(Visit, t->Rchild);
		(*Visit)(t);
	}
}
void PreOrder(BTree* bt, void  (*Visit)(BTNode* u)) {
	PreOrd(Visit, bt->Root);
}
void InOrder(BTree* bt, void  (*Visit)(BTNode* u)) {
	InOrd(Visit, bt->Root);
}
void PostOrder(BTree* bt, void  (*Visit)(BTNode* u)) {
	PostOrd(Visit, bt->Root);
}
//二叉平衡时的删除运算
void AVLremove(BTree* bt, int k) {
	BTNode* c, * r, * s, * p, * q;
	q = (BTNode*)malloc(sizeof(BTNode));
	p = bt->Root;
	while (p && p->key != k) {
		q = p;
		if (k < p->key) {
			p = p->Lchild;
		}
		else {
			p = p->Rchild;
		}
	}//调用二叉搜索树的搜索算法，是否能找到该要删除的节点
	if (!p) {
		printf("\nNo Element with Key k!\n");
		return;
	}
	printf("\nfind the elememt which you want to delete: %d\n", p->key);
	if (p->Lchild && p->Rchild) {//看下要删除的结点是否有两个孩子，如果有，就找到该节点的中序遍历次序下的后继结点
		s = p->Rchild;
		r = p;
		while (s->Lchild) {
			r = s;
			s = s->Lchild;
		}
		p->key = s->key;//将该节点中序遍历次序下的后继结点的值赋给该节点。
		p = s;//然后，刷新p，q，新的p就是原来要删除的节点的中序遍历次序下的后继结点，q就是原来要删除的结点的中序遍历次序下后继的结点的父节点
		q = r;
	}
	if (p->Lchild) {//这一段代码应该基本上泡不到，是个小bug，因为现在的p已经不可能有左孩子了。
		c = p->Lchild;
	}
	else {
		c = p->Rchild;//把新节点p的右孩子提出来
	}
	if (p == bt->Root) {
		bt->Root = c;
	}
	else if (p == q->Lchild) {
		q->Lchild = c;
		if (c != NULL) {
			c->Father = q;
		}
	}
	else {
		q->Rchild = c;
		if (c != NULL) {
			c->Father = q;
		}
	}
	free(p);//在这里执行删除操作
	printf("Remove Succeeded!\n");
	if (bt->Root != NULL) {
		BFInitiate(*bt);
	}
	else {
		return;//如果删的是只有一个父节点的AVL树，就会在这里直接跳出函数
	}

	printf("%d\n", q->bf);
LABEL:
	while (1) {
		q->bf = Depth(q->Lchild) - Depth(q->Rchild);
		if (q->bf < -1 || q->bf>1) {
			break;
		}
		if (q->Father == NULL) {
			break;
		}
		q = q->Father;
	}
	if (q->Father == NULL && q->bf >= -1 && q->bf <= 1) {
		printf("\n二叉树已经平衡，无需再平衡！\n");
	}
	if (q->bf == 2) {
		LeftRotation(q, bt);
		BFInitiate(*bt);
		goto LABEL;
		//实时证明，旋转完一次以后，有可能还是无法平衡，所以还需要再次进行判断是否是平衡了，就需要引入一个循环。如果不平衡，需要再次旋转，直到平衡为止
	}
	if (q->bf == -2) {
		RightRotation(q, bt);
		BFInitiate(*bt);
		goto LABEL;
		//实时证明，旋转完一次以后，有可能还是无法平衡，所以还需要再次进行判断是否是平衡了，就需要引入一个循环。如果不平衡，需要再次旋转，直到平衡为止
	}
}

void main() {
	BTree* z;
	z = (BTree*)malloc(sizeof(BTree));
	CreateBT(z);
	AVListInsert(z, 100);  //从无到有构造二叉平衡树时，根节点一定要最先创建！
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 50);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 200);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 150);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 400);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 800);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 125);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 110);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 105);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 170);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 120);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVListInsert(z, 106);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVLremove(z, 150);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	AVLremove(z, 120);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	AVLremove(z, 170);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	AVLremove(z, 100);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	AVListInsert(z, 120);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	AVLremove(z, 105);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	AVLremove(z, 50);
	BFInitiate(*z);
	LevelOrd(*z);
	InOrder(z, Visit);
	printf("\n");
	printf("\n");
}
攻城狮手搓万物
关注
专栏目录
数据结构之平衡二叉树的平衡因子BF 的计算
followMyInclinations的专栏
12-29 1万+
在书上看了平衡二叉树的代码后，发现前人的智慧真是无限。但是因为一次性给出的最完美的代码让人有时候看不太懂... 后来经过仔细推敲，才慢慢发现了其中的奥秘。一开始并不知道关于平衡二叉树的平衡因子BF是怎么修改的，后来才发现关于平衡二叉树的最重要的一句话：在构建平衡二叉树的过程中，每当插入一个结点时，先检查是否因插入而破坏了树的平衡性，若是，则找出最小不平衡子树，在保持二叉排序树特性的前提下，调整关
二叉平衡树（C++）
wo_ai_luo_的博客
02-25 1080
平衡二叉树也叫做AVL树,AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树(Self-Balancing Binary Search Tree,简称平衡二叉树。我们怎么知道这棵二叉搜索树平不平衡呢？我们知道，二叉搜索树的搜索时间和高度是有直接关系的，但是我们按递增、递减序输入之后，高度就和n一样了，所以时间复杂度为O(log n).想要优化，就是改变这棵二叉搜索树的高度。
数据结构与算法-平衡二叉树【二十】
Riptide
09-24 353
前景提要 因为线性表（假定长度为n）在动态的添加和删除的弊端，所以我们引入了二叉搜索树，但是二叉搜索树有多种形式 最好的情况是 线性表的 判定树 最坏的情况是这颗二叉搜索树的深度为n，每一层一个节点。 最好的情况是这样： ASL = log2(n + 1) - 1 数量级为O(log2n) 5 第一层 / \
分析线性表、二叉平衡树和哈希表存储数据时各自的优劣
WilburYao的博客
04-25 1850
链接：https://www.nowcoder.com/questionTerminal/b67ebdf7e1a84f37a9b1ed578525f625 线性表，插入的时间复杂度为O(1)，但是因内部无法保证有序，所以查找需要O(Length)的时间复杂度，而删除则取决于所用实现是链表还是数组，链表为O(1)，数组为O(Length)。虽然时间复杂度看起来比较糟糕，但是其时间常数相对后两者...
AVL平衡二叉树 图文详解与实现
m0_46452562的博客
04-06 729
文章目录一、AVL简介1.二叉搜索树2.平衡条件二、AVL树的平衡调整策略1.最小不平衡子树2.AVL树的失衡调整1、LL型2、RR型3、LR型4、RL型三、AVL树的一些操作1、添加结点步骤模拟代码2、删除结点步骤模拟代码3、修改结点步骤代码4、遍历1.先序遍历2.中序遍历3.后序遍历四、最终代码有注释版无注释版测试代码测试结果 一、AVL简介 AVL树本质上还是一棵二叉搜索树，它的特点是： 1.本身首先是一棵二叉搜索树。 2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。 也就
算法：二叉平衡树（AVL树）
OceanStar的博客
10-07 7343
平衡二叉树定义 平衡二叉树 全称叫做 平衡二叉搜索（排序）树，简称 AVL树。英文：Balanced Binary Tree （BBT），注：二叉查找树(BST) AVL 什么意思？AVL 是大学教授 G.M. Adelson-Velsky 和 E.M. Landis 名称的缩写，他们提出的平衡二叉树的概念，为了纪念他们，将 平衡二叉树 称为 AVL树。 AVL树本质上是一颗二叉查找树，但是它又具有以下特点： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1， 左右两个子树 也都是一棵平衡二叉树。
AVL二叉搜索树的插入算法
早安不安的博客
05-18 629
AVL二叉搜索树的插入自平衡算法
二叉平衡树的构建
公众号：风景邮递Yuan的博客
03-22 941
二叉平衡树的关键在于如何平衡这棵二叉树 我利用的是在每个结点里面加入hight 这个变量，用于记录树的高度，一棵树高度可以无限高，无法判断树是否平衡；所以我又引入了另外一个变量factor结合hight来判断树是否平衡； height的由来 在每一棵二叉树里初始化height记height为1，然后在调用函数insert插入新的结点时，更新每一个结点的height的值；即通过比较左子树和右子树的大小，取出大的一个加1；再结合遍历可得出每一棵树的高度；有父树比子树大1的特点； static int max(i
平衡二叉排序树（AVL树）
狂放不羁霸的博客
06-13 2549
平衡二叉排序树插入操作的算法思想： 1、查找插入位置，同时记录离插入位置最近的可能失衡结点A； 2、插入新结点S； 3、确定旋转点B，同时更新A的平衡因子； 4、更新B到S的路径上各结点的平衡因子（原值必为0，否则A将下移）； 5、根据A、B的平衡因子判断是否失衡以及失衡类型，并做相应处理。...
C语言实现二叉平衡树
ZER00000001的博客
07-24 945
前言 对于大量的数据而言，链表的线性访问时间太慢，不宜使用。本章节将会介绍一种简单的数据结构：树（tree），其大部分操作的运行时间平均为O（logN）。在数据结构中树是非常有用的抽象概念，在本篇中我们将讨论二叉平衡树，为后续高阶搜索树打下基础。如果代码有疑问的同学可以私信问我，一定要先把逻辑理顺！一定要先把逻辑理顺！一定要先把逻辑理顺！重要的话说三遍(；д；)，不然后面的高阶搜索树会很吃亏的！ ...
C#，自平衡二叉查找树（AVL Tree）的算法与源代码
最新发布
03-24
自平衡二叉查找树（AVL Tree）中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. ...
实现二叉排序树的各种算法
07-25
实验过程中，学生可能还会探讨不同场景下二叉排序树的表现，比如在已排序和未排序的数据集上构建树的差异，以及在不平衡树和平衡树之间进行操作的效率对比。通过这样的实践，学生能深入理解二叉排序树的原理，并提高...
二叉平衡树查找，插入与删除.zip
09-04
二叉平衡树有多种类型，常见的有AVL树、红黑树、Splay树等。在这里，虽然没有明确指出使用的是哪种类型的平衡树，但我们可以假设它是AVL树，因为AVL树是最基础且最典型的平衡树结构。AVL树的特点是任何节点的两个...
字符串加密与解密_一种可以用在程序加密的功能
家里蹲大学摸鱼学专业优秀毕业生的博客
08-27 7785
本篇博客会有两篇代码，均为C# 编写而成。其中一篇为先行的各种加密技术如何使用（转载出处会在文末注明）；另一篇为利用以上加密技术做出的一个类库，可以使程序捆绑在运行此程序的硬件并限定使用时间，十分高效和耐用。 好，话不多说，先上第一篇： 各种加密技术： AES（转自百度百科） 高级加密标准 密码学中的高级加密标准（Advanced Encryption Standard，AES），又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。 这个标准用来替代原先的DES（Data Encrypti
Python_OpenCV_实现模糊集合用于图像增强（对比度提升，空间滤波）
家里蹲大学摸鱼学专业优秀毕业生的博客
03-08 2081
本文部分内容来自： https://blog.csdn.net/qq_37764129/article/details/82893966 模糊集的详细原理请看冈萨雷斯的数字图像处理教程，这里不再详细赘述。 下面将模糊集用于图像增强的步骤罗列如下： 使用模糊集合来进行灰度变换，从而增强图像。首先可以在常理下考虑一下，一般的对于动态范围较小的图像，我们一般的处理的方法是灰度拉升，或者直方图均衡。 这两种的方法的本质就是，让原图较暗的像素更加暗，让原图较亮的像素更加亮。那么，我们规定如下模糊规则 R1：IF 一个
实时识别骰子的点数_Halcon
家里蹲大学摸鱼学专业优秀毕业生的博客
09-08 1631
在以前的赌场中会有人出老千预先知道色子的点数，不清楚现在的国际赌场是否还有（话说我也不会去赌博的，哈哈哈哈哈哈） 那么，本文就把这种用Halcon编写的实时识别色子点数的算法分享出来 本文会有两个关于图像分割的 核心算法： 距离变换与分水岭算法 即 distance_transform (ConnectedRegions, DistanceImage, ‘octagonal’, ‘true’, 1000, 1000) 与 watersheds_threshold (ImageScaleMax, Basins
Python_OpenCV_Numppy实现8比特图像平面分层
家里蹲大学摸鱼学专业优秀毕业生的博客
02-28 1219
对于256级的8位灰度图，将每一位的灰度拆分出来，生成对应的二值图像，并将不同层次的灰度二值图像组合可以在不损失图像精度的前提下降低图像存储空间。 对应的做法是将不同层次的二值图像分别乘以对应的常数，然后相加即可。 实验证明，将第5，6，7，8层分层二值图像分别乘以对应的对应的常数相加，生成的图像极为接近原图，而且所占用空间变小。 下面我们先分拆灰度原图，将其拆分成8层二值图像。 我们知道，灰度级（0_255）可以用二进制表示，比如灰度值为125的像素，用二进制表示为 0111 1101 ，所以它是在第7位
C#调用C++编写的DLL(非托管)
家里蹲大学摸鱼学专业优秀毕业生的博客
09-15 889
前言 我之前有过一个函数使用C++写的，我想将它加到C#里面，用C#调用。结果我看了好多博主的博客，成功的把上面的坑一个一个都踩过了。（小声吐槽，话说这些博主不看自己的东西能不能跑起来吗。。。） 那么，本篇博客就以实用的角度出发，介绍如何将C++编写的DLL供给C#调用。 首先，托管与非托管的区别请看以下博客： 我是传送门 DLL（动态链接库）的各个C++关键字的介绍请看以下博客： 我是传送门 上面顺便介绍了静态链接库与动态链接库的区别。 C++调用C++编写的DLL请看下述博客 我是传送门 本博客也顺便介
无向数据网的最小代价生成树：Prim算法
家里蹲大学摸鱼学专业优秀毕业生的博客
09-21 867
说实话，教科书上的案例是错误的，Prim算法没有那么简单，短短的几行代码根本实现不了。不过仍然向它致敬，因为理论讲的很透彻，我也是根据理论写出来这个复杂代码的，本算法的基本数据结构是邻接表。 Prim算法简介：（这里转载网友的介绍~） 最小生成树问题的概念—普里姆算法是从点的角度来解决。若在解决问题过程中需要遍历图的所有点，则普里姆算法更好。 基本思想： 普里姆算法更像构建一棵树。联想我们构建二叉树的过程，从根节点出发，构建左右子树，再以左右子树为根节点，构建它们的左右子树。普里姆算法设一个点集V，初始时只
平衡二叉排序树算法实现与操作
如果插入操作导致了树的高度不平衡，需要进行旋转操作来重新平衡树。常见的旋转操作有右旋（R_Rotate）和左旋（L_Rotate），用于调整树的形态。 2. **前序、中序、后序遍历**：遍历二叉树是理解其结构的关键。前序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值