C++八大排序复习

所有排序算法均从小到大排序
一冒泡排序：冒泡排序的思想就是两两比较，把最大的沉下去；重复沉入最大数据。直到剩下最后两个数据进行比较。

void BubbleSort(int *ar, int len)
{
	int flag = 0;
	int i = 0;
	int j = 0;
	for(i=0; i<len-1; ++i)
	{
		for(j=0; j<len-i-1; ++j)
		{
			if(ar[j] > ar[j+1])
			{
				flag = 1;
				Swap(&ar[j], &ar[j+1]);
			}
		}
		if(flag == 0)
		{
			return ;
		}
		flag = 0;
	}
}

二 选择排序： 选择排序的思想是选择出范围内的最小的那个元素，最后与该范围内的第一个元素进行交换；不断重复这一过程，缩小范围，直到剩最后两个数据进行比较

void SelectSort(int *ar, int len)
{
	int tmp = 0;
	int i = 0;
	int j = 0;
	for(i=0; i<len; ++i)
	{
		tmp = i;
		for(j=i+1; j<len; ++j)
		{
			if(ar[j] < ar[tmp])
			{
				tmp = j;
			}
		}
		if(tmp != i)
		{
			Swap(&ar[i], &ar[tmp]);
		}
	}
}

三快速排序: 选取一个基值，前后进行比较，最终其前面的比其都小，后面的比其都大；在前后两部分递归调用快排

快排递归
void Quick(int*ar, int start, int end );
{
	int i = start;
	int j = end;
	int tmp = ar[i];	

	while(i <= j)
	{
		while(i < j && ar[j] >=tmp)
		{
			j--;
		}
		if(i >= j)
		{
			break;
		}
		ar[i] = ar[j];
		while(i < j && ar[i] < tmp)
		{
			i++;
		}
		if(i >= j)
		{
			break;
		}
		ar[j] = ar[i];
	}
	ar[i] = tmp;
	
	if(j - start > 1)
	{
		Quick(ar, start, j-1);
	}
	if(end - j > 1)
	{
		Quick(ar, j+1, end);
	}

}

void QuickSort(int *ar, int len)
{
	int start = 0;
	int end = len - 1;
	Quick(ar, start, end);
}

快排非递归：
快排非递归可以借助于stl的队列、栈存储需要排序的元素的开始结束位置，读取后出队列（出栈），终止条件为队列（栈）为空。

四 插入排序： 插入排序的思想是将数据插入到已经有序的数组中，给他分配一个合适的位置。

void InsertSort(int *ar, int len)
{
	if(len < 2)
	{
		return ;
	}
	int i = 0;
	int j = 0;
	int tmp = 0;
	while(i < len - 1)
	{
		j = i;
		tmp = ar[j+1];
		while(j >= 0 && ar[j] > tmp)
		{
			ar[j+1] = ar[j];
			j--;
		}
		ar[j+1] = tmp;
		++i;
	}
}

五 堆排序 堆排序借助于最大堆的性质，最大的元素在堆顶，将其与堆最后一个元素交换，然后重新调整堆，重复进行，直到最后两个数据进行交换完成。

void Adjust(int *ar, int start, int end)
{
	int i = start;
	int j = start * 2 + 1;
	int tmp = ar[i];
	while(j <=end)
	{
		if(j+1 <= end && ar[j+1] > ar[j])
		{
			j++;
		}
		if(tmp < ar[j])
		{
			ar[i] = ar[j];
			i = j;
			j = 2 * i + 1;
		}
		else
		{
			break;
		}
	}
	ar[i] = tmp;
}

void CreatHeap(int *ar, int len)
{
	int i = (len - 1) / 2;
	for(; i>=0; --i)
	{
		Adjust(ar, i, len-1);
	}
}

void HeapSort(int *ar, int len)
{
	CreatHeap(ar, len);
	int i = 0;
	for(i=0; i<len-1; ++i)
	{
		Swap(&ar[0], &ar[len - i - 1]);
		Adjust(ar, 0, len - 2 - i);
	}
}

