排序算法——基于C++

几种排序算法的实现：
1.插入排序
2.归并排序
3.堆排序
4.快速排序
5.随机快速排序

#include<iostream>
#include<cstdlib>
#include<ctime>
#include<math.h>
#include<algorithm>

using namespace std;

//array size
int ARRAY_SIZE = 10 * 1024;


//插入排序(in place)  升序
void insert_sort(long *arr, int arr_len)
{
	int temp;

	for (int i = 0; i < arr_len; i++)
	{
		for (int j = i + 1; j < arr_len; j++)
		{
			if (arr[j] <= arr[i])
			{
				temp = arr[j];
				arr[j] = arr[i];
				arr[i] = temp;
			}
		}
	}

}


void merge(long *arr, int p, int q, int r);

//归并排序
void merge_sort(long *arr, int p, int arr_len)
{
	int q = 0;
	if (p < arr_len)
	{
		//divide  对半分  推给子问题，递归执行
		q = floor((p + arr_len) / 2);
		merge_sort(arr, p, q);
		merge_sort(arr, q + 1, arr_len);
		//merge 合并子问题的结果
		merge(arr, p, q, arr_len);
	}

}

//merge
void merge(long *arr, int p, int q, int r) {
	int i, j, k;
	//左子组的大小
	int n1 = q - p + 1;
	//右子组的大小
	int n2 = r - q;
	//分配空间
	int *L = (int*)malloc(sizeof(int)*(n1 + 1));
	int *R = (int*)malloc(sizeof(int)*(n2 + 1));
	//获取对应在数组内的值
	for(i = 0; i < n1; i++)
		L[i] = arr[p + i];
	for (j = 0; j < n2; j++)
		R[j] = arr[q + j + 1];
	//最后一个数设为最大
	L[n1] = RAND_MAX;
	R[n2] = RAND_MAX;
	i = j = 0;
	for (k = p; k <= r; k++)
	{
		//若L内的部分小于R的部分，则将L的添加到arr里，然后i+1，继续比较L[i+1]和R[j]
		if (L[i] <= R[j])
			arr[k] = L[i++];
		else
			arr[k] = R[j++];
	}
	//释放内存
	free(L);
	free(R);
}


//堆排序   二叉树
/*
小顶堆和大顶堆
小顶堆：越往上越小，根节点最小
大顶堆：越往上越大，根节点最大
*/

void max_heapify(long *arr, int index, int arr_size);
void min_heapify(long *arr, int index, int arr_size);

void stack_sort(long *arr, int arr_len)
{
	int heap_size = ARRAY_SIZE;
	while (heap_size != 0)
	{
		for (int i = (heap_size / 2) - 1; i >= 0; i--)
		{
			max_heapify(arr, i, heap_size);//构造大顶堆
			//min_heapify(arr, i, heap_size);//构造小顶堆
		}
		swap(arr[0], arr[heap_size - 1]);//交换根节点和最后一个节点
		heap_size--;//除掉最后一个节点，其他的节点再构建大顶堆/小顶堆
	}
}
//构造大顶堆
void max_heapify(long *arr, int index, int arr_size)
{
	int temp = 0;
	int l_leave = 2 * index + 1;//左分支
	int r_leave = 2 * index + 2;//右分支
	int largest = 0;

	//判断父节点与子节点的大小
	if (l_leave <= arr_size - 1 && arr[l_leave] > arr[index])
		largest = l_leave;
	else
		largest = index;

	if (r_leave <= arr_size - 1 && arr[r_leave] > arr[largest])
		largest = r_leave;
	//子节点比父节点大，则交换
	if (largest != index) 
	{
		temp = arr[index];
		arr[index] = arr[largest];
		arr[largest] = temp;
		max_heapify(arr, largest, arr_size);
	}
}

//构造小顶堆
void min_heapify(long *arr, int index, int arr_size)
{
	int temp = 0;
	int l_leave = 2 * index + 1;//左分支
	int r_leave = 2 * index + 2;//右分支
	int minest = 0;

	//判断父节点与子节点的大小
	if (l_leave <= arr_size - 1 && arr[l_leave] < arr[index])
		minest = l_leave;
	else
		minest = index;

	if (r_leave <= arr_size - 1 && arr[r_leave] < arr[minest])
		minest = r_leave;
	//子节点比父节点小，则交换
	if (minest != index)
	{
		temp = arr[index];
		arr[index] = arr[minest];
		arr[minest] = temp;
		max_heapify(arr, minest, arr_size);
	}
}

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

int partition(long *arr, int first, int last);
//快速排序    最后一个数作为比较值
void quick_sort(long *arr, int begin, int end)
{
	int mid_ref = 0;
	if (begin < end)
	{
		mid_ref = partition(arr, begin, end);
		if (mid_ref == -1)
			return;
		quick_sort(arr, begin, mid_ref);
		quick_sort(arr, mid_ref + 1, end);
	}
	
}

int partition(long *arr, int first, int last)
{
	int temp = 0;
	int value = 0;
	int i = 0;

	value = arr[last - 1];
	i = first - 1;

	for (int j = first; j < last - 1; j++)
	{
		if (arr[j] <= value)
		{
			i += 1;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	
	temp = arr[i + 1];
	arr[i + 1] = arr[last - 1];
	arr[last - 1] = temp;

	return i + 1;

}

//==============================================================
int partition_rand(long *arr, int first, int last);
//快速排序    产生随机数作为比较值
void quick_sort_rand(long *arr, int begin, int end)
{
	int mid_ref = 0;
	if (begin < end)
	{
		mid_ref = partition_rand(arr, begin, end);
		if (mid_ref == -1)
			return;
		quick_sort_rand(arr, begin, mid_ref);
		quick_sort_rand(arr, mid_ref + 1, end);
	}
	
}

int partition_rand(long *arr, int first, int last)
{
	int temp = 0;
	int value = 0;
	int i = 0;
	int rand_index = 0;

	rand_index = rand() % (last - first) + first;//产生随机数

	value = arr[rand_index];
	i = first - 1;

	for (int j = first; j < last; j++)
	{
		if (arr[j] < value)
		{
			i += 1;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
			if (i == rand_index)
				rand_index = j;
		}
	}
	
	temp = arr[i + 1];
	arr[i + 1] = arr[rand_index];
	arr[rand_index] = temp;

	return i + 1;

}




int main() {

	
	int begin_arr = 0, end_arr = 0;//数组排序的起始位置到终止位置z
	clock_t start, end;//define time computer

	start = clock();

	srand(start);//generate random number seeds

	long *arr;

	arr = (long *)malloc(ARRAY_SIZE * sizeof(long));//malloc memory space based on ARRAY_SIZE

	for (int i = 0; i < ARRAY_SIZE; i++)
	{
		arr[i] = rand();
	}
	

	insert_sort(arr, ARRAY_SIZE);//插入排序
	//merge_sort(arr, begin_arr, ARRAY_SIZE);//归并排序
	//stack_sort(arr, ARRAY_SIZE);//堆排序
	//quick_sort(arr, 0, ARRAY_SIZE);//快速排序
	//quick_sort_rand(arr, 0, ARRAY_SIZE);//随机快速排序



	end = clock();

	cout << "time = " << double(end - start) / CLOCKS_PER_SEC << endl;

	
	////显示
	//for (int i = 0; i < ARRAY_SIZE; i++)
	//{
	//	cout << arr[i] << " ";
	//}
	//
	//cout << endl;

	return 0;
}