算法导论红黑树的C++实现

最新推荐文章于 2024-09-08 15:12:17 发布
最新推荐文章于 2024-09-08 15:12:17 发布
阅读量2k 收藏 2
点赞数
分类专栏： C++ 红黑树 算法导论 文章标签： 算法 c++ tree null search insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyjjkk/article/details/7440941
版权
C++ 同时被 3 个专栏收录
3 篇文章 0 订阅
订阅专栏
红黑树
1 篇文章 0 订阅
订阅专栏
算法导论
1 篇文章 0 订阅
订阅专栏 
按照算法导论里的红黑树伪代码用C++实现了一下，
并附带一些测试代码。

#include <iostream>
#include <utility>
using namespace std;
enum Color{RED,BLACK};//颜色标记
template<class T>
class Binary_Tree_Node//红黑树节点
{
public:
	Binary_Tree_Node()
	{
		parent=NULL;
		leftchild=NULL;
		rightchild=NULL;
		C=BLACK;
	}
	Binary_Tree_Node<T> * parent;//*/父节点*/
	Binary_Tree_Node<T> * leftchild;//左子树
	Binary_Tree_Node<T> * rightchild;//后子树
	T Key;//键值
	Color C;//颜色标记


};
template<class T>
class Binary_Tree//红黑树结构
{
public:
	Binary_Tree()
	{
		root =NULL;
	}
	Binary_Tree_Node<T> * root;//根节点
};
template<class T>
void Inorder_Tree_Walk( Binary_Tree_Node<T> * A)//顺序打印树
{
	if (A!=NULL)
	{
		Inorder_Tree_Walk(A->leftchild);
		cout<<A->Key<<"  ";
		Inorder_Tree_Walk(A->rightchild);
	}
}
template<class T>
Binary_Tree_Node<T> * Tree_Search( Binary_Tree_Node<T> * A,const T & Search_Key)//递归查找
{
	if (A==NULL||A->Key==Search_Key)
	{
		return A;
	}
	if (A->Key<Search_Key)
	{
		return Tree_Search(A->rightchild,Search_Key);
	}
	else
	{
		return Tree_Search(A->leftchild,Search_Key);
	}
}
template<class T>
Binary_Tree_Node<T> * Interative_Tree_Search( Binary_Tree_Node<T> * A,const T   & Search_Key )//非递归查找
{
	Binary_Tree_Node<T> * temp=A;
	while(temp!=NULL&& temp->Key!=Search_Key)
	{

		if (temp->Key<Search_Key)
		{
			temp=temp->leftchild;
		}
		else
		{
			temp=temp->rightchild;
		}
	}
	return temp;
}
template<class T>
Binary_Tree_Node<T> * Tree_Min(Binary_Tree_Node<T> * A)//求节点下的最小值
{
	Binary_Tree_Node<T> * temp=A;
	Binary_Tree_Node<T> * tempRt=NULL;
	while (temp!=NULL)
	{
		tempRt=temp;
		temp=temp->leftchild;
	}
	return tempRt;
}
template<class T>
Binary_Tree_Node<T> * Tree_Max(Binary_Tree_Node<T> * B)//求节点下的最大值
{
	Binary_Tree_Node<T> * temp=B;
	Binary_Tree_Node<T> * tempRt=NULL;
	while(temp!=NULL)
	{
		tempRt=temp;
		temp=temp->rightchild;
	}
	return tempRt;
}
template<class T>
Binary_Tree_Node<T> * Successor(Binary_Tree_Node<T> * A)//求比节点的大的后一个值
{
	Binary_Tree_Node<T> * temp=A;
	if (temp!=NULL)
	{
		if (temp->rightchild!=NULL)
		{
			return Tree_Min(temp->rightchild);
		}
		Binary_Tree_Node<T> * y=temp->parent;
		while(y!=NULL && temp==y->rightchild)
		{
			temp=y;
			y=y->parent;
		}
		return y;
	}
	else
	{
		return temp;
	}
}
template<class T> 
Binary_Tree_Node<T> * Predecessor(Binary_Tree_Node<T> * A)//求比节点小的前一个值
{
	Binary_Tree_Node<T> * temp=A;
	if (temp!=NULL)
	{
		if (temp->leftchild!=NULL)
		{
			return Tree_Max(temp->leftchild);
		}
		Binary_Tree_Node<T> * y=temp->parent;
		while(y!=NULL && temp==y->leftchild)
		{
			temp=y;
			y=y->parent;
		}
		return y;
	}
	else
	{
		return temp;
	}
}
template<class T>
void RB_Tree_Insert(Binary_Tree<T> & Tree,const T & InsertKey)//红黑树插入
{
	Binary_Tree_Node<T> * y=NULL;
	Binary_Tree_Node<T> * x=Tree.root;
	while(x!=NULL)
	{
		y=x;
		if (x->Key<InsertKey)
		{
			x=x->rightchild;
		}
		else
		{
			x=x->leftchild;
		}
	}
	Binary_Tree_Node<T> * NewNode=new Binary_Tree_Node<T>;
	NewNode->Key=InsertKey;
	NewNode->parent=y;
	if (y==NULL)
	{
		Tree.root=NewNode;
	}
	else
	{
		if (y->Key<InsertKey)
		{
			y->rightchild=NewNode;
		}
		else
		{
			y->leftchild=NewNode;
		}
	}
	NewNode->C=RED;
	RB_Tree_Insert_Fixup(Tree,NewNode);//插入后修复红黑树属性

}
template<class T>
void RB_Tree_Insert_Fixup(Binary_Tree<T> & Tree,Binary_Tree_Node<T> * NewNode)
{
	Binary_Tree_Node<T> * Z=NULL;
	/*Binary_Tree_Node<T> Nil;*/
	Z=NewNode;
	while(Z->parent!=NULL&&Z->parent->C==RED)
	{
		Binary_Tree_Node<T> * y=NULL;
		if (Z->parent==Z->parent->parent->leftchild)
		{
			y=Z->parent->parent->rightchild;
			if (y!=NULL&&y->C==RED)
			{
				y->C=BLACK;
				Z->parent->C=BLACK;
				Z->parent->parent->C=RED;
				Z=Z->parent->parent;
				continue;
			}
			else
			{

				if (Z==Z->parent->rightchild)
				{
					Z=Z->parent;
					Left_Roation(Tree,Z);
					continue;
				}
				else
				{
					Z->parent->C=BLACK;
					Z->parent->parent->C=RED;
					Right_Roation(Tree,Z->parent->parent);
				}
			}
		}
		else 
		{
			y=Z->parent->parent->leftchild;
			if (y!=NULL&&y->C==RED)
			{
				y->C=BLACK;
				Z->parent->C=BLACK;
				Z->parent->parent->C=RED;
				Z=Z->parent->parent;
				continue;
			}
			else
			{
				if (Z==Z->parent->leftchild)
				{
					Z=Z->parent;
					Right_Roation(Tree,Z);
					continue;
				}
				else
				{
					Z->parent->C=BLACK;
					Z->parent->parent->C=RED;
					Left_Roation(Tree,Z->parent->parent);
				}
			}
		}
	}
	Tree.root->C=BLACK;
}
template<class T>
void Tree_Insert(Binary_Tree<T> & Tree,const T & InsertKey)//普通二叉树插入
{
	Binary_Tree_Node<T> * y=NULL;
	Binary_Tree_Node<T> * x=Tree.root;
	while(x!=NULL)
	{
		y=x;
		if (x->Key<InsertKey)
		{
			x=x->rightchild;
		}
		else
		{
			x=x->leftchild;
		}
	}
	Binary_Tree_Node<T> * NewNode=new Binary_Tree_Node<T>;
	NewNode->Key=InsertKey;
	NewNode->parent=y;
	if (y==NULL)
	{
		Tree.root=NewNode;
	}
	else
	{
		if (y->Key<InsertKey)
		{
			y->rightchild=NewNode;
		}
		else
		{
			y->leftchild=NewNode;
		}
	}
	return ;
}
template<class T>
void RB_Tree_Delete(Binary_Tree<T> & Tree,Binary_Tree_Node<T> * DeleteNode)//红黑树删除
{
	Binary_Tree_Node<T> * tempDeleteNode=DeleteNode;
	Binary_Tree_Node<T> * y=NULL;
	Binary_Tree_Node<T> * x=NULL;
	Binary_Tree_Node<T> Nil;//本地临时的Nil
	if (tempDeleteNode!=NULL)
	{
		if (tempDeleteNode->leftchild==NULL
			||tempDeleteNode->rightchild==NULL)
		{
			y=tempDeleteNode;
		}
		else
		{
			y=Successor(tempDeleteNode);
		}
		if (y->leftchild!=NULL)
		{
			x=y->leftchild;
		}
		else
		{
			x=y->rightchild;
		}
		if (x==NULL)
		{
			x=&Nil;//x为null 则赋值为nil的指针;.
		}
		x->parent=y->parent;
		if (y->parent==NULL)
		{
			Tree.root=x;
		}
		else if (y==y->parent->leftchild)
		{
			y->parent->leftchild=x;
		}
		else
		{
			y->parent->rightchild=x;
		}
		if (y!=DeleteNode)
		{
			DeleteNode->Key=y->Key;
		}
		if (y->C==BLACK)
		{
			RB_Tree_Delete_FixUp(Tree,x);//修复红黑树属性
		}
		if (Nil.parent!=NULL)//将临时插入的nil还原为null指针
		{
			if (&Nil==Nil.parent->leftchild)
			{
				Nil.parent->leftchild=NULL;
			}
			else if (&Nil==Nil.parent->rightchild)
			{
				Nil.parent->rightchild=NULL;
			}
		}
		if (Tree.root==&Nil)
		{
			Tree.root=NULL;
		}
		delete y;
		return;

	}
	else
	{
		return ;
	}
}
template<class T>
void RB_Tree_Delete_FixUp(Binary_Tree<T> & Tree,Binary_Tree_Node<T> * x)
{
	while(x!=Tree.root&&x->C==BLACK)
	{
		Binary_Tree_Node<T> * w=NULL;
		if (x==x->parent->leftchild)
		{
			w=x->parent->rightchild;
			if (w!=NULL&&w->C==RED)
			{
				w->C=BLACK;
				x->parent->C=RED;
				Left_Roation(Tree,x->parent);
				w=x->parent->rightchild;
			}
			if (w==NULL||(w!=NULL&&(w->leftchild==NULL||w->leftchild->C==BLACK)
				&&(w->rightchild==NULL||w->rightchild->C==BLACK)))
			{
				if (w!=NULL)
				{
					w->C=RED;
				}
				x=x->parent;
				continue;
			}
			else if(w->rightchild==NULL||w->rightchild->C==BLACK)
			{
				w->C=RED;
				w->leftchild->C=BLACK;
				Right_Roation(Tree,w);
				w=x->parent->rightchild;
			}
			w->C=x->parent->C;
			x->parent->C=BLACK;
			w->rightchild->C=BLACK;
			Left_Roation(Tree,x->parent);
			x=Tree.root;
		}
		else
		{
			w=x->parent->leftchild;
			if (w!=NULL&&w->C==RED)
			{
				w->C=BLACK;
				x->parent->C=RED;
				Right_Roation(Tree,x->parent);
				w=x->parent->leftchild;
			}
			if (w==NULL||(w!=NULL&&(w->leftchild==NULL||w->leftchild->C==BLACK)
				&&(w->rightchild==NULL||w->rightchild->C==BLACK)))
			{
				if (w!=NULL)
				{
					w->C=RED;
				}
				x=x->parent;
				continue;
			}
			else if (w->leftchild==NULL||w->leftchild->C==BLACK)
			{
				w->C=RED;
				w->rightchild->C=BLACK;
				Left_Roation(Tree,w);
				w=x->parent->leftchild;
			}
			w->C=x->parent->C;
			x->parent->C=BLACK;
			w->leftchild->C=BLACK;
			Right_Roation(Tree,x->parent);
			x=Tree.root;
		}
	}
	x->C=BLACK;
	return;
}
template<class T>
void Tree_Delete(Binary_Tree<T> & Tree,Binary_Tree_Node<T> * DeleteNode)//普通二叉树删除
{
	Binary_Tree_Node<T> * tempDeleteNode=DeleteNode;
	Binary_Tree_Node<T> * y=NULL;
	Binary_Tree_Node<T> * x=NULL;
	if (tempDeleteNode!=NULL)
	{
		if (tempDeleteNode->leftchild==NULL
			||tempDeleteNode->rightchild==NULL)
		{
			y=tempDeleteNode;
		}
		else
		{
			y=Successor(tempDeleteNode);
		}
		if (y->leftchild!=NULL)
		{
			x=y->leftchild;
		}
		else
		{
			x=y->rightchild;
		}
		if (x!=NULL)
		{
			x->parent=y->parent;
		}
		if (y->parent==NULL)
		{
			Tree.root=x;
		}
		else if (y==y->parent->leftchild)
		{
			y->parent->leftchild=x;
		}
		else
		{
			y->parent->rightchild=x;
		}
		if (y!=DeleteNode)
		{
			DeleteNode->Key=y->Key;
		}
		delete y;
		return;

	}
	else
	{
		return ;
	}
}
template<class T>
void Left_Roation(Binary_Tree<T> & Tree,Binary_Tree_Node<T> * Node)//左旋
{
	Binary_Tree_Node<T> * y=NULL;
	y=Node->rightchild;
	if (y!=NULL)
	{
		if (y->leftchild!=NULL)
		{
			Node->rightchild=y->leftchild;
			y->leftchild->parent=Node;
		}
		else
		{
			Node->rightchild=NULL;
		}
		y->parent=Node->parent;
		if (Node->parent==NULL)
		{
			Tree.root=y;
		}
		else
		{
			if (Node->parent->leftchild==Node)
			{
				Node->parent->leftchild=y;
			}
			else
			{
				Node->parent->rightchild=y;
			}
		}
		y->leftchild=Node;
		Node->parent=y;
	}
	return;
}
template<class T>
void Right_Roation(Binary_Tree<T> & Tree,Binary_Tree_Node<T> * Node)//右旋
{
	Binary_Tree_Node<T> * y=NULL;
	y=Node->leftchild;
	if (y!=NULL)
	{
		if (y->rightchild!=NULL)
		{
			Node->leftchild=y->rightchild;
			y->rightchild->parent=Node;
		}
		else
		{
			Node->leftchild=NULL;
		}
		y->parent=Node->parent;
		if (Node->parent==NULL)
		{
			Tree.root=y;
		}
		else
		{
			if (Node->parent->leftchild==Node)
			{
				Node->parent->leftchild=y;
			}
			else
			{
				Node->parent->rightchild=y;
			}
		}
		y->rightchild=Node;
		Node->parent=y;
	}
	return;
}
#include <algorithm>
int * randIntGernate(int Num,bool output=true)//生成随机测试数组
{
	if (Num<=0)
	{
		return NULL;
	}
	int * RT=new int[Num];
	for (int i=0;i<Num;i++)
	{
		RT[i]=i;
	}
	random_shuffle(RT,RT+Num);
	//
	if (output)
	{
		cout<<"gernate rand "<<Num<<" Int array:"
			<<endl;
		for (int i=0;i<Num;i++)
		{
			cout<<RT[i]<<" ";
		}
		cout<<endl;
	}

	//
	return RT;	
}

