堆

最新推荐文章于 2023-05-28 11:19:59 发布
最新推荐文章于 2023-05-28 11:19:59 发布
阅读量636 收藏
点赞数
分类专栏： data structure 文章标签： null insert delete struct 测试 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kusey/article/details/8090496
版权

堆的定义：

1. 堆是一个完全二叉树（最底层的节点都集中在左边，其它各层的节点都是满的）。

2. 父节点的值总是大于（或者小于）左右子节点的值。

3. 父节点的左右子树都是一个最大堆（或者最小堆）。


堆的存储：

        一般情况下都使用数组来表示堆，i节点的父节点的下标为(i-1)/2，它的左右子节点的下标分别为i*2+1和i*2+2。下标从0开始。


插入：

        插入一个节点，先插到堆的最末尾，然后比较这个节点的值跟其父节点值的大小，如果大于（对于最大堆来说是大于，对于最小堆是小于）父节点的值，则交换这两个节点的值，继续向上进行比较。

删除：

        堆的删除都是从堆顶开始，删除根节点，然后把最后一个节点挪到根节点的位置，比较这个节点跟它的两个子节点的值的大小，如果这个值小于（对于最大堆来说是小于，对于最小堆是大于）两个子节点中比较大的值（最小堆是选择比较小的值），则交换这两个节点的值，继续向下进行比较。

层次遍历：

        数的层次遍历，需要用到队列，先把根节点enqueue到队列中，然后循环判断队列是否为空，如果不为空，则dequeue队列头的节点并输入这个节点的值，把这个节点的左节点和右节点enqueue到队列中，继续下一个循环过程，直到队列中所有的节点都dequeue出来了，层次遍历结束。


queue.h

#ifndef __queue_h__
#define __queue_h__

#include "heap.h"

#define DEFAULT_QUEUE_SIZE		32
#define DEFAULT_INCREAM_SIZE	8

typedef struct _queue {
	uint		_size;
	uint		_head;
	uint		_tail;
	PHEAPNODE	*_nodes;
} QUEUE, *PQUEUE;

PQUEUE		queue_create	();
void		queue_destroy	( PQUEUE pqueue );
int			queue_enqueue	( PQUEUE pqueue, PHEAPNODE pnode );
PHEAPNODE	queue_dequeue	( PQUEUE pqueue );
uint		queue_size		( PQUEUE pqueue );
int			queue_empty		( PQUEUE pqueue );

#endif // __queue_h__

queue.c 

#include "queue.h"
#include <stdio.h>
#include <malloc.h>

PQUEUE queue_create()
{
	PQUEUE pqueue = (PQUEUE)malloc( sizeof(QUEUE) );
	if( NULL != pqueue ) {
		pqueue->_nodes = (PHEAPNODE*)malloc( sizeof(PHEAPNODE) * DEFAULT_QUEUE_SIZE );
		if( NULL != pqueue->_nodes ) {
			pqueue->_size = DEFAULT_QUEUE_SIZE;
			pqueue->_head = -1;
			pqueue->_tail = -1;
		}
		else {
			free( pqueue );
			pqueue = NULL;
		}
	}
	return pqueue;
}

void queue_destroy( PQUEUE pqueue )
{
	if( NULL == pqueue )
		return;
	free( pqueue->_nodes );
	free( pqueue );
	pqueue = NULL;
}

int queue_enqueue( PQUEUE pqueue, PHEAPNODE pnode )
{
	PHEAPNODE	*pnodes	= NULL;
	uint		i		= 0;

	if( NULL == pqueue || NULL == pqueue->_nodes )
		return 0;

	if( -1 == pqueue->_head )
		pqueue->_head = 0;
	else if( (pqueue->_tail + 1) == pqueue->_size ) {
		pnodes = (PHEAPNODE*)malloc( sizeof(PHEAPNODE) * (pqueue->_size + DEFAULT_INCREAM_SIZE) );
		for( i = pqueue->_head; i <= pqueue->_tail; i++ )
			pnodes[i] = pqueue->_nodes[i];
		free( pqueue->_nodes );
		pqueue->_nodes = pnodes;
		pqueue->_size += DEFAULT_INCREAM_SIZE;
	}

	pqueue->_nodes[pqueue->_tail + 1] = pnode;
	pqueue->_tail++;

	return 1;
}

