数据结构之排序算法

插入排序：

void Insertion_sort(int array[], int len)
{
	int i, j, temp;
	for (i = 1; i < len; i++)
	{
		temp = array[i];
		j = i - 1;
		while ((j>=0) && (array[j] > temp))
		{
			array[j + 1] = array[j];
			j--;
		}
		array[j + 1] = temp;
	}
}

希尔排序：

void Shell_sort(int array[], int len)
{
	for (int div = len / 2; div >= 1; div = div / 2)
	{
		for (int i = 0; i < div; i++)    //分成div组
		{
			for (int j = i; j < len - div; j += div)    //每组进行插入排序
			{
				for (int k = j; k < len; k += div)
				{
					if (array[j]>array[k])
					{
						int temp = array[j];
						array[j] = array[k];
						array[k] = temp;
					}
				}
			}
		}
	}
}

选择排序：

void Select_sort(int array[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		int min = i;    //找最小值
		for (int j = i + 1; j < len; j++)
		{
			if (array[j]<array[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			int temp = array[min];
			array[min] = array[i];
			array[i] = temp;
		}
	}
}

堆排序：

void adjustHeap(int array[], int len, int par)
{
	int temp = array[par];
	for (int k = par * 2 + 1; k < len; k = k * 2 + 1)
	{
		//如果右边值大于左边值，指向右边
		if (k + 1 < len && array[k]< array[k + 1])
		{
			k++;
		}
		//如果子节点大于父节点，将子节点值赋给父节点,并以新的子节点作为父节点（不用进行交换）
		if (array[k]>temp)
		{
			array[par] = array[k];
			par = k;
		}
		else
			break;
	}
	array[par] = temp;
}

void Heap_sort(int array[], int len)
{
	for (int i = len / 2 - 1; i >= 0; i--)
	{
		adjustHeap(array, len, i);
	}
	for (int j = len - 1; j > 0; j--)
	{
		int temp = array[0];
		array[0] = array[j];
		array[j] = temp;

		adjustHeap(array, j, 0);
	}
}

冒泡排序：

 

void bubble_sort(int array[], int len)
{
	//len = sizeof(array) / sizeof(array[1]);
	int change = 1;
	for (int i = 0; i < len - 1; i++)
	{
		change = 0;
		for (int j = 0; j < len - i - 1; j++)
		{
			if (array[j] > array[j + 1])    //前一个数大于后一个数，则交换两个数
			{
				int temp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = temp;

				change = 1;
			}
		}
		if (change == 0)    //没有发生交换，直接跳出循环
			break;
	}
}

快速排序：

void Quick_sort(int array[], int low, int hight)
{
	if (low > hight)
	{
		return;
	}
	int first = low;
	int last = hight;
	int key = array[first];

	while (first < last)    //在组内寻找
	{
		while (first < last && key <= array[last])    //向前寻找
		{
			last--;
		}
		array[first] = array[last];
		while (first < last && key >= array[first])    //向后寻找
		{
			first++;
		}
		array[last] = array[first];
	}
	array[first] = key;    //将key放到位
	Quick_sort(array, low, first - 1);
	Quick_sort(array, first + 1, hight);
}

归并排序：

void Merge(int array1[],int array2[], int startIndex, int midIndex, int endIndex)
{
    int i = startIndex, j=midIndex+1, k = startIndex;
    while(i!=midIndex+1 && j!=endIndex+1)
    {
        if(array1[i] > array1[j])
            array2[k++] = array1[j++];
        else
            array2[k++] = array1[i++];
    }
    while(i != midIndex+1)
        array2[k++] = array1[i++];
    while(j != endIndex+1)
        array2[k++] = array1[j++];
    for(i=startIndex; i<=endIndex; i++)
        array1[i] = array2[i];
}
 
//内部使用递归
void Merge_Sort(int array1[], int array2[], int startIndex, int endIndex)
{
    int midIndex;
    if(startIndex < endIndex)
    {
        midIndex = startIndex + (endIndex-startIndex) / 2;
        MergeSort(array1, array2, startIndex, midIndex);
        MergeSort(array1, array2, midIndex+1, endIndex);
        Merge(array1, array2, startIndex, midIndex, endIndex);
    }
}

各排序算法比较