各种常见的排序，冒泡排序，选择排序，插入排序，希尔排序，堆排序，快速排序，基数排序，桶排序

标签：各种常见排序   希尔   堆   快速   归并   

各种常见的排序

要开始找工作了，把以前学的各种小知识复习一遍，以下是各种常见的排序的简单实现（冒泡排序，选择排序，插入排序，希尔排序，堆排序，快速排序，基数排序，桶排序），至于原理就不写出来了，代码比较简单，看一下就懂，再不行可以随意找本书或百度！

#include <iostream>
using namespace std;

//	冒泡
void BubbleSort(int data[], int length)
{
	if(data == NULL || length <= 0)
		return ;
	for (int i = length - 1; i > 0; --i)
	{
		int exchange = 1;
		for (int j = i - 1; j >= 0; --j)
		{
			int tmp;
			if (data[i] < data[j])
			{
				tmp = data[i];
				data[i] = data[j];
				data[j] = tmp;
			}
			exchange = 0;
		}
		if(exchange)
			return;
	}
}

//	冒泡排序
void BubbleSort_2(int data[], int length)
{
	for (int i = 0; i < length - 1; ++i)
	{
		int exchange = 0;
		for (int j = length - 1; j > i; --j)
		{
			int tmp;
			if (data[j - 1] > data[j])
			{
				tmp = data[j];
				data[j] = data[j - 1];
				data[j - 1] = tmp;
			}
			exchange = 1;
		}
		if(!exchange)
			return;
	}
}

//	直接插入排序
void InsertSort(int data[], int length)
{
	if(data == NULL || length <= 0)
		return;
	for (int i = 1; i < length; ++i)
	{
		int tmp = data[i];
		int j = i - 1;
		while (j >= 0 && data[j] > tmp)
		{
			data[j + 1] = data[j];
			--j;
		}
		data[j + 1] = tmp;
	}
}

// 直接选择排序
void SelectSort(int data[], int length)
{
	for(int i = 0; i < length - 1; ++i)
	{
		int k = i;
		for(int j = i + 1; j < length; ++j)
		{
			if (data[j] < data[k])
				k = j;
		}
		if (k != i)
		{
			int tmp = data[i];
			data[i] = data[k];
			data[k] = tmp;
		}
	}
}

//	快速排序
void QuickSort(int data[], int start, int last)
{
	if(data == NULL || start > last)
		return;
	int i = start, j = last;
	if(start < last)
	{
		int tmp = data[start];
		while(i != j)
		{
			while (j > i && data[j] > tmp)
				--j;
			data[i] = data[j];
			while(i < j && data[i] < tmp )
				++i;
			data[j] = data[i];
		}
		data[i] = tmp;
		QuickSort(data, start, i - 1);
		QuickSort(data, i + 1, last);
	}
}

//	希尔排序
void ShellSort(int data[], int length)
{
	int gap = length / 2;
	while (gap > 0)
	{
		for(int i = gap; i < length ; ++i)
		{
			int tmp = data[i];
			int j = i - gap;
			while (j >= 0 && tmp < data[j])
			{
				data[j + gap] = data[j];
				j = j - gap;
			}
			data[j + gap] = tmp;
			//j = j - gap;
		}
		gap = gap / 2;
	}
}

void sift(int data[], int low, int high)
{
	// 若第一个元素的下标为0，则两个子节点的下标为：2 * 0 = 0， 2 * 0 + 1 = 1
	//	不对（与父节点重合），这也就还前面说的第一个元素的下标要从1开始的原因。
	int i = low, j = 2 * i;
	int tmp = data[i];
	while (j <= high)
	{
		if(j < high && data[j] < data[j + 1])
			++j;
		if(data[j] > tmp)
		{
			data[i] = data[j];
			i = j;
			j *= 2;
		}
		else
			break;
	}
	data[i] = tmp;
}

//	堆排序
void HeapSort(int data[], int length)
{
	for(int i = length / 2; i > 0; --i)
		sift(data, i, length);
	for (int j = length ; j > 1; --j)
	{
		int tmp = data[1];
		data[1] = data[j];
		data[j] = tmp;
		sift(data, 1, j - 1);
	}
}

//	归并排序

void Merge(int data[], int low, int mid, int high)
{
	//	一次归并
	// 将相邻两个有序表 [low, mid],[mid + 1, high] 合并到一个表中
	if (data == NULL || low < 0 || low > mid || mid > high)
		return;
	int i = low, j = mid + 1;
	//int *data_tmp = (int *)malloc(sizeof(int) * (high - low + 1));
	int *data_tmp = new int[high - low + 1];
	int k = 0;
	while(i <= mid && j <= high)
	{
		if (data[i] <= data[j])
		{
			data_tmp[k] = data[i];
			++i;
			++k;
		}
		else 
		{
			data_tmp[k] = data[j];
			++k;
			++j;
		}
	}
	while (i <= mid)
	{
		data_tmp[k] = data[i];
		++i;
		++k;
	}
	while(j <= high)
	{
		data_tmp[k] = data[j];
		++j;
		++k;
	}
	for (int k = 0, i = low; i <= high; ++i, ++k)
		data[i] = data_tmp[k];
}

void MergePass(int data[], int extent, int length)
{
	//	归并两个长度为extent的有序表
	if(data == NULL || extent <= 0 || extent > length)
		return;
	int i;
	for (i = 0; i + 2 * extent < length; i += 2 * extent)
		Merge(data, i, i + extent - 1, i + 2 * extent - 1);
	// 可能还剩下一些单的没有配对的元素
	if(i + extent - 1 < length)	   //	若最后元素剩下小与一个extent的长度，则没必要归并
		Merge(data, i, i + extent - 1, length - 1);
}

void MergeSort(int data[], int length)
{
	if(data == NULL || length <= 0)
		return;
	for(int extent = 1; extent < length; extent *= 2)
		MergePass(data, extent, length);
}

void main()
{
	int data[] = {0,9,8,7,1,5,6,3,4,2,45,26,789,12,79,7832,4565,413,46,455,78,58};
	//BubbleSort_2(data,22);
	//InsertSort(data,22);
	//InsertSort(data,22);
	//QuickSort(data, 0, 21);
	//ShellSort(data,22);
	//HeapSort(data, 21);   // 第一个元素没有算进去
	MergeSort(data,22);
	for(int i = 0; i < 22; ++i)
		cout << data[i] << " ";
	cout << endl;
}

http://blog.csdn.net/xwchao2014/article/details/44804087

各种常见的排序，冒泡排序，选择排序，插入排序，希尔排序，堆排序，快速排序，基数排序，桶排序

标签：各种常见排序   希尔   堆   快速   归并   

原文地址：http://blog.csdn.net/xwchao2014/article/details/47278893