PHEAPNODE queue_dequeue( PQUEUE pqueue )
{
	if( NULL == pqueue || NULL == pqueue->_nodes )
		return NULL;

	if( pqueue->_head > pqueue->_tail )
		return NULL;

	return pqueue->_nodes[pqueue->_head++];
}

int queue_empty( PQUEUE pqueue )
{
	if( NULL == pqueue || NULL == pqueue->_nodes )
		return 1;
	if( -1 == pqueue->_head )
		return 1;
	if( pqueue->_head > pqueue->_tail )
		return 1;
	return 0;
}

heap.h 

#ifndef __heap_h__
#define __heap_h__

#ifndef	DLLEXPORT
#define	DLLAPI		__declspec(dllimport)
#else
#define	DLLAPI		__declspec(dllexport)
#endif

typedef	unsigned int	uint;
typedef uint			Data;

typedef struct _heap_node {
	Data				_data;
	struct _heap_node	*_parent;
	struct _heap_node	*_left;
	struct _heap_node	*_right;
} HEAPNODE, *PHEAPNODE;

typedef enum {
	HEAP_MINIMUM,
	HEAP_MAXIMUM
} eHeapType;

typedef struct _heap {
	eHeapType	_type;
	PHEAPNODE	_root;
} HEAP, *PHEAP;

typedef void (*visit_func)( PHEAPNODE pnode );

#ifdef	__cplusplus
extern "C" {
#endif

	PHEAP		DLLAPI	heap_create				( eHeapType type );
	PHEAP		DLLAPI	heap_from_array			( eHeapType type, Data *pdata, uint num );
	void		DLLAPI	heap_destroy			( PHEAP pheap );
	int			DLLAPI	heap_insert				( PHEAP pheap, Data data );
	void		DLLAPI	heap_remove				( PHEAP pheap );
	void		DLLAPI	heap_to_array			( PHEAP pheap, Data *pdata, uint num );
	void		DLLAPI	heap_pre_order_visit	( PHEAP pheap, visit_func pvf );
	void		DLLAPI	heap_in_order_visit		( PHEAP pheap, visit_func pvf );
	void		DLLAPI	heap_post_order_visit	( PHEAP pheap, visit_func pvf );
	void		DLLAPI	heap_order_visit		( PHEAP pheap, visit_func pvf );
	PHEAPNODE	DLLAPI	heap_find_data			( PHEAP pheap, Data data );
	uint		DLLAPI	heap_node_count			( PHEAP pheap );

#ifdef	__cplusplus
}
#endif

#endif // __heap_h__

heap.c 

#define DLLEXPORT

#include "heap.h"
#include "queue.h"
#include <stdio.h>
#include <malloc.h>

//============================================================================//

static void			s_heap_delete_node		( PHEAPNODE pnode );
static PHEAPNODE	s_heap_find_insert_pos	( PHEAP pheap );
static PHEAPNODE	s_heap_find_last_node	( PHEAP pheap );
static void			s_heap_pre_order_visit	( PHEAPNODE pnode, visit_func pvf );
static void			s_heap_in_order_visit	( PHEAPNODE pnode, visit_func pvf );
static void			s_heap_post_order_visit	( PHEAPNODE pnode, visit_func pvf );
static void			s_heap_order_visit		( PHEAPNODE pnode, visit_func pvf );
static PHEAPNODE	s_heap_find_data		( PHEAPNODE pnode, Data data );
static uint			s_heap_node_count		( PHEAPNODE pnode );

//============================================================================//

PHEAP DLLAPI heap_create( eHeapType type )
{
	PHEAP pheap = (PHEAP)malloc( sizeof(HEAP) );
	if( NULL != pheap ) {
		pheap->_type = type;
		pheap->_root = NULL;
	}
	return pheap;
}

void DLLAPI heap_destroy( PHEAP pheap )
{
	if( NULL == pheap )
		return;
	
	s_heap_delete_node( pheap->_root );

	free( pheap );
	pheap = NULL;

	return;
}

PHEAP DLLAPI heap_from_array( eHeapType type, Data *pdata, uint num )
{
	PHEAP	pheap	= NULL;
	uint	i		= 0;

	if( NULL == pdata || 0 == num )
		return NULL;

	pheap = heap_create( type );
	if( NULL == pheap )
		return pheap;

	for( i = 0; i < num; i++ )
		heap_insert( pheap, pdata[i] );

	return pheap;
}

