二叉堆-顺序存储

数组实现二叉堆

---

创建3个文件：heapArray.h、heapArray.c、heapArrayTest.c

---

heapArray.h

#ifndef HEAP_ARRAY_H_
#define HEAP_ARRAY_H_

#ifdef __GNUC__
	#define DEPRECATED __attribute__( (deprecated) )
#elif defined(_MSC_VER)
	#define DEPRECATED __declspec( deprecated )
#else
	#define DEPRECATED
#endif

#ifndef PTOI
	#define PTOI( p ) ((int32_t)(int64_t)(p))
#endif
#ifndef ITOP
	#define ITOP( i ) ((void *)(int64_t)(i))
#endif

#define ADT HeapArray

// 功能: a与b的比较过程.
// 参数: a, b.
// 返回: a>b返回正数, a

heapArray.c

#include 
#include 
#include 
#include "heapArray.h"


// 功能: 打印错误信息后就错误退出程序.
// 参数: expression(错误判断表达式), message(需打印的错误信息).
// 返回: 无.
// 注意: 当表达式 expression 为真时, 才触发.
#define ERROR_EXIT( expression, message )                                    \
if( (expression) ) {                                                         \
	fprintf( stderr, "\nerror location: file = %s, func = %s, line = %d.\n", \
	                       __FILE__, __func__, __LINE__ );                   \
	fprintf( stderr, "error  message: %s%s.\n\a",                            \
	                       (message) != NULL ? (message) : __func__,         \
		                   (message) != NULL ? "" : " function error" );     \
	exit( EXIT_FAILURE );                                                    \
}

// 功能: 数组的两个元素进行互换.
// 参数: a(数组首地址), i(数组下标), j(数组下标).
// 返回: 无.
// 注意: 没有副作用的宏, C99标准: #define f ({...}).
#define SWAP( a, i, j ) ({            \
	int32_t i1i1i = (i), j1j1j = (j); \
	void *t1t1t = *((a) + i1i1i);     \
	*((a) + i1i1i) = *((a) + j1j1j);  \
	*((a) + j1j1j) = t1t1t;           \
})

#define ADT HeapArray


struct HeapArray {
	int32_t capacity;
	int32_t size;
	CompareFunc *cmp;
	void *array[0];
};


ADT *newHeapArray( int32_t capacity, CompareFunc *cmp ) {
	ADT *heap = NULL;

	ERROR_EXIT( !cmp, NULL );
	capacity = capacity < 0 ? 512 : capacity;
	heap = malloc( sizeof(*heap) + sizeof(heap->array[0]) * capacity );
	ERROR_EXIT( !heap, NULL );
	heap->capacity = capacity;
	heap->size = 0;
	heap->cmp = cmp;

	return heap;
}

void *addHeapArray( HeapArray *heap, void *data ) {
	int32_t i = 0;

	ERROR_EXIT( !heap || heap->size >= heap->capacity, NULL );
	i = heap->size++;
	heap->array[i] = data;

	for( int32_t p = (i - 1) / 2; heap->cmp( heap->array[i], heap->array[p] ) < 0; p = (i - 1) / 2 ) {
		// i: index, p: parent.
		SWAP( heap->array, p, i );
		i = p;
	}

	return data;
}

void *addHeadHeapArray( HeapArray *heap, void *data ) {
	return NULL;
}

void *pollHeapArray( HeapArray *heap ) {
	int32_t i = 0;

	ERROR_EXIT( !heap || heap->size < 1, NULL );
	SWAP( heap->array, 0, heap->size - 1 ); // 堆顶与堆底进行对换.
	--heap->size;
	for( int32_t l = i * 2 + 1; l < heap->size; l = i * 2 + 1 ) { // 从堆顶至堆底方向进行调整.
		// l: left child, r: right child, m: maximum or minimum.
		int32_t r = l + 1, m = l;
		if( r < heap->size && heap->cmp( heap->array[r], heap->array[l] ) < 0 ) {
			m = r;
		}
		if( heap->cmp( heap->array[i], heap->array[m] ) <= 0 ) {
			break;
		}
		SWAP( heap->array, m, i );
		i = m;
	}

	return heap->array[heap->size];
}

void *pollTailHeapArray( HeapArray *heap ) {
	ERROR_EXIT( !heap || heap->size < 1, NULL );

	return heap->array[--heap->size];
}

void *peekHeapArray( HeapArray *heap ) {
	ERROR_EXIT( !heap || heap->size < 1, NULL );

	return heap->array[0];
}

void *peekTailHeapArray( HeapArray *heap ) {
	ERROR_EXIT( !heap || heap->size < 1, NULL );

	return heap->array[heap->size - 1];
}

int existHeapArray( HeapArray *heap, void *data ) {
	ERROR_EXIT( !heap, NULL );

	for( int32_t i = 0; i < heap->size; ++i ) {
		if( !heap->cmp( heap->array[i], data ) ) {
			return 1;
		}
	}

	return 0;
}

int32_t findHeapArray( HeapArray *heap, void *data ) {
	ERROR_EXIT( !heap, NULL );
	for( int32_t i = 0; i < heap->size; ++i ) {
		if( !heap->cmp( heap->array[i], data ) ) {
			return i;
		}
	}

	return -1;
}

int32_t findTailHeapArray( HeapArray *heap, void *data ) {
	ERROR_EXIT( !heap, NULL );
	for( int32_t i = heap->size - 1; i >= 0; --i ) {
		if( !heap->cmp( heap->array[i], data ) ) {
			return i;
		}
	}

	return -1;
}

int32_t sizeHeapArray( HeapArray *heap ) {
	ERROR_EXIT( !heap, NULL );

	return heap->size;
}

int emptyHeapArray( HeapArray *heap ) {
	ERROR_EXIT( !heap, NULL );

	return heap->size < 1;
}

int fullHeapArray( HeapArray *heap ) {
	ERROR_EXIT( !heap, NULL );

	return heap->size >= heap->capacity;
}

int32_t capacityHeapArray( HeapArray *heap ) {
	ERROR_EXIT( !heap, NULL );

	return heap->capacity;
}

void clearHeapArray( HeapArray *heap ) {
	ERROR_EXIT( !heap, NULL );

	heap->size = 0;
}

void delHeapArray( HeapArray **heap ) {
	ERROR_EXIT( !heap, NULL );
	free( *heap );
	*heap = NULL;
}

heapArrayTest.c

#include 
#include 
#include 
#include 
#include "heapArray.h"


// a>b返回正数, a