常见排序算法的思想及实现

冒泡排序

每一趟排序（包括多次两两比较和交换）找出余下的最大元素放在数组的最后，叫沉底排序更贴切。

void bubble_sort(int a[], int len)
{
	int i, j;
	for(i = 0; i < len - 1; i++)//len - 1趟排序
	{
		for (j = 0; j < len - i - 1; j++)//从第一趟排序，推出j的范围
		{
			if(a[j] > a[j + 1])//前面的元素更大需要往下沉
			{
				swap(&a[j], &a[j + 1]);
			}
		}
	}
}

选择排序

每一趟排序找出余下元素中最小的元素放在数组的最前面

void select_sort(int a[], int len)
{
	int i, j;
	for(i = 0; i < len - 1; i++)//len - 1趟排序
	{
		for(j = i + 1; j < len; j++)//一趟中需要和a[i]比较的元素
		{
			if(a[i] > a[j])
			{
				swap(&a[i], &a[j]);
			}
		}
	}
}

void select_sort_plus(int a[], int len)
{
	int i, j, min;
	for(i = 0; i < len - 1; i++)//len - 1趟排序
	{
		min = i;
		for(j = i + 1; j < len; j++)//选择排序改进：标记最小值，一趟最多交换一次
		{
			if(a[min] > a[j])
			{
				min = j;
			}
		}
		if(min != i)
		{
			swap(&a[i], &a[min]);
		}
	}
}

插入排序

每一趟排序把本次排序的元素往前插入到合适的位置

void insert_sort(int a[], int len)
{
	int i, j;
	for(i = 1; i < len; i++)
	{
		for(j = i; j > 0 && a[j] < a[j - 1]; j--)
		{
			swap(&a[j], &a[j - 1]);
		}
	}
}

希尔排序

插入排序的改进；插入排序比较移动的步长是1，希尔排序中改进该步长，从大缩小到1

void shell_sort(int a[], int len)
{
	int i, j, k = 1;
	while(k < len / 3)
	{
		k = 3 * k + 1;
	}
	while(k >= 1)
	{
		for(i = k; i < len; i++)
		{
			for(j = i; j >= k && a[j] < a[j - k]; j -= k)
			{
				swap(&a[j], &a[j - k]);
			}
		}
		k /= 3;
	}
}

快速排序

每趟排序把基准值放到对的位置即左边的元素都比它小，右边的元素都比它大

void quick_sort(int a[], int low, int high)
{
	int pivot;
	if(low < high)
	{
		pivot = quickSort(a, low, high);
		quick_sort(a, low, pivot - 1);
		quick_sort(a, pivot + 1, high);
	}
}

int quickSort(int a[], int low, int high)
{
	int pivot = a[low];
	while(low < high)
	{
		while(low < high && pivot <= a[high])
			high--;
		swap(&a[low], &a[high]);
		while(low < high && pivot >= a[low])
			low++;
		swap(&a[low], &a[high]);
	}
	return low;
}

堆排序

利用大顶堆的特点：根的值比左右子树都大

先构造堆

交换堆的第一个元素和最后一个元素，使最大的元素放在数组的最后，再对前面的堆进行调整，重复该操作

void heap_sort(int a[], int len)
{
	int i;
	for(i = len / 2 - 1; i >= 0; i--)
	{
		heap_adjust(a, i, len);
	}
	for(i = len - 1; i >= 1; i--)
	{
		swap(&a[0], &a[i]);
		heap_adjust(a, 0, i);
	}
}

void heap_adjust(int a[], int i, int len)
{
	int j;
	int temp = a[i];
	for(j = 2 * i + 1; j < len; j = 2 * j + 1)
	{
		if(j < len -1 && a[j] < a[j + 1])
			j++;
		if(temp >= a[j])
			break;
		a[i] = a[j];
		i = j;
	}
	a[i] = temp;
}

归并排序

递归地合并两个有序数组

void merge_sort(int a[], int len)
{
	int *temp = (int *) malloc(len * sizeof(int));
	mergeSort(a, 0, len - 1, temp);
	free(temp);
}

void mergeSort(int a[], int low, int high, int temp[])
{
	int mid = (low + high) / 2;
	if(low < high)
	{
		mergeSort(a, low, mid, temp);
		mergeSort(a, mid + 1, high, temp);
		mergeArray(a, low, mid, high, temp);
	}
}

void mergeArray(int a[],int low, int mid, int high, int temp[])
{
	int i = low, j = mid + 1, k = 0;
	while(i <= mid && j <= high)
	{
		if(a[i] < a[j])
		{
			temp[k++] = a[i++];
		}
		else
		{
			temp[k++] = a[j++];
		}
	}
	while(i <= mid)
	{
		temp[k++] = a[i++];
	}
	while(j <= high)
	{
		temp[k++] = a[j++];
	}
	for(i = 0; i < k; i++ )
	{
		a[low + i] = temp[i];
	}
}