void DLLAPI heap_to_array( PHEAP pheap, Data *pdata, uint num )
{
	PQUEUE		pqueue	= NULL;
	int			index	= 0;
	PHEAPNODE	p		= NULL;

	if( NULL == pheap || NULL == pheap->_root || NULL == pdata || 0 == num )
		return;

	pqueue = queue_create();
	if( NULL == pqueue )
		return;

	queue_enqueue( pqueue, pheap->_root );
	while( !queue_empty(pqueue) ) {
		p = queue_dequeue(pqueue);
		if( NULL == p )
			break;
		pdata[index++] = p->_data;
		if( index == num )
			break;
		queue_enqueue( pqueue, p->_left );
		queue_enqueue( pqueue, p->_right );
	} 

	queue_destroy( pqueue );
}

int DLLAPI heap_insert( PHEAP pheap, Data data )
{
	PHEAPNODE	parent	= NULL;
	PHEAPNODE	child	= NULL;

	if( NULL == pheap )
		return 0;

	if( NULL == pheap->_root ) {
		pheap->_root = (PHEAPNODE)malloc( sizeof(HEAPNODE) );
		if( NULL == pheap->_root )
			return 0;
		else {
			pheap->_root->_data = data;
			pheap->_root->_parent = pheap->_root->_left = pheap->_root->_right = NULL;
			return 1;
		}
	}

	if( heap_find_data(pheap, data) )
		return 0;

	parent = s_heap_find_insert_pos(pheap);
	if( NULL == parent )
		return 0;
	else {
		child = (PHEAPNODE)malloc( sizeof(HEAPNODE) );
		if( NULL == child )
			return 0;
		child->_data = data;
		child->_parent = parent;
		child->_left = child->_right = NULL;

		if( NULL == parent->_left )
			parent->_left = child;
		else
			parent->_right = child;

		if( HEAP_MAXIMUM == pheap->_type ) {
			while( child->_data > parent->_data ) {
				child->_data = parent->_data;
				parent->_data = data;
				child = parent;
				parent = child->_parent;
				if( NULL == parent )
					break;
			}
		}
		else {
			while( child->_data < parent->_data ) {
				child->_data = parent->_data;
				parent->_data = data;
				child = parent;
				parent = child->_parent;
				if( NULL == parent )
					break;
			}
		}

		return 1;
	}
}

void DLLAPI heap_remove( PHEAP pheap )
{
	PHEAPNODE	plast	= NULL;
	PHEAPNODE	parent	= NULL;
	PHEAPNODE	child	= NULL;
	PHEAPNODE	left	= NULL;
	PHEAPNODE	right	= NULL;
	Data		temp	= 0;

	if( NULL == pheap || NULL == pheap->_root )
		return;

	plast = s_heap_find_last_node( pheap );
	if( pheap->_root != plast ) {
		pheap->_root->_data = plast->_data;
		parent = plast->_parent;
		if( parent->_left == plast )
			parent->_left = NULL;
		else
			parent->_right = NULL;
		parent = pheap->_root;
		while( NULL != parent ) {
			child = NULL;
			left = parent->_left;
			right = parent->_right;
			if( HEAP_MAXIMUM == pheap->_type ) {
				if( NULL != left && parent->_data < left->_data && 
					(NULL == right || (NULL != right && right->_data < left->_data)) )
						child = left;
				else if( NULL != right && parent->_data < right->_data &&
					(NULL == left || (NULL != left && left->_data < right->_data)) )
						child = right;
				else
					break;
				temp = parent->_data;
				parent->_data = child->_data;
				child->_data = temp;
				parent = child;
			}
			else {
				if( NULL != left && parent->_data > left->_data &&
					(NULL == right || (NULL != right && right->_data > left->_data)) )
						child = left;
				else if( NULL != right && parent->_data > right->_data &&
					(NULL == left || (NULL != left && left->_data > right->_data)) )
						child = right;
				else
					break;
				temp = parent->_data;
				parent->_data = child->_data;
				child->_data = temp;
				parent = child;
			}
		}
	}

	free( plast );
	plast = NULL;
}

void DLLAPI heap_pre_order_visit( PHEAP pheap, visit_func pvf )
{
	if( NULL == pheap || NULL == pheap->_root || NULL == pvf )
		return;
	s_heap_pre_order_visit( pheap->_root, pvf );
}

void DLLAPI heap_in_order_visit( PHEAP pheap, visit_func pvf )
{
	if( NULL == pheap || NULL == pheap->_root || NULL == pvf )
		return;
	s_heap_in_order_visit( pheap->_root, pvf );
}

