常见排序的实现

一.直接插入排序

       这是相当简单的排序方式,在具体实现的时候会有不同,具体有以下的两个实现:

//实现1
void Insert_sort(int *arr, int length)
{
	int i;
	int j;
	int tmp;
	int k;
	for (i = 1; i < length; i++)
	{
		tmp = arr[i];
		//方法不好,即使数组有序也需要n^2次比较,时间复杂度为O(n^2)
		for (j = 0; j < i; j++)
		{   
                        //找位置
			if (tmp < arr[j])
			{
				break;
			}
		}
		
		for (k = i - 1; k >= j; k--)
		{
			arr[k + 1] = arr[k];
		}
		
		arr[j] = tmp;
	}
}

//实现2,推荐使用
//最差为O(n^2),最好为O(1)   算法稳定   完全有序为O(n)
void Insert_sort(int *arr, int length)
{
	int i;
	int j;
	int tmp;
	for (i = 1; i < length; i++)
	{
		tmp = arr[i];
		//在遍历的时候就完成了数据移动
		for (j = i - 1; j >= 0; j--)
		{
			if (arr[j] <= tmp)
			{
				break;
			}
			arr[j + 1] = arr[j];
		}
		arr[j+1] = tmp;
	}
}

二.希尔排序

      

//gap增量,即组数也是间隔值
void Shell(int *arr, int length, int gap)
{
	int i;
	int j;
	int tmp;
	//组内排序,最后是一个一个排序
	for (i = gap; i < length; i++)
	{
		tmp = arr[i];//组中的一个元素
		//排序tmp这个组中前于tmp的值
		for (j = i - gap; j >= 0; j -= gap)
		{
			if (arr[j] <= tmp)
			{
				break;
			}
			arr[j + gap] = arr[j];
		}
		arr[j + gap] = tmp;
	}
}

void ShellSort(int *arr,int length)//O(n^1.3)~O(n^1.5), 最好能达到O(1),不稳定
{
	int brr[] = { 5, 3, 1 };//缩小增量,最后一个数值为1
	for (int i = 0; i < sizeof(brr) / sizeof(brr[0]); i++)
	{
		Shell(arr, length, brr[i]); //对arr进行排序,brr是个辅助数组
	}
}

三.冒泡排序

       关于冒泡排序的优化,网上有很多,可以自行百度学习

