22.冒泡，选择，插入，希尔，快速，堆排序

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
#include<math.h>

//冒泡排序
void bubbleSort(int *arr, int len)
{
	int i, j, tmp;
	int flag = 0;  //若第一次循环比较时没有发生交换，说明已经有序，提前结束循环

	for (i = 0; i < len; i++)
	{
		for (j = 0; j < len - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 1;
			}
		}

		if (flag == 0)
		{
			break;
		}
	}
}

//选择排序
void selectSort(int *arr, int len)
{
	int i, j, tmp;
	int minIndex;

	for (i = 0; i < len - 1; i++)
	{
		minIndex = i;
		for (j = i + 1; j < len; j++)
		{
			if (arr[minIndex] > arr[j])
			{
				minIndex = j;
			}
		}

		if (minIndex != i)  //说明i不是最小元素的下标
		{
			tmp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = tmp;
		}
	}
}

//插入排序  
void insertSort(int *arr, int len)
{
	int tmp, i, j;
	for (i = 0; i < len; i++)
	{
		tmp = arr[i];
		for (j = 0; j < i; j++)  //查找元素整体向后移动的其实下标  
		{
			if (arr[j] > tmp)
			{
				break;
			}
		}

		for (int k = i - 1; k >= j; k--)
		{
			arr[k + 1] = arr[k];
		}

		arr[j] = tmp;
	}
}

//优化后的插入排序  
void insertSort2(int *arr, int len)
{
	int tmp, i, j;
	for (i = 0; i < len; i++)
	{
		tmp = arr[i];
		for (j = i - 1; j >= 0; j--)  //以便查找tmp应该存放的位置，以便将元素同一向后移动  
		{
			if (arr[j] <= tmp)
			{
				break;
			}
			else
			{
				arr[j + 1] = arr[j];
			}
		}

		arr[j + 1] = tmp;
	}
}

//希尔排序  
void shell(int *arr, int len, int gap)
{
	int tmp, i, j;
	for (i = gap; i < len; i++)
	{
		tmp = arr[i];
		for (j = i - gap; j >= 0; j -= gap)  //类似于插入排序，以gap为间隔跳跃判断并移动元素  
		{
			if (arr[j] < tmp)
			{
				break;
			}
			else
			{
				arr[j + gap] = arr[j];
			}
		}

		arr[j + gap] = tmp;
	}
}

void shellSort(int *arr, int len)
{
	int d[] = { 5, 3, 1 };   //表示每个希尔排序划分的组数,当gap等于1时与插入排序相同，最后一个增量必须为1  
	for (int i = 0; i < sizeof(d) / sizeof(d[0]); i++)
	{
		shell(arr, len, d[i]);
	}
}

//快速排序  
int Partition(int *arr, int low, int high)  //快速排序的一趟划分  
{
	int tmp = arr[low];  //以arr[low]为基准  

	//从后往前，比基准小的往前移动(arr[low] = arr[high])  
	//从前往后，比基准大的往后移动(arr[high] = arr[low])  
	//一趟之后，基准位于合适位置  
	while (low < high)
	{
		while ((low < high) && (arr[high] >= tmp))
		{
			high--;
		}

		if (low == high)
		{
			break;
		}
		else
		{
			arr[low] = arr[high];
		}

		while ((low <  high) && (arr[low] <= tmp))
		{
			low++;
		}

		if (low == high)
		{
			break;
		}
		else
		{
			arr[high] = arr[low];
		}
	}

	arr[low] = tmp;
	return low;
}

void quick(int *arr, int start, int end)
{
	int par = Partition(arr, start, end);

	if (par > start + 1)
	{
		quick(arr, start, par - 1);
	}

	if (par < end - 1)
	{
		quick(arr, par + 1, end);
	}
}

//递归形式的快速排序
void quickSort(int *arr, int len)
{
	quick(arr, 0, len - 1);
}

//非递归形式的快速排序
void quickSort2(int *arr, int len)
{
	int size = (int)ceil((log((double)len) / log((double)2)));
	int *stack = (int*)malloc(sizeof(int) * 2 * size);
	assert(stack != NULL);
	
	int top = 0;
	int low = 0;
	int high = len - 1;
	int par = Partition(arr, low, high);

	if (par > low + 1)
	{
		stack[top++] = low;
		stack[top++] = par - 1;
	}

	if (par < high - 1)
	{
		stack[top++] = par + 1;
		stack[top++] = high;
	}

	while (top > 0)
	{
		high = stack[--top];
		low = stack[--top];

		par = Partition(arr, low, high);

		if (par > low + 1)
		{
			stack[top++] = low;
			stack[top++] = par - 1;
		}

		if (par < high - 1)
		{
			stack[top++] = par + 1;
			stack[top++] = high;
		}
	}

	free(stack);
}

//堆排序
void adjust(int *arr, int start, int end)  //堆排序的一次调整
{
	int tmp = arr[start];

	for (int i = 2 * start + 1; i <= end; i = 2*start + 1)
	{
		if ((i + 1 <= end) && (arr[i] < arr[i + 1]))
		{
			i++;   //i表示孩子当中较大值的下标
		}

		if (arr[i] > tmp)
		{
			arr[start] = arr[i];
			start = i;
		}
		else
		{
			break;
		}
	}

	arr[start] = tmp;
}

void heapSort(int *arr, int len)
{
	int i, tmp;

	for (i = (len - 1 - 1) / 2; i >= 0; i--)  //通过多次调整建立大根堆
	{
		adjust(arr, i, len - 1);
	}

	for (i = 0; i < len - 1; i++)
	{
		//堆首与当前堆尾互换
		tmp = arr[0];
		arr[0] = arr[len - 1 - i];
		arr[len - 1 - i] = tmp;

		adjust(arr, 0, len - 1 - i - 1);  //最后一个减一表示当前堆最后一个已经排好序，使堆的尺寸减一
	}
}

void print(int *arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main()
{
	int arr[] = { 2, 5, 9, 3, 1, 6, 8, 7, 4, 0, 11, -5, 18, -2 };

	//bubbleSort(arr, sizeof(arr)/sizeof(arr[0]));  
	//selectSort(arr, sizeof(arr) / sizeof(arr[0]));
	//insertSort(arr, sizeof(arr)/sizeof(arr[0]));  
	//insertSort2(arr, sizeof(arr)/sizeof(arr[0]));  
	//shellSort(arr, sizeof(arr)/sizeof(arr[0]));  
	//quickSort(arr, sizeof(arr) / sizeof(arr[0]));
	//quickSort2(arr, sizeof(arr) / sizeof(arr[0]));
	heapSort(arr, sizeof(arr) / sizeof(arr[0]));

	print(arr, sizeof(arr) / sizeof(arr[0]));

	return 0;
}