数据结构几种排序实现---快速排序，冒泡排序，直接插入排序，直接选择排序，堆排序

1、直接插入排序

每次选择一个待排序值插入已有排序序列中；

（4,2,6,5,1,8)为递增排序为例：

1. key=2;小于4，4右移，2插入4位置，246518
2. key=6；位置不动，246518
3. key=5；6后移，5插入；245618
4. ....重复上述步骤，直到最后一个数插入

实现代码：

代码源文件链接

//直接插入排序*****************************************//
void insert_sort(int a[],int n)
{
	int tem;
	for (int i=0;i<n-1;i++)
	{
		tem=a[i+1];
		for (int j=i;j>=0;j--)
		{
			//升序为例//
			if (a[j]>tem)
			{
				a[j+1]=a[j];
				a[j]=tem;
			}
			else 
			{
				a[j+1]=tem;
				break;
			}
		}
	}
	for (int i=0;i<n;i++)
	{
		cout<<"直接插入排序:"<<a[i]<<endl;
	}
}

---

2、直接选择排序

每次选择最小的数放数组里

void xuanze_sort(int a[],int n)
{
	//升序排列//
	int min,min_index=0;
	for(int i=0;i<n-1;i++)
	{
		min=a[i];
		for (int j=i+1;j<n;j++)
		{
			if (min>a[j])
			{
				min=a[j];
				min_index=j;
			}
		}
		if (min<a[i])
		{
			a[min_index]=a[i];
			a[i]=min;			
		}
	}
	for (int i=0;i<n;i++)
	{
		cout<<"直接排序:  "<<a[i]<<endl;
	}
}

3、冒泡法

每一轮对相邻元素对比，根据大小交换位置

void maopao(int a[],int n)
{
	bool flag=true;
	int tem=0;
	for (int i=0;i<n-1;i++)
	{
		for(int j=0;j<n-i-1;j++)
		{
			if (a[j]<a[j+1])
			{
				tem=a[j];
				a[j]=a[j+1];
				a[j+1]=tem;
			}
		}
	}
	for(int i=0;i<n;i++)cout<<a[i]<<endl;
}

4.快速排序（递归实现）

每次一第一个数为基准，（升序为例）小于基准的放左边，大于基准的放右边。

然后对左边序列和右边序列进行相同的操作，调用递归，直到所有数排列完成。

void quicksort(int a[],int left,int right)
{
	if (left>=right)return;
	//升序排列//
	int i=left,j=right,num_cmp=a[left];
	while (i<j)
	{
		while (i<j&&a[j]>=num_cmp)
		{
			j--;
		}
		a[i]=a[j];
		while (i<j&&a[i]<=num_cmp)
		{
			i++;
		}
		a[j]=a[i];
	}
	a[j]=num_cmp;

	quicksort(a,left,i-1);
	quicksort(a,i+1,right);

}

5、堆排序（递归实现）

升序为例：

每次构建大根堆，

根和最后一个叶子节点的数交换

对前n-1个数重新构建大根堆；

循环前边操作。

void stack_sort(int a[],int n)
{
	if (n==1)
	{
		cout<<"stack_sort :"<<a[0]<<endl;
		return;
	}
	//构建大根堆//
	int tem;
	bool is_even;
	if(n%2==0)is_even=true;
	else is_even=false;
	for (int i=n/2;i>0;i--)
	{
		if (is_even)
		{
			//由于数组序号从0开始，所以所有二叉树序号对应的数组位置序号减一
			if(a[2*i-1]>a[i-1])
			{
				tem=a[2*i-1];
				a[2*i-1]=a[i-1];
				a[i-1]=tem;
			}
			is_even=false;
		}
		else
		{
			if (a[2*i-1]>a[2*i])
			{
				if (a[2*i-1]>a[i-1])
				{
					tem=a[2*i-1];
					a[2*i-1]=a[i-1];
					a[i-1]=tem;
				}
			}
			else
			{
				if (a[2*i]>a[i-1])
				{
					tem=a[2*i];
					a[2*i]=a[i-1];
					a[i-1]=tem;
				}
			}
		}

	}
	//构建初始大根堆结束//
	//根和最后一个子叶子交换位置//
	tem=a[0];
	a[0]=a[n-1];
	a[n-1]=tem;

	//递归调用自身，对前n-1个剩余数据重新构建大根堆//
	stack_sort(a,n-1);
	cout<<"stack_sort: "<<a[n-1]<<endl;
}