void DLLAPI heap_post_order_visit( PHEAP pheap, visit_func pvf )
{
	if( NULL == pheap || NULL == pheap->_root || NULL == pvf )
		return;
	s_heap_post_order_visit( pheap->_root, pvf );
}

void DLLAPI heap_order_visit( PHEAP pheap, visit_func pvf )
{
	if( NULL == pheap || NULL == pheap->_root || NULL == pvf )
		return;
	s_heap_order_visit( pheap->_root, pvf );
}

PHEAPNODE DLLAPI heap_find_data( PHEAP pheap, Data data )
{
	if( NULL == pheap || NULL == pheap->_root )
		return NULL;
	return s_heap_find_data( pheap->_root, data );
}

uint DLLAPI heap_node_count( PHEAP pheap )
{
	if( NULL == pheap || NULL == pheap->_root )
		return 0;
	return s_heap_node_count( pheap->_root );
}

//============================================================================//

void s_heap_delete_node( PHEAPNODE pnode )
{
	if( NULL == pnode )
		return;

	if( NULL != pnode->_left )
		s_heap_delete_node( pnode->_left );
	if( NULL != pnode->_right )
		s_heap_delete_node( pnode->_right );

	free( pnode );
	pnode = NULL;
}

void s_heap_pre_order_visit( PHEAPNODE pnode, visit_func pvf )
{
	pvf( pnode );
	if( NULL != pnode->_left )
		s_heap_pre_order_visit( pnode->_left, pvf );
	if( NULL != pnode->_right )
		s_heap_pre_order_visit( pnode->_right, pvf );
}

void s_heap_in_order_visit( PHEAPNODE pnode, visit_func pvf )
{
	if( NULL != pnode->_left )
		s_heap_in_order_visit( pnode->_left, pvf );
	pvf( pnode );
	if( NULL != pnode->_right )
		s_heap_in_order_visit( pnode->_right, pvf );
}

void s_heap_post_order_visit( PHEAPNODE pnode, visit_func pvf )
{
	if( NULL != pnode->_left )
		s_heap_post_order_visit( pnode->_left, pvf );
	if( NULL != pnode->_right )
		s_heap_post_order_visit( pnode->_right, pvf );
	pvf( pnode );
}

void s_heap_order_visit( PHEAPNODE pnode, visit_func pvf )
{
	PQUEUE		pqueue	= NULL;
	PHEAPNODE	p		= NULL;

	if( NULL == pnode || NULL == pvf )
		return;

	pqueue = queue_create();
	if( NULL == pqueue )
		return;

	queue_enqueue( pqueue, pnode );
	while( !queue_empty(pqueue) ) {
		p = queue_dequeue(pqueue);
		if( NULL == p )
			break;
		pvf( p );
		queue_enqueue( pqueue, p->_left );
		queue_enqueue( pqueue, p->_right );
	} 

	queue_destroy( pqueue );
}

PHEAPNODE s_heap_find_insert_pos( PHEAP pheap )
{
	PQUEUE		pqueue	= NULL;
	PHEAPNODE	ret		= NULL;
	PHEAPNODE	p		= NULL;

	if( NULL == pheap || NULL == pheap->_root )
		return NULL;

	pqueue = queue_create();
	if( NULL == pqueue )
		return NULL;

	queue_enqueue( pqueue, pheap->_root );
	while( !queue_empty(pqueue) ) {
		p = queue_dequeue(pqueue);
		if( NULL == p )
			break;

		if( NULL == p->_left ) {
			ret = p;
			break;
		}
		else if( NULL == p->_right ) {
			ret = p;
			break;
		}
		else {
			queue_enqueue( pqueue, p->_left );
			queue_enqueue( pqueue, p->_right );
		}
	} 

	queue_destroy( pqueue );
	return ret;
}

PHEAPNODE s_heap_find_last_node( PHEAP pheap )
{
	PQUEUE		pqueue	= NULL;
	PHEAPNODE	pret	= NULL;
	PHEAPNODE	p		= NULL;

	if( NULL == pheap || NULL == pheap->_root )
		return NULL;

	pqueue = queue_create();
	if( NULL == pqueue )
		return NULL;

	queue_enqueue( pqueue, pheap->_root );
	while( !queue_empty(pqueue) ) {
		p = queue_dequeue(pqueue);
		if( NULL == p )
			break;
		else
			pret = p;
		queue_enqueue( pqueue, p->_left );
		queue_enqueue( pqueue, p->_right );
	} 

	queue_destroy( pqueue );
	return pret;	
}

