排序算法

1、选择排序：以升序为例，第一次找出最小的数放在第一个位置，第二次找出剩下元素中最小的数放入第二个位置，依此类推，知道最后一个元素。最好情况是本来就有序，此时需要交换0次，最差情况是逆序，此时需要交换n-1次，总体复杂度O(n*n)。

void SelectSort(int a[],int iLen)
{
	int i = 0;
	int j = 0;
	int iMin = 0;
	int iPos = 0;

	for (; i < iLen-1; i++)
	{
		iMin = a[i];
		iPos = i;

		//找出最小的
		for (j = i+1; j < iLen; j++)
		{
			if (a[j] < iMin)
			{
				iMin = a[j];
				iPos = j;
			}
		}
		//放在当前第一个未排序位置
		if (iPos != i)
		{
			a[iPos] = a[i];
			a[i] = iMin;
		}
		
	}
}

 

2、直接插入排序：将序列分成有序序列和无序序列，依次将无序序列中的数字插入有序序列中。

void InsertSort(int a[],int iLen)
{
	int i = 0;
	int j = 0;
	int iTmp = 0;

	for (; i < iLen-1; i++)
	{
		iTmp = a[i+1];
		for (j = i+1; j > 0; j--)
		{
			
			if (iTmp < a[j-1])
			{
				a[j] = a[j-1];
			}
			else
			{
				break;
			}
		}
		a[j] = iTmp;
	}
}

 

3、冒泡排序：依次比较相邻的两个元素，符合条件则交换，这样每轮都能找到一个最大或最小的数

void BubbleSort(int a[],int iLen)
{
	int i = 0;
	int j = 0;
	int iTmp = 0;
	for (; i < iLen-1; i++)
	{
		for (j = iLen-1; j > i; j--)
		{
			if (a[j] < a[j-1])
			{
				iTmp = a[j];
				a[j] = a[j-1];
				a[j-1] = iTmp;
			}
		}
	}
}

 4、归并排序：主要是递归和合并

//合并数组，数组a由iStart\iMid\iEnd分成两段，b用来保存合并后的数组
void MergeArry(int a[],int iStart,int iMid,int iEnd)
{
	int i = iStart;
	int j = iMid+1;
	int k = 0;

	//比较a的两段，将较小的放入b
	while (i <= iMid && j <= iEnd)
	{
		if (a[i] < a[j])
		{
			b[k++] = a[i++];
		}
		else
		{
			b[k++] = a[j++];
		}
	}

	//将前半段剩余的放入b
	while (i <= iMid)
	{
		b[k++] = a[i++];
	}
	//将后半段剩余的放入b
	while (j <= iEnd)
	{
		b[k++] = a[j++];
	}

	//将临时数组b的元素复制到a
	for (i = 0; i < k; i++)
	{
		a[iStart+i] = b[i];
	}

}
//递归排序
void MergeSort(int a[],int iStart,int iEnd)
{
	int iMid = 0;
	if (iStart < iEnd)
	{
		iMid = (iStart+iEnd)/2;
		MergeSort(a,iStart,iMid,b);
		MergeSort(a,iMid+1,iEnd,b);
		MergeArry(a,iStart,iMid,iEnd,b);
	}
}

5、快速排序

void Qsort(int a[],int iLow,int iHigh)
{
	if (iLow > iHigh)//这个是异常保护，也是递归的结束条件
	{
		return;
	}

	int i = iLow;
	int j = iHigh;
	int iIndex = a[i];

	while (i < j)
	{
		while (i < j && a[j] >= iIndex)
		{
			j--;
		}
		if (i < j)
		{
			a[i] = a[j];
			i++;
		}

		while (i < j && a[i] < iIndex)
		{
			i++;
		}
		if (i < j)
		{
			a[j] = a[i];
			j--;
		}
	}

	a[i] = iIndex;
	Qsort(a,iLow,i-1);
	Qsort(a,i+1,iHigh);
}

void QuickSort(int a[],int iLen)
{
	Qsort(a,0,iLen-1);
}

6、堆排序

void Swap(int& a,int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

void AdjustMinHeap(int a[],int iLen,int iPos)
{
	int iTemp = a[iPos];
	int iChild;

	for (; 2*iPos+1 <= iLen; iPos = iChild)//2*iPos+1为iPos的左孩子
	{
		iChild = 2*iPos+1;
		if (iChild < iLen && a[iChild] > a[iChild+1])//让iChild指向左右孩子中较小的一个
		{
			iChild++;
		}

		if (a[iChild] > a[iPos])
		{
			//左右孩子中小的都比iPos大，那就不用调整了
			break;
		}
		else
		{
			//将左右孩子中最小的放在iPos的位置
			a[iPos] = a[iChild];
		}
	}
	a[iPos] = iTemp;//最后把要调整的元素放在合适的位置
}

void MinHeapSort(int a[],int iLen)
{
	
	int i = 0;
	//建立堆
	for (i = iLen/2-1; i >= 0; i--)
	{
		AdjustMinHeap(a,iLen-1,i);
	}
	
	for (i = iLen-1; i > 0; i--)
	{
		Swap(a[0],a[i]);
		AdjustMinHeap(a,i-1,0);
	}
}