堆和堆实现、堆排序

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/wanzew/article/details/82919227

最大堆实现：

class maxHeap{
public:
	maxHeap(int capa) :capacity(capa),count(0){
		data = new int[capa+1];
	}
	~maxHeap() { delete[] data; }
		
	int size() { return count; }

	void insert(int item) {
		data[++count] = item;
		maxHeapUp(count);
	}

	int max() {
		int v = data[1];

		swap(data[count--], data[1]);
		maxHeapDown(1);

		return v;
	}
private:
	int count;
	int capacity;
	int* data;
	void maxHeapUp(int index) {
		while (index > 1 && data[index /2] < data[index]) {
			swap(data[index], data[index / 2]);
			index /= 2;
		}
	}

	void maxHeapDown(int index) {
		while (2 * index <= count) {
			int sub_left = 2 * index;
			int max_side = sub_left;
			if (sub_left + 1 <= count && data[sub_left + 1] > data[sub_left])
				max_side = sub_left + 1;
			if (data[index] < data[max_side])
				swap(data[index], data[max_side]);
			index = max_side;
		}
	}
}

原地堆排序：

void maxHeapDown(int arr[], int i, int index_uplimit) {
	while (2 * i + 1 <= index_uplimit) {
		int sub_left = 2 * i + 1;
		int max_side = sub_left;

		//找到子树中最大的一边
		if (sub_left + 1 <= index_uplimit && arr[sub_left + 1] > arr[sub_left])
			max_side = sub_left +1;

		//最大堆：你还没下面大的大
		if (arr[i] < arr[max_side])
			swap(arr[i], arr[max_side]);
		else
			break;
		i = max_side;
	}
}

void heapSortInplace(int arr[], int index) {
	//heapify
	for (int i = (index - 1) / 2; i >= 0; i--) {
		maxHeapDown(arr, i, index);
	}
	//sort				//i不用=0
	for (int i = index; i >= 0; i--) {
		swap(arr[0],  arr[i]);
		maxHeapDown(arr, 0, i - 1);
	}
}

从包含n个数字的数组中选取top100（最小堆实现）：

class PriorityQueue {
private:
	int count;
	int capacity;
	int *data;
	void minHeapDown(int index) {
		while (index * 2 <= capacity) {
			int sub_left = index * 2;
			int min_side = sub_left;
			if (sub_left + 1 <= capacity && data[sub_left + 1] < data[sub_left])
				min_side = sub_left + 1;
			//最小堆：你比下面小的还小
			if (data[index] > data[min_side])
				swap(data[index], data[min_side]);
			else 
				break;
			index = min_side;
		}
	}
	void minHeapUp(int index) {
		while (index > 1) {
			if (data[index] < data[index / 2])
				swap(data[index], data[index / 2]);
			index /= 2;
		}
	}
public:
	PriorityQueue(int top):capacity(top),count(0){
		data = new int[top +1];
	}
	~PriorityQueue() { delete[] data; }

	//用数组前top个元素初始化最小堆，最小堆一共top个元素
	//
	void buildHeap(int arr[]) {
		for (int i = 0; i < capacity; i++) {
			data[++count] = arr[i];
			minHeapUp(count);
		}
	}

	//arr数组中从第top+1个元素开始，依次和data[1]对比
	//比data[1]大就下沉
	void selectTop(int arr[], int len) {
		for (int i = capacity; i < len; i++) {
			if (arr[i] > data[1]) {
				data[1] = arr[i];
				minHeapDown(1);
			}
		}
	}

	void printData() {
		for (int i = 1; i <= capacity; i++) {
			cout << data[i] << " ";
		}
		cout << endl;
	}

};