六 桶排序： 桶排序的思想是用一个个的桶（队列、栈）来暂时存放数据，在同一个桶中的数据其在某一位的数是相同的，同时也是其桶号，最多只需要10个桶（0–9）

int GetMaxWidth(int* ar, int len)
{
	int i = 0;
	int tmp = ar[0];
	for (i = 1; i < len; ++i)
	{
		if (ar[i] > tmp)
		{
			tmp = ar[i];
		}
	}
	i = 0;
	while (tmp != 0)
	{
		tmp = tmp / 10;
		i++;
	}
	return i;
}

int GetRadix(int ar, int width)
{
	int i = 0;
	for (i = 0; i < width; ++i)
	{
		ar /= 10;
	}
	return ar % 10;
}
void BucketSort(int* ar, int len)
{
	int i = 0;
	vector<queue<int>>  qu(10);

	int width = GetMaxWidth(ar, len);
	for (i = 0; i < width; ++i)
	{
		int j = 0;
		for (j = 0; j < len; ++j)
		{
			int radix = GetRadix(ar[j], i);
			qu[radix].push(ar[j]);
		}
		
		int count = 0;
		for (j = 0; j < 10; ++j)
		{
			while (qu[j].size() != 0)
			{
				int tmp = qu[j].front();
				ar[count++] = tmp;
				qu[j].pop();
			}
		}
	}
}
void PrintData(int* ar, int len)
{
	int i = 0;
	for (i = 0; i < len; ++i)
	{
		printf("%-4d", ar[i]);
	}
	printf("\n");
}

七 希尔排序： 希尔排序可以看成多分组的插入排序，根据增量来分成多个小组，每个小组元素之间的间隔大小为增量值，从每个组的第二个元素开始进行插入。
假设有4组数据 ，组代码为a b c d 每组4个元素 1 2 3 4 即 a1 b1 c1 d1 a2 b2 c2 d2 a3 b3 c3 d3 a4 b4 c4 d4. 首先 a2 插入其组合适位置 在b2 c2 d2 在a3插入其组合适位置（a1 a2）

void Shell(int *ar, int p, int len)
{
	int i = p;
	int j = 0;
	int tmp = 0;
	while(i < len)
	{
		j = i - p;
		tmp = ar[i];
		while(j >= 0 && ar[j] > tmp)
		{
			ar[j+p] = ar[j];
			j = j - p;
		}
		ar[j + p] = tmp;
		i++;
	}
}


void ShellSort(int *ar, int len)
{
	int p[3] = {5,3,1};
	int i = 0;
	for(i=0; i<3; ++i)
	{
		Shell(ar, p[i], len);
	}
}

八 归并排序： 归并排序的思想是：

void Meger(int *ar, int len, int width)
{
	int *br = (int *)malloc(sizeof(int) * len);
	int l1 = 0;
	int h1 = l1 + width - 1;
	int l2 = h1 + 1;
	int h2 = l2 + width - 1  > len - 1 ? len - 1 : l2 + width - 1;
	int count = 0;
	while(l1 < len)
	{
		while(l1 <= h1 && l2 <= h2)
		{
			if(ar[l1] < ar[l2])
			{
				br[count++] = ar[l1++];
			}
			else
			{
				br[count++] = ar[l2++];
			}
		}
		while(l1 <= h1)
		{
			br[count++] = ar[l1++];
		}
		while(l2 <= h2)
		{
			br[count++] = ar[l2++];
		}
		l1 = h2 + 1;
		h1 = l1 + width - 1 > len - 1 ? len - 1 : l1 + width - 1;
		l2 = h1 + 1;
		h2 = l2 + width - 1 > len - 1 ? len - 1 : l2 + width - 1;
	}
	for(count=0; count<len; ++count)
	{
		ar[count] = br[count];
	}
	free(br);
	br = NULL;
}

void MegerSort(int *ar, int len)
{
	int i = 1;
	for(; i<len; i*=2)
	{
		Meger(ar, len, i);
	}
}

时间复杂度与空间复杂度分析：