#include <utility>
typedef pair<int,int> count_Pair;
template<class T>
void count_Path_Color(Binary_Tree_Node<T> * Node,count_Pair PathCount=count_Pair(0,0))
//打印红黑树的节点分布情况,检测红黑树是否正确
{
	if (Node!=NULL)
	{
		if (Node->C==RED)
		{
			PathCount.first++;
		}
		else
		{
			PathCount.second++;
		}
		count_Path_Color(Node->leftchild,PathCount);
		count_Path_Color(Node->rightchild,PathCount);
	}
	else
	{
		PathCount.second++;
		cout<<"RED:  "<<PathCount.first<<"  BLACK:  "<<PathCount.second<<endl;
	}
}
#include <string>
template<class T> 
void Print_Tree(Binary_Tree_Node<T> * Node, string s ="")//递归打印一颗树
{
	cout<<s;
	if (Node!=NULL)
	{
		if (Node->leftchild==NULL&&Node->rightchild==NULL)
		{
			cout<<Node->Key<<"_"<<(Node->C==RED?'R':'B')<<endl;//leaf
			return;
		}
		cout<<Node->Key<<"_"<<(Node->C==RED?'R':'B')<<" :[";
		Inorder_Tree_Walk(Node);
		cout<<"]"<<endl;
		//
		Print_Tree(Node->leftchild,s+"|  ");
		Print_Tree(Node->rightchild,s+"   ");
	}
	else
	{
		cout<<"NULL_B\r\n";
	}
}
void doTest(bool output=true)//测试
{
	while(1)
	{
		cout<<"How many nodes do you want the RB_Tree to have"<<endl;
		int num;
		cin>>num;
		int * arrayInt=randIntGernate(num,output);//随机化一个数组,填充红黑树
		Binary_Tree<int> tttt;
		for (int i=0;i<num;i++)
		{
			RB_Tree_Insert(tttt,arrayInt[i]);
		}
		delete [] arrayInt;
		Print_Tree(tttt.root);
		cout<<endl;
		count_Path_Color(tttt.root);
		while(1)
		{
			cout<<"Please chose an operator \r\n0:search\r\n1:delete\r\n2:insert\r\n-1:new RB_Tree\r\n";
			int a;
			cin>>a;
			if (a==-1)//新的树
			{
				break;
			}
			if (a==0)//查询
			{
				cout<<"please input the number to be searched:"<<endl;
				int number;
				cin>>number;
				Binary_Tree_Node<int> * find=Tree_Search(tttt.root,number);
				if (find!=NULL)
				{
					cout<<"find "<<number<<endl;
				}
				else
				{
					cout<<"can not find "<<number<<endl;
				}
			}
			if (a==1)//删除
			{
				cout<<"please input the number to be deleted:"<<endl;
				int number;
				cin>>number;
				Binary_Tree_Node<int> * find=Tree_Search(tttt.root,number);
				if (find==NULL)
				{
					cout<<number<<" not exist"<<endl;
				}
				cout<<"before delete"<<endl;
				Print_Tree(tttt.root);
				cout<<endl;
				count_Path_Color(tttt.root);
				cout<<endl;
				RB_Tree_Delete(tttt,find);
				cout<<"after delete "<<endl;
				Print_Tree(tttt.root);
				cout<<endl;
				count_Path_Color(tttt.root);
				cout<<endl;
			}
			else if (a==2)//插入
			{

				cout<<endl;
				cout<<"Please input the number to be inserted:"<<endl;
				int Num;
				cin>>Num;
				cout<<"before insert "<<endl;
				Print_Tree(tttt.root);
				cout<<endl;
				count_Path_Color(tttt.root);
				cout<<endl;
				RB_Tree_Insert(tttt,Num);
				cout<<"after insert:"<<Num<<endl;
				Print_Tree(tttt.root);
				cout<<endl;
				count_Path_Color(tttt.root);
				cout<<endl;
			}
		}

	}

}