void BubbleSort(int *arr, int length)//稳定
{
	int i;
	int j;
	int tmp;
	for (i = 0; i < length-1; i++)
	{
		//找到最大值的沉在数组最后,之后就不用再管最大的数了
		for (j = 0; j + 1 < length - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

四.快速排序

int Partition(int *arr, int start, int end)
{
	int low = start;
	int high = end;
	int tmp = arr[low];
	while (low < high)
	{
                //结束说明此时这个数小于了tmp或循环条件不满足
		while ((low < high) && arr[high] >= tmp)
			high--;
		arr[low] = arr[high];

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

//递归实现
static void Quick(int *arr, int start, int end)
{
	int par = Partition(arr, start, end);//先进行快排一次调整
	if (start < par - 1) //左侧
	{
		Quick(arr, start, par - 1);
	}
	if (par+1 < end) //右侧
	{
		Quick(arr, par+1, end);
	}
}

void QuickSort(int *arr, int length)//最差O(nlogn),最好O(logn),不稳定
{
	Quick(arr, 0, length-1);
}

五.堆排序

       堆排序需要说明一下,具体如下图:

代码实现如下:

//树中左右节点的和父节点的关系:左孩子是父节点的2K+1  右节点是父节点的2K+2, k为父节点下标
void HeapAdjust(int *arr, int start, int end)
{
	int parent = start; //表示父节点
	int tmp = arr[parent];//tmp记录父节点
	for (int i = 2 * start + 1; i <= end; i = 2 * i + 1)
	{
		//i表示父节点的子节点,下一次是以子节点做父节点,用到节点规律
		if (i + 1 <= end && arr[i] < arr[i + 1])//左右孩子最大值的下标
			i++;
		if (arr[i] > tmp)
		{
			arr[parent] = arr[i];
			parent = i;
		}
		else
		{
			break;
		}
	}
	//上述循环找到tmp的位置,放入
	arr[parent] = tmp;
}

void HeapSort(int *arr, int length)//不稳定
{
	int i;
	int j;
	int tmp;
	for (i = length - 1 - 1 / 2; i >= 0; i--)
	{
		HeapAdjust(arr, i, length - 1);
	}

	for (i = 0; i < length - 1; i++)
	{
//将最大的数值放在数组的后面,放置后,此数字为最大,则不再参与后续堆调整,数组的实际操作个数减一
		tmp = arr[0];//保存最大值,大根堆0号下标的值最大
		arr[0] = arr[length - i - 1];
		arr[length - i - 1] = tmp;//此时交换完成

		HeapAdjust(arr, 0, (length - i - 1) - 1);
	}
}

六.归并排序:

 

//gap为归并段的长度
void Merge(int *arr, int length, int gap)
{
	/*下列4个只是作为下标的一个整型数据,不用考虑越界,因为下面的代码都是要满足循环体条件才能够进入的,越界的数据肯定是不能满足循环体的,也就不能操作数组*/
	/*一般对能进行表示数组的整型数据是要考虑越界的,但是这个代码将整型数据放在了循环体的判断条件里,可以杜绝其作为越界下标的可能*/
	int low1 = 0; //第一个归并段的起始下标
	int high1 = low1 + gap -1 ; //第一个归并段的结束下表
	int low2 = high1 + 1;
	//如果有第二个归并段,第二个段的长度不一定为gap可能小于gap,为了杜绝越界需要特殊处理,因为这个数据可能被当作下标来读取数组
	int high2 = low2 + gap < length ? low2 + gap - 1 : length - 1; 

	int *brr = (int *)malloc(length*sizeof(int));
	int i = 0;//用来当brr数组的下标

	//合并中肯定有两个归并段的处理方式,low2小于length表示有两个归并段
	while (low2 < length)
	{
		//两个归并段都有数据
		while (low1 <= high1 && low2 <= high2)
		{
			if (arr[low1] <= arr[low2])
				brr[i++] = arr[low1++];
			else
				brr[i++] = arr[low2++];
		}

		// 第一个归并段还有数据
		while (low1 <= high1)
		{
			brr[i++] = arr[low1++];
		}

		while (low2 <= high2)
		{
			brr[i++] = arr[low2++];
		}

		low1 = high2 + 1;
		high1 = low1 + gap - 1;
		low2 = high1 + 1;
		high2 = low2 + gap < length ? low2 + gap - 1 : length - 1;
	}


//只剩一个归并段处理(可能是两两结合剩余了一个或者是归并段的长度正好为本数组长度,但后者可能性小)
	while (low1 < length)
	{
		brr[i++] = arr[low1++];
	}

	//将结果重新拷贝回原数组
	for (i = 0; i < length; i++)
	{
		arr[i] = brr[i];
	}

	free(brr);
}

void MergeSort(int *arr, int length)//O(nlogn),O(n),稳定
{
	//i表示归并段的长度,先是把每个元素看作是一个段,即段长度为1,和相邻段进行合并
	for (int i = 1; i < length; i*=2)// 1  2  4  8  16
	{
		Merge(arr, length, i);
	}
}

七.选择排序

//选择排序，不稳定   O(1)~O(n^2)
void SelectSort(int *arr,int len)
{
    int minIndex;
    int i;
    int j;
    int tmp;
    for(i=0;i<len-1;i++)
    {
		minIndex = i;
		for(j=i+1;j<len;j++)
		{
			if(arr[minIndex] > arr[j])
			{
				minIndex = j;
			}
		}
		if(i != minIndex)
		{
			tmp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = tmp;
		}
    }
}