C实现各类排序算法代码

#include <iostream>

using namespace std;

//直接插入排序
void insert_sort(int a[], int n)
{
	int i, j, temp;

	for (i = 1; i < n; i++)
	{
		//暂存下标为i的数,下标从1开始,因为开始时
		//下标为0的数,前面没有任何数,此时认为它是排好序的
		temp = a[i];
		for (j = i - 1; j >= 0 && temp < a[j]; j--)
		{
			//如果满足条件就往后挪。最坏的情况就是temp比a[0]小,它就要放在最前面
			a[j + 1] = a[j];
		}
		a[j + 1] = temp;
	}
}

//希尔排序
void shell_sort(int a[], int len)
{
	int h, i, j, temp;
	for (h = len / 2; h > 0; h = h / 2) //控制增量
	{
		for (i = h; i < len; i++)
		{
			temp = a[i];
			for (j = i - h; j >= 0 && temp < a[j]; j -= h)
			{
				a[j + h] = a[j];
			}
			a[j + h] = temp;
		}
	}
}

//冒泡排序
void bubble_sort_1(int a[], int len)
{
	int i = 0;
	int j = 0;
	int temp = 0;
	for (i = 0; i < len - 1; i++)
	{
		for (j = len - 1; j >= i; j--)
		{
			if (a[j + 1] < a[j])
			{
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
}

void bubble_sort_2(int a[], int len)
{
	int i = 0;
	int j = 0;
	int temp = 0;
	int exchange = 0;

	for (i = 0; i < len - 1; i++)
	{
		exchange = 0;
		for (j = len - 1; j >= i; j--)
		{
			if (a[j + 1] < a[j])
			{
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
				exchange = 1;
			}
		}
		if (exchange != 1)   //说明前面已经排序好了
			return;
	}
}

//快速排序
void quick_sort(int a[], int low, int high)
{
	int i, j, base;
	if (low < high)
	{
		i = low;
		j = high;
		base = arr[low];
		while (i < j)
		{
			while (a[j] > base && i<j) j--;
			while (a[i] < base && i>j) i++;

			int temp = a[j];
			a[j] = a[i];
			a[i] = temp;
		}
		arr[low] = arr[i];
		arr[i] = base;
		
		quick_sort(a, low, i - 1);
		quick_sort(a, i + 1, high);
	}
}

//选择排序
void select_sort(int a[], int len)
{
	int i, j, x, l;
	for (i = 0; i < len; i++)
	{
		x = a[i];
		l = i;
		for (j = 1; j < len; j++)
		{
			if (a[j] < x)
			{
				x = a[j];
				l = j;
			}
		}
		a[l] = a[i];
		a[i] = x;
	}
}

//
//堆排序

int heapSize = 0;

//返回左子节点索引
int Left(int index)
{
	return ((index << 1) + 1);
}

//返回右子节点索引
int Right(int index)
{
	return ((index << 1) + 2);
}

//交换a,b的值
void swap(int *a, int *b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

//array[index]与其左、右子树进行递归对比
//用最大值替换array[index],index表示堆顶索引
void maxHeapify(int array[], int index)
{
	int largest = 0;			//最大数
	int left = Left(index);		//左子节点索引
	int right = Right(index);	//右子节点索引

	//把largest赋为堆顶与左子节点的较大者
	if ((left <= heapSize) && (array[left] > array[index]))
	{
		largest = left;
	}
	else
		largest = index;

	//把largest与堆顶的右子节点比较,取较大者
	if ((right <= heapSize) && (array[right] > array[largest]))
	{
		largest = right;
	}

	//此时largest为堆顶、左子节点、右子节点的最大者
	if (largest != index)
	{
		//如果堆顶不是最大者,则交换,并递归调整堆
		swap(&array[index], &array[largest]);
		maxHeapify(array, largest);
	}
}

//初始化堆,将数组中的每一个元素置放到适当的位置
//完成之后,堆顶的元素为数组的最大值
void buildMaxHeap(int array[], int length)
{
	int i;
	heapSize = length;   //堆大小赋为数组长度
	for (i = (length >> 1); i >= 0; i--)
	{
		maxHeapify(array, i);
	}
}

void heap_sort(int array[], int length)
{
	int i;
	//初始化堆
	buildMaxHeap(array, length - 1);
	for (i = (length - 1); i >= 1; i--)
	{
		//堆顶元素array[0](数组的最大值)被置换到数组的尾部array[i]
		swap(&array[0], &array[i]);
		heapSize--;				//从堆中移除该元素
		maxHeapify(array, 0); //重建堆
	}
}
/


/
//归并排序

//将分治的两端按大小次序填入临时数组,最后把临时数组拷贝到原始数组中
//lpos到rpos - 1 为一端,rPos到rEnd为另一端
void Merge(int a[], int tmp[], int lPos, int rPos, int rEnd)
{
	int i, lEnd, NumElements, tmpPos;
	lEnd = rPos - 1;
	tmpPos = lPos;						//从左端开始
	NumElements = rEnd - lPos + 1;		//数组长度

	while (lPos <= lEnd&&rPos <= rEnd)
	{
		if (a[lPos] < a[rPos])			//比较两端的元素值
			tmp[tmpPos++] = a[lPos++];	//把较小的值先放入tmp临时数组
		else
			tmp[tmpPos++] = a[rPos++];
	}

	//到这里,左端或右端只能有一端还可能含有剩余元素
	while (lPos <= lEnd)				//把左端剩余的元素放入tmp
		tmp[tmpPos++] = a[lPos++];

	while (rPos <= rEnd)
		tmp[tmpPos++] = a[rPos++];		//把右端剩余的元素放入tmp

	for (i = 0; i < NumElements; i++, rEnd--)
		a[rEnd] = tmp[rEnd];			//把临时数组拷贝到原始数组
}

void msort(int a[], int tmp[], int low, int high)
{
	if (low >= high)
		return;

	int middle = (low + high) / 2;		//计算分裂点
	msort(a, tmp, low, middle);			//对子区间递归做归并排序
	msort(a, tmp, middle + 1, high);	//对子区间递归做归并排序
	Merge(a, tmp, middle + 1, middle + 1, high);	//组合，把两个有序区合并为一个有序区
}

void merge_sort(int a[], int len)
{
	int *tmp = NULL;
	tmp = new int[len];
	if (tmp != NULL)
	{
		msort(a, tmp, 0, len - 1);
		delete[]tmp;
	}
}
/


//基数排序(桶排序)

int find_max(int a[], int len)  //查找长度为len的数组的最大元素
{
	int max = a[0];				//max从a[0]开始
	for (int i = 1; i < len; i++)
	{
		if (max < a[i])			//如果发现元素比max大
			max = a[i];			//就重新给max赋值
	}
	return max;
}

//计算number有多少位
int digit_number(int number)
{
	int digit = 0;
	do 
	{
		number /= 10;
		digit++;
	} while (number != 0);
	return digit;
}

//返回number上第Kth位的数字
int Kth_digit(int number, int Kth)
{
	number /= pow(10, Kth);
	return number % 10;
}

//对长度为len的数组进行基数排序
void radix_sort(int a[], int len)
{
	int *temp[10];        //指针数组,每一个指针表示一个箱子
	int count[10] = { 0,0,0,0,0,0,0,0,0,0 };//用于存储每个箱子装有多少元素
	int max = find_max(a, len);		//取得系列中的最大整数
	int maxDigit = digit_number(max);	//得到最大整数的位数
	int i, j, k;
	for (i = 0; i < 10; i++)
	{
		temp[i] = new int[len];  //使每一个箱子能装下len个int元素
		memset(temp[i], 0, sizeof(int) * len);//初始化为0
	}

	for (i = 0; i < maxDigit; i++)
	{
		memset(count, 0, sizeof(int) * 10);//每次装箱前把count清空
		for (j = 0; j < len; j++)
		{
			int xx = Kth_digit(a[j], i);	//将数据安装位数放入到暂存数组中
			temp[xx][count[xx]] = a[j];
			count[xx]++;	//此箱子的计数递增
		}
		int index = 0;
		for (j = 0; j < 10; j++)		//将数据从暂存数组中取出,放入原始数组中
		{
			for (k = 0; k < count[j]; k++)	//把箱子里所有的元素都取回到原始数组
			{
				a[index++] = temp[j][k];
			}
		}
	}

	for (i = 0; i < 10; i++)
	{
		delete[]temp[i];
		temp[i] = NULL;
	}
}




void print_array(int a[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}

int main()
{
	int a[] = { 5,23,1,3,67,34,89 };
	radix_sort(a, 7);
	print_array(a, 7);


	system("pause");
	return 0;
}