PHEAPNODE s_heap_find_data( PHEAPNODE pnode, Data data )
{
	PHEAPNODE pret = NULL;

	if( NULL == pnode )
		return NULL;
	if( pnode->_data == data )
		return pnode;
	pret = s_heap_find_data( pnode->_left, data );
	if( NULL == pret )
		pret = s_heap_find_data( pnode->_right, data );
	return pret;
}

uint s_heap_node_count( PHEAPNODE pnode )
{
	if( NULL == pnode )
		return 0;
	return s_heap_node_count( pnode->_left ) + s_heap_node_count( pnode->_right ) + 1;
}

测试代码：

#include "../heap/heap.h"
#include <iostream>

#pragma comment( lib, "../bin/heap.lib" )

void visit( PHEAPNODE pnode )
{
	if( NULL != pnode )
		std::cout << pnode->_data << "  ";
}

int main( void )
{
	PHEAP pheap = heap_create( HEAP_MINIMUM );
	heap_insert( pheap, 54 );
	heap_insert( pheap, 27 );
	heap_insert( pheap, 35 );
	heap_insert( pheap, 99 );
	heap_insert( pheap, 890 );
	heap_insert( pheap, 2 );
	heap_insert( pheap, 34865 );

	uint count = heap_node_count( pheap );
	if( count > 0 ) {
		Data *pdata = new Data[count];
		heap_to_array( pheap, pdata, count );
		for( uint i = 0; i < count; i++ )
			std::cout << pdata[i] << "  ";
		std::cout << std::endl;
		delete []pdata;
	}

	heap_pre_order_visit( pheap, visit );	std::cout << std::endl;
	heap_in_order_visit( pheap, visit );	std::cout << std::endl;
	heap_post_order_visit( pheap, visit );	std::cout << std::endl;

	heap_remove( pheap );
	heap_order_visit( pheap, visit );		std::cout << std::endl;

	heap_remove( pheap );
	heap_order_visit( pheap, visit );		std::cout << std::endl;

	heap_destroy( pheap );

	return 0;
}

运行结果：


