排序：冒泡排序、快速排序、shell排序法

1、冒泡排序法

思路：整形数组a[n]，要求把数组a按从小到大排列，采用冒泡排序法。

即：第一遍，目的--最小的数值放在a[0]，从尾a[n-1]扫描到a[0]，对于a[k] (0<k=<n-1)，若a[k]<a[k-1]，则两者值进行互换，这样一遍下去，数组中最小的值肯定为a[0]；

        第二遍，目的--第二小的值放在a[1]，从尾a[n-1]扫描到a[1]即可，对于a[k] (0<k=<n-1)，若a[k]<a[k-1]，则两者值进行互换，这样一遍下去，数组中次小的值肯定为a[1]；

       ……

       第n-1遍，目的--找出第n-1小的值放在a[n-2]中，由于前面的n-2个数已经排好序，故只需从尾a[n-1]扫描到a[n-2]即可。

      这样到此结束，总体思想是不断将小值移动到前面去。冒泡排序法有一个缺点，就是必须根据数组长度扫描固定的次数，若已经排好序了，还会继续这样一遍遍扫描，直到结束，我们可以添加一个判断条件，若在扫描一遍的过程中没有数据交换则说明已经排好序了，到此返回结束即可。

程序：

//bubbel sort
#include <iostream>
using namespace std;

void BubbleSort(int a[],const int length)
{
  bool exchange=false;
  for(int i=0;i<length;i++)
  {
    for(int j=length-1;j>i;j--)
	{
	  if(a[j]<a[j-1])
	  {
		  exchange=true;
	         int temp=a[j];
		 a[j]=a[j-1];
		 a[j-1]=temp;
	  
	  }
	  if(exchange==false) 
		  return;
	}
  }

}


int main(void) 
{
int a[]={0,2,4,3,1,8,7,9,6,5};
int length=sizeof(a)/sizeof(int);
BubbleSort(a,length);
for(int k=0;k<length;k++)
 cout<<a[k]<<endl;
return 0;
}

2、快速排序法

快速排序法是根据冒泡排序法改进而来，QuickSort(char a[],int s,int t)总体思路为：

1、对于整形数组a[n]，先指定某一个位置的值，比如a[s]，将其赋值给临时变量temp；

2、两个用来表示数组a元素的下标i=s，j=t 。令temp=a[i]。

3、对于j，不断j--，直到a[j]<a[i]，将该a[j]赋值给a[i]，即a[i]=a[j]。

4、对于i，不断i++，直到a[i]>temp，将a[i]赋值给a[j]，即a[j]=a[i]。

5、如此循环3、4，直到i==j结束，将temp赋值给a[i]。

通过上面1、2、3、4、5，可以看出，现在位置上的temp，其左边的值都比temp小，其右边上的值都比temp大，这样将数组分成两部分。

6、运用递归，对temp左边进行排序QuickSort(a,s,i-1)；对temp右边进行排序QuickSort(a,i+1,t)；

7、结束条件为函数参数s<t

//quick sort
#include <iostream>
using namespace std;

void QuickSort(int a[],  int s,  int t)
{

  if(s<t)
  {
	  int i=s,j=t;
      int temp=a[s];
	  while(i!=j)
	  {
		  while(j>i && a[j]>temp)
			  j--;
		  a[i]=a[j];

		  while(i<j && a[i]<temp)
			  i++;
		  a[j]=a[i];
	  }

	 a[i]=temp;
	 QuickSort(a,s,i-1);
	 QuickSort(a,i+1,t);
  }


}


int main(void) 
{
int a[]={0,2,4,3,1,8,7,9,6,5};
int length=sizeof(a)/sizeof(int);
QuickSort(a,0,length-1);
for(int k=0;k<length;k++)
 cout<<a[k]<<endl;
return 0;
}

3、shell排序

希尔排序

一种思路为：对于数组a[n]，令d=n；d=(d+1)/2；依次比较a[i]与a[i+d]（0<=i<n-d），若a[i]>a[i+d]则互换，直到对i从0到d-1没有互换为止；

再次令d=(d+1)/2，依次比较a[i]与a[i+d]（0<=i<n-d），若a[i]>a[i+d]则互换，直到对i从0到d-1没有互换为止；

……

直到d>1不满足为止。

#include <iostream>
using namespace std;
void ShellSort(int *a,int n)
 {
     int d=n;
	 while(d>1)
	 {
	    d=(d+1)/2;
		bool exchange=false;
		do
		{
			for(int i=0;i<n-d;i++)
			{
			   if(a[i+d]<a[i])
			   {  
				   exchange=true;
			      int temp=a[i];
				  a[i]=a[i+d];
				  a[i+d]=temp;
			   }
			
			}
			exchange=false;
		}while(exchange);
	 
	 }
 }


int main(void) 
{
int a[]={0,2,4,3,1,8,7,9,6};
int length=sizeof(a)/sizeof(int);
ShellSort(a,length);
for(int k=0;k<length;k++)
 cout<<a[k]<<endl;
return 0;
}