内部各种排序算法实现代码

                                                                                    内部排序算法

1、算法可以锻炼智力。

2、算法的实现和理解并非最重要，算法的思想最重要。

3、要深入研究算法，还需要能分析算法的时间和空间复杂度。简而言之，看懂《算法导论》对算法的定量分析。

4、但为了面试，我退而求其次，关注算法的实现和思想。以后的东西慢慢研究，慢慢升华。

  

#include <stdio.h>
#if 0
堆排序:本例以最小堆为例, 空间复杂度是O(1)，平均和最差时间复杂度都是O(nlgn)，相比快速排序最差时间复杂度O(n2)，这里突出的优点. 
因为初始构建堆所需比较移动次数多，所以不适合小的个数的排序，对海量数据处理效率比较高. 因为比较有跳跃，所以是不稳定的.
#endif
/* a[s...m],除a[s]外，a[s+1 ...m]满足堆的定义，所以需要把a[s] 放到合适位置，以达到a[s...m]满足堆的定义 */
void heap_adjust(int a[], int s, int m)
{
	int temp;
	int i;

	temp = a[s];
    /* 可以把s看成i的prevp */
	for (i = 2 * s + 1; i <= m; i = 2 * i + 1) 
	{
		if (i < m && a[i+1] < a[i])
		//if (a[i+1] < a[i]) /* 这里如果没有i < m的话，会导致剩下最后2个数时，因为没有a[i+1]，会导致这里错误执行i = i ＋ 1 */
		{
			i = i + 1;
		}

		if (temp <= a[i])
		{
			break;
		}

		a[s] = a[i];

		s = i;
	}

	a[s] = temp;
}

/* 本例以最小堆为例 */
void create_heap(int a[], int len)
{
	int i;

	for (i = (len - 1 - 1) / 2; i >= 0; --i)
	{
		heap_adjust(a, i, len - 1); 
	}
}

void heap_sort(int a[], int len)
{
	int i;
	int temp;

	for (i = len - 1; i >= 1; --i)
	{
		temp = a[i];
		a[i] = a[0];
		a[0] = temp;

		heap_adjust(a, 0, i-1);
	}
}

void print_array(int a[], int len)
{
	int i;

	for (i = 0; i < len; i++)
	{
		printf("%d ", a[i]);
	}

	printf("\n");
}


int main(void)
{
	int a[8] = {49, 38, 65, 97, 76, 13, 27, 49};

	printf("before create heap:\n");
	print_array(a, 8);

 	create_heap(a, 8);

	printf("before heap sort:\n");
	print_array(a, 8);

	heap_sort(a, 8);

	printf("after heap sort:\n");
	print_array(a, 8);

	return 0;
}

#include <stdio.h>
#include <malloc.h>

#if 0
归并排序
最好、最差和平均时间复杂度都是O(nlgn), 空间复杂度是O(n + lgn) = O(n)
两两比较时存在(a[i] < a[j]),所以是稳定排序
#endif

void merge(int a[], int left, int mid ,int right)
{
	int i;
	int j;
	int k;
	
	int *temp = (int*)malloc(sizeof(int) * (right - left + 1));
	if (!temp)
	{
		printf("malloc failed\n");
		return;
	}

	i = left;
	j = mid + 1; 
	k = 0;

	while (i <= mid && j <= right)
	{
		if (a[i] > a[j])
		{
			temp[k++] = a[j++];
		}
		else
		{
			temp[k++] = a[i++];
		}
	}

	while (i <= mid)
	{
		temp[k++] = a[i++];
	}

	while (j <= right)
	{
		temp[k++] = a[j++];
	}

	k = 0; /* 将k置0 */
	for (i = left; i <= right; i++)
	{
		a[i] = temp[k++];
	}
}

/* 将排序好的数组放在原排序数组中 */
void merge_sort(int a[], int left, int right)
{
	if (left < right)
	{
		int mid = (left + right) >> 1;

		merge_sort(a, left, mid);
		merge_sort(a, mid+1, right);
		merge(a, left, mid, right);
	}
}

void print_array(int a[], int len)
{
	int i;

	for (i = 0; i < len; i++)
	{
		printf("%d ", a[i]);
	}

	printf("\n");
}

int main(void)
{
	//int a[] = {3, 7, 5, 1, 4, 7, 2, 9, 3};
	int a[] = {49, 38, 65, 97, 76, 13, 27, 49, 55};

	merge_sort(a, 0, 8);
	print_array(a, 9);
}

#include <stdio.h>
/*********************************************************************
*  快速排序是不稳定的排序，因为有跳跃                                *
*  思想是分治法,不过不需要分治法的合并操作                           *
*  时间复杂度是O(nlgn), 最差的时间复杂度是O(n的平方)                 *
*  空间复杂度是递归造成的，最好情况,递归树的深度为lgn，因此空间复杂度*                                                                    *
*  为O(lgn),最坏情况，需要进行n-1次调用，其空间复杂度是O(lgn)        *
*                                                                    *
**********************************************************************/
int get_index(int a[], int low ,int high)
{
	int temp = a[low];

	while (low < high)
	{
		while (low < high && a[high] >= temp) 
		{
			--high;
		}

		a[low] = a[high];

		while (low < high && a[low] <= temp)
		{
			++low;
		}

		a[high] = a[low];
	}

	a[low ] = temp;

	return low;

}

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

void print_array(int a[], int len)
{
	int i;

	for (i = 0; i < len; i++)
	{
		printf("%d ", a[i]);
	}

	printf("\n");
}

int main(void)
{
	//int a[] = {3, 7, 5, 1, 4, 7, 2, 9, 3};
	int a[] = {49, 38, 65, 97, 76, 13, 27, 49, 55};

	quick_sort(a, 0, 8);

	print_array(a, 9);
}

#include <stdio.h>
#if 0
希尔排序移动是跳跃式的，所以是不稳定的排序算法
时间复杂度是O(n3/2)
空间复杂度是O(1)
#endif
void shell_sort_core(int *a, int len, int inc)
{
	int temp;
	int i;
	int j;

	for (i = inc; i < len; i++)
	{
		if (a[i] >= a[i-inc])
		{
			continue;
		}

		for (j = i - inc; j >= 0; j -= inc)
		{
			if (a[j+inc] < a[j])
			{
				temp = a[j+inc]; 
				a[j+inc] = a[j];
				a[j] = temp;
			}
		}
	}
}

void shell_sort(int a[], int len)
{
	int inc[3] = {5, 3, 1};
	int i;

	for (i = 0; i < 3; i++) 
	{
		shell_sort_core(a, len, inc[i]);
	}
}

void print_array(int a[], int len)
{
	int i;

	for (i = 0; i < len; i++)
	{
		printf("%d ", a[i]);
	}

	printf("\n");
}

int main(void)
{
	//int a[] = {3, 7, 5, 1, 4, 7, 2, 9, 3};
	int a[] = {49, 38, 65, 97, 76, 13, 27, 49, 55};

	shell_sort(a, 9);
	print_array(a, 9);
}