kusey
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
堆排序详细图解（通俗易懂）
oorik的博客
02-17 23万+
什么是堆 堆是一种叫做完全二叉树的数据结构，可以分为大根堆，小根堆，而堆排序就是基于这种结构而产生的一种程序算法。 堆的分类 大根堆:每个节点的值都大于或者等于他的左右孩子节点的值 小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值 两种结构映射到数组为: 大根堆: 小根堆: //父-->子:i--->左孩子:2*i+1, 右孩子:2*i+2; //子-->父:i--->(i-1)*2;(i为下标元素) 排序思想 1.首先将待排序的数...
dispatch_queue_create---创建队列
TungKamLau
05-20 9320
dispatch_queue_create(const char *label, dispatch_queue_attr_t attr); 可以看到创建队列的方法有两个参数可以传，默认的创建方式是这样的 dispatch_queue_t queue = dispatch_queue_create("TreeNewBee_queue", NULL); 后面的参数传入”NULL”就可以了。或许大家
一文读懂堆与栈的区别
Dablelv 的博客专栏。
06-29 39万+
堆（Heap）与栈（Stack）是开发人员必须面对的两个概念，在理解这两个概念时，需要放到具体的场景下，因为不同场景下，堆与栈代表不同的含义。一般情况下，有两层含义： （1）程序内存布局场景下，堆与栈表示的是两种程序内存分区； （2）数据结构场景下，堆与栈表示两种常用的数据结构。 1.程序内存分区——堆与栈 栈由操作系统自动分配释放 ，用于存放函数的参数值、局部变量的值等，其操作方式类......
交换机堆叠配置
热门推荐
紫墨丹青
06-21 59万+
两台交换机堆叠： 网络拓扑； 堆叠配置。 三台交换机堆叠： 网络拓扑： 堆叠配置。
堆排序算法（图解详细流程）
阿顾的博客
08-04 23万+
堆排序的时间复杂度O(N*logN),额外空间复杂度O(1)，是一个不稳定性的排序 目录 一 准备知识 1.1 大根堆和小根堆 二 堆排序基本步骤 2.1 构造堆 2.2固定最大值再构造堆 三 总结 四代码 一 准备知识 堆的结构可以分为大根堆和小根堆，是一个完全二叉树，而堆排序是根据堆的这种数据结构设计的一种排序，下面先来看看什么是大根堆和小根堆 1.1 大根...
堆排序
guanlovean
06-20 19万+
1、首先了解堆是什么 堆是一种数据结构，一种叫做完全二叉树的数据结构。 2、堆的性质 这里我们用到两种堆，其实也算是一种。 大顶堆：每个节点的值都大于或者等于它的左右子节点的值。 小顶堆：每个节点的值都小于或者等于它的左右子节点的值。 如上所示，就是两种堆。 如果我们把这种逻辑结构映射到数组中，就是下边这样 9 5 8 2 3 4 7 ...
排序算法：堆排序
最新发布
Yikefore的博客
05-28 2717
关于排序算法中的堆排序的详细介绍，以及实现过程和时间复杂度的计算，附带图解。
JVM - 堆
目目沐沐
01-28 4万+
JVM - 堆
数据结构——堆
漫漫无期的博客
10-10 5617
一、概念及其介绍 堆(Heap)是计算机科学中一类特殊的数据结构的统称。 堆通常是一个可以被看做一棵完全二叉树的数组对象。 堆满足下列性质： 堆中某个节点的值总是不大于或不小于其父节点的值。 堆总是一棵完全二叉树。 二、适用说明 堆是利用完全二叉树的结构来维护一组数据，然后进行相关操作，一般的操作进行一次的时间复杂度在O(1)~O(logn)之间，堆通常用于动态分配和释放程序所使用的对象。 若为优先队列的使用场景，普通数组或者顺序数组，最差情况为O(n^2)，堆这种数据结构也可以提高入队...
浅析栈区和堆区内存分配的区别
09-05
栈区和堆区是编程语言中内存管理的两个重要概念，它们在内存分配和管理上有显著的区别。首先，栈区，也称为栈，是编译器自动分配和释放的内存区域，主要用于存放函数参数值和局部变量。栈的内存分配是连续的，就像一...
图解堆排序
12-21
在深入探讨堆排序之前，首先我们要理解堆的概念和顺序存储二叉树的特性。顺序存储二叉树是一种特殊的数组表示的二叉树，通常只考虑完全二叉树，即每一层除了最后一个节点外，其余节点都完全填充。在这种存储方式中，...
Java实现堆排序
03-30
堆排序是一种基于比较的排序算法，其主要原理是利用了完全二叉树的特性来对数据进行排序。在Java中实现堆排序，我们需要理解堆的数据结构以及如何维护堆的性质。接下来，我们将深入探讨这个话题。 堆是一个近似完全...
华为交换机堆叠
12-26
1. **配置交换机堆叠端口**：将出厂堆叠物理接口G0/0/28和G0/0/27分别加入到堆叠端口1和堆叠端口2，以实现所有堆叠交换机之间的堆叠端口交叉相连。初始状态下，所有成员交换机的堆叠ID均为默认的0，因此所有成员...
交换机堆叠技术详细介绍
10-01
### 交换机堆叠技术详解 #### 一、概述 交换机堆叠技术是指通过特定的方式将多台物理上的交换机连接在一起，使其在逻辑上表现为一台设备的技术。这种技术可以提高网络性能、扩展端口数量，并简化网络管理。本文将...
提高网络健壮性必杀技之——堆叠.doc
01-20
提高网络健壮性必杀技之——堆叠 堆叠是一种提高网络健壮性的技术，通过将多个网络设备或系统连接在一起，以提高网络的可靠性和冗余性。这种技术广泛应用于各种网络环境中，如数据中心、企业网络、电信网络等。 在...
java实现堆的操作方法(建堆,插入,删除)
08-28
下面小编就为大家分享一篇java实现堆的操作方法(建堆,插入,删除)，具有很好的参考价值，希望对大家有所帮助
iOS实现卡片堆叠效果
08-19
iOS实现卡片堆叠效果 iOS实现卡片堆叠效果是指在iOS平台上实现类似于安卓5.0的Material Design设计语言中的卡片堆叠效果，通过巧妙地使用UIScrollView和Core Animation来实现卡片的堆叠和缩放效果。下面是对该效果...
二叉堆与堆排序详解
"堆排序是一种基于完全二叉树结构的高效排序算法，它利用了堆的特性进行排序。堆可以是大顶堆或小顶堆，其中大顶堆的每个节点都大于或等于其子节点，小顶堆则相反。在完全二叉树中，从根节点到叶子节点的路径上的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值