hyjjkk
关注
专栏目录
算法导论：c++实现红黑树
imcy的博客
12-21 370
数据结构性质 这里定义一个结构体保存颜色enum colorRB { black = 0, red, }; struct TreeNode_RB { int val; colorRB color; TreeNode_RB *left; TreeNode_RB *right; TreeNode_RB *parent; TreeNod
算法导论-红黑树C++实现
weixin_30855761的博客
11-10 91
红黑树的定义： 一棵二叉查找树如果满足下面的红黑性质，则为一棵红黑树： 1）每个节点或是红的，或是黑的。 2）根节点是黑的。 3）每个叶节点（NIL）是黑节点。 4）如果一个节点是红的，则它的两个儿子都是黑的。 5）对每个节点，从该节点到其子孙节点的所有路径上包含相同节点数目的黑节点。 C++代码实现： BRTreeNode.h [cpp] view plai...
算法导论红黑树C++实现
sinat_15652045的博客
07-28 348
用一个类封装了红黑树的一些属性，水平有限，敬请批评指正，谢谢！#include "Header.h"enum NodeColor { Red, Black };struct RBTreeNode{RBTreeNode* leftchild;RBTreeNode* rightchild;RBTreeNode* parents;//char color;NodeColor color;int key;
算法导论 红黑树的C++代码实现
sinat_24520925的专栏
12-16 626
红黑树为满足下列五个条件的特殊二叉树 每个结点要么是红的要么是黑的。  根结点是黑的。  每个叶结点（叶结点即指树尾端NIL指针或NULL结点）都是黑的。  如果一个结点是红的，那么它的两个儿子都是黑的。   对于任意结点而言，其到叶结点树尾端NIL指针的每条路径都包含相同数目的黑结点。 本文代码根据算法导论上的伪代码编写，按照先序、中序、后序输出。可直接运行，如有错误，欢迎大家指正~~~
算法导论红黑树C++代码实现
05-15
红黑树C++代码实现
算法导论的红黑树的C++实现源码
03-29
在《算法导论》这本书中，红黑树是重要的章节之一，因为它提供了高效的数据存储和检索方法。下面我们将详细探讨红黑树的特性、C++实现的关键点以及测试验证的方法。 红黑树的主要特性： 1. 每个节点要么是红色，...
红黑树算法C++实现
07-07
该程序详细实现了红黑树算法,带有注释,能正确运行出结果
红黑树与区间树算法实现
04-08
通过C++实现和graphviz的可视化，学生能够直观地看到数据结构的操作过程，这对于理解和掌握这些高级数据结构的概念至关重要。对于IT专业人士来说，掌握这些数据结构的实现是提高算法效率和解决复杂问题的关键技能。
算法导论用C++实现代码
04-18
在《算法导论》的C++实现中，我们可能会遇到以下几个关键知识点： 1. **基本数据结构**：包括数组、链表、栈、队列、哈希表和树等。例如，二分查找通常在有序数组中使用，而链表可以用于实现动态大小的数据结构，如...
算法导论第十三章--红黑树C++代码实现
小博客
07-31 5474
红黑树的性质，各个操作的具体步骤在透彻了解红黑树之一   透彻了解红黑树之二         透彻了解红黑树之三  透彻理解红黑树之四 透彻理解红黑树之五，中已经讲的很详细了，在这里只将代码实现贴出来： BRTreeNode.h #include using namespace std; class BRTree; class BRTreeNode { private: frien
红黑树的c++ 实现
sysucph的专栏
04-05 143
红黑树，这个算法导论上有算法流程的介绍，这里简单实现了一下。不同于avl树，红黑树黑色叶子节点还是很有用，在处理删除操作时，多了null的叶子节点，算法写起来顺很多，因为有可能删除了节点之后，调整是从黑色的叶子节点开始的。 #ifndef __RBTREE_H__ #define __RBTREE_H__ #include <vector> #define RBTREE_NOD...
算法导论——红黑树插入算法C++实现
xiaowang627的博客
05-07 6272
红黑树图文详解及其C++语言实现
【数据结构】树（三）：红黑树插入与删除操作（C++实现）
快去创造奇迹
04-27 2690
红黑树性质及操作分析，包含C++代码实现
C++：STL学习之红黑树
Cold_Sun_的博客
09-05 1899
一、红黑树介绍 引用算法导论里面的话： 一颗红黑树是满足下面红黑性质的二叉搜索树： 1、每个结点是红色，或是黑色的 2、根结点是黑色的 3、每个叶结点NIL是黑色的 4、如果一个结点是红色的，则它的两个子结点都是黑色的 5、对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 根据红黑树的这些性质，易证：一颗有n个内部结点的红黑树的高度至多为2lg(n+1...
第102篇 C++数据结构（十二）红黑树的删除
weixin_49188222的博客
05-19 885
第102篇 C++数据结构（十二）红黑树的删除红黑树删除的结点孩子情况红黑树的删除代码实现红黑树删除被删除结点的情况红黑树删除的调整红黑树删除的代码实现红黑树删除总结 红黑树删除的结点孩子情况 红黑树的删除和普通的二叉搜索树的删除时一样的，都是存在三种情况： 1.删除的结点没有孩子，这时这个结点可以直接删除 2.删除的结点有一个孩子，则用孩子的数据来替换掉它的数据，像数组的删除用后面的数据把前面的数据覆盖掉一样，然后删除该结点 3.删除的结点有两个孩子，这种情况可以转成（1），（2）情况，就是找前驱结点或者
dp算法练习【7】
最新发布
MADAO的博客
09-08 1372
给你一个按排序的整数数组nums，返回组成的新数组，要求也按排序。平方后，数组变为 [16,1,0,9,100]排序后，数组变为 [0,1,9,16,100]非常简单，思路平方后排序。优化：插入法。
【数据结构】排序算法系列——希尔排序（附源码+图解）
Skrrapper的博客
09-07 1086
希尔排序实际上是个相当复杂的排序算法，这主要是跟它的步长序列gap到底该如何取、后续应该减小有关。时，数组已经接近有序的了，就整体而言，最后一次整体的插入排序就可以大大提高效率——我们从插入排序的时间复杂度分析也可以看出，可以看到每次减小gap的规律是将原先的gap/2，但事实上这只是其中一种处理方法，并不说明这是最优解。，使得平均情况下的时间复杂度能够在O(n^1.3)左右，而不好的选择则可能导致接近最坏情况的性能。中，我们会将整体数据一分为多份，进行散布式的插入排序，这时候每一个子序列之间的间隙就是。
【Python 千题 —— 算法篇】寻找两个正序数组的中位数
繁依Fanyi的博客
09-07 1254
合并排序法：易于理解，但时间复杂度较高，适合小规模数据。双指针法：通过双指针合并数组，时间复杂度 O(m + n)，适合中等规模数据。二分查找法：通过二分查找，在较短数组上进行划分，时间复杂度为 O(log(min(m, n)))，是处理大规模数据的最佳选择。对于这种涉及高效搜索和排序的题目，掌握二分查找的应用至关重要。通过本题目，我们不仅能够提升对数组和中位数的理解，还能够学到如何优化时间复杂度，使算法在处理大规模数据时更加高效。
C++实现红黑树插入操作详解
"红黑树的插入操作c++实现" 红黑树是一种自平衡二叉查找树，它的每个节点都带有颜色属性，可以是红色或黑色。这种数据结构在保持搜索效率的同时，通过特定的规则和旋转操作来保证树的平衡，从而确保最坏情况下的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值