常见的几种排序算法（java和C++版）（参考《算法》）

1. 博主这里要讲的几种排序算法包括（从难到易）：

1.冒泡排序（最low的算法）

2.插入排序

3.希尔排序

4.归并排序

5.快速排序

6.快速排序的三项切分

冒泡排序：

（1）简介：这是最原始，最简单的排序，几乎不需要额外的空间

（2）基本原理：通过循环将最大的元素移到最末端或者最前端，俗称冒泡！

（3）时间复杂度：O（n^2）

（4）空间复杂度：O（n）

（5）代码： 

         C++版：

void sort1(int *A,int maxx)                //这里的冒泡是让较小的数往前冒
{
    while(maxx--){              //总共有maxx个元素，故循环maxx次，但是实际上值执行了maxx-1次，细心的小伙伴也许注意到了，因为当							//执行完maxx-1次的时候，数组已经排好了序
        int j=maxx;
        while(j>=0 &&j--){
            if(A[j]>A[maxx])	 //如果前面的元素比A[maxx]大，则交换两元素，就是说将小的值前移
                exch(A,maxx,j);
        }
    }
}

void exch(int *A,int a,int b)        //交换数组的两元素
{
    int t=A[a];
    A[a]=A[b];A[b]=t;
}

         Java版：

	public static void sort1(Comparable[] a,int max,boolean options){					//排序1：最low的算法：冒泡排序
		int N=a.length;
		for(int i=0;i<N;i++){    //其实冒泡排序是这样执行的：A[0]是0到a.length中最小的元素，而后不管A[0],A[1]就是1到a.length中最小的元素，

			int min=i;	 //故每次找最小的元素既可
			for(int j=i+1;j<N;j++){
				if(less(a[j],a[min]))min=j;				//如果a[j]比a[min]小，则交换j和min
			}
			exch(a,i,min);
		}
	}

 public static void exch(Comparable[] a,int i,int j){      //交换a[i],a[j]
  Comparable t=a[i];a[i]=a[j];a[j]=t;
 }	

 public static boolean less(Comparable a,Comparable b){      //a是否比b小
  return a.compareTo(b)<0;
 }

（6）优点：无

插入排序：

（1）简介：还是比较简单的排序算法，有的时候比其他算法更快（反正肯定比冒泡快），算法的快慢取决于处理的数据，后面会讲

（2）基本原理：先将A[0]看成一个数组，然后A[i]逐渐加入该数组，每加入一个元素就对该数组排序，就是说如果新添的元素比前面的小，那么该元素的位置前移，比它大的元素全部后移一位，博主此处的代码在比较的同时顺便移动元素的位置，优化了代码！

（3）时间复杂度：最坏：O（n^2）

                               最好：O（n）

（4）空间复杂度：           O（n）

（5）代码：

         C++版：

void sort2(int *A,int maxx)//插入排序,一般的插入排序是要交换两数组的值，这里我们优化一下操作，使他不需要交换数组元素，也能达到移动数组的目的
{
    int now,j,i;           //初始化now元素
    for(i=1;i<maxx;i++){   //循环maxx-1次，相当于A[0]已经排好了，现在从A[1]开始往里增长序列，的每一个新增的元素都找到自己的位置，如果新加的元素
        for(now=A[i],j=i-1;j>=0 && now<A[j];j--){    //比前面的元素小，那么前面的元素要腾出位置给它，
            A[j+1]=A[j];                             //并且保证该位置前面一个元素要比它小，后面的元素不小于它，其实就是找出合适的位置
        }
        A[j+1]=now;
    }
}

         Java版：

	public static void sort2(Comparable[] a,int lo,int hi,int max){	  //插入排序,这里的lo和hi是指数组的初下标和末下标，大家先默认为0和a.length
		for(int i=lo+1;i<=hi;i++){                                //后面会讲我这么做的原因，max其实没有意义，只是为了后面的接口一致
			if(less(a[i],a[i-1])){				  //初步判断，其实有没有都可以
				int j=i-1;
				Comparable now=a[i];
				while(j>=lo && less(now,a[j])){		//和C++的步骤相同
					a[j+1]=a[j];j--;
				}
				a[j+1]=now;
			}
		}
	}

 	public static boolean less(Comparable a,Comparable b){      //a是否比b小
  		return a.compareTo(b)<0;
 	}

（6）优点：处理小规模数组排序较快

希尔排序：

void shellSort()
{
	int increment;										//记录增量的变量
	int start;											//记录每次插入排序的起始元素位置
	int temp;
	increment = count;
	//printf("IM HERE  %d",increment/3);
	for (increment = increment / 2; increment > 0; increment = increment / 2)
	{
		//printf("IM HERE1");
		for (start = increment; start < count; start++)
		{
			for (int j = start - increment; j >= 0 && data[j] > data[j + increment]; j -= increment)
			{
				std::swap(data[j], data[j + increment]);
			}
			
		}
	
	}
}

归并排序

快速排序

void quickSort(int low, int high)
{
	if (low > high)
		return;
	int i, j;
	int pivot;
	pivot = data[low];
	i = low;
	j = high;
	while (i != j)
	{
		while (data[j] >= pivot&&i < j)
			j--;
		while (data[i] <= pivot&&i < j)
			i++;
		if (i < j)
			std::swap(data[i], data[j]);
	}
	data[low] = data[i];
	data[i] = pivot;
	/*for (int u = 0; u < count; u++)
		printf("%d ", data[u]);
	printf("\n");*/
	quickSort(low, i - 1);
	quickSort(i + 1, high);
}