冒泡排序的基本思想：重复的走过要排序的数列，一次比较两个元素，相邻两个元素进行交换，直到没有在需要交换为止。

（1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。

（2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

（3）针对所有的元素重复以上的步骤，除了最后一个。

（4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

//交换类冒泡排序
void BubbleSort(int a[],int n){
	int i,j,t;
	for(i=0;i<n-1;i++){
		for(j=0;j<n-i;j++){
			if(a[j]>a[j+1]){
				t=a[j];
				a[j]=a[j+1];
				a[j+1]=t;	
			}
		}
	}
	printf("交换类冒泡升序序列为:\n");
	for(i=0;i<n;i++){
		printf("%d ",a[i]);
	}
	printf("\n");

}

简单选择排序的基本思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，才放在序列的起始位置，知道全部待排序的数据元素排完为止！

//简单的选择类排序
void ChangeSort(int a[],int n){
	int i,j,t;
	for(i=0;i<n-1;i++){
		for(j=i+1;j<n;j++){
			if(a[i]>a[j]){
				t=a[i];
				a[i]=a[j];
				a[j]=t;
			}
		}
	}
	printf("选择类排序升序为:\n");
	for(i=0;i<n;i++){
		printf("%d ",a[i]);
	}
	printf("\n");
} 

插入排序的基本思想：每步将一个待排序的记录，按其关键码值的大小插入前面已经排好序的文件中适当位置，知道全部插入为止！

//插入类排序
void InSertSort(int a[],int n){
	int i,j,x;
	for(i=1;i<n;i++){
		x=a[i];
		for(j=i-1;j>=0 && a[j]>x;j--){
			a[j+1]=a[j];
		}
		a[j+1]=x;
	}
	printf("插入类排序升序序列为:\n");
	for(i=0;i<n;i++){
		printf("%d ",a[i]);
	}
	printf("\n");
} 

二路归并排序的基本思想：采用分治算法来对其一个数组进行划分合并，直到划分的组中只有一个数组元素为止！

//采用分治算法思想进行二路归并排序 
void MergeSort(int a[],int left,int right){
	if(left == right){
		return;
	}
	int mid = (left + right)/2;
	MergeSort(a,left,mid);		//左边依次递归再次划分 
	MergeSort(a,mid+1,right);	//右边依次递归再次求解 
	int c[10];					//临时数组，用来保存具体两个子区间合并的值 
	int i = left;
	int j = mid+1;
	int k = left;
	while(i <= mid || j <= right){ 	
		//当右子区间已经比较完，或者左区间中的值存在且比右区间值小 
		if(j > right || (i <= mid && a[i] < a[j])){
			c[k++] = a[i++];	//将其左区间的值放入临时数组中 
		}else{
			c[k++] = a[j++];	//右区间的值存在，且比左区间的值小，放入临时数组 
		}
	}
	//将临时数组中的值拷贝到原来数组
	for(k=left;k<=right;k++){
		a[k] = c[k];
	}
}

快速排序的基本思想：采用分治算法通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，

然后再按此方法对这部分数据进行快速排序，整个排序过程可以递归进行，依此达到整个数据编程有序序列！

//快速排序算法 
void quickSort(int *a, int left, int right)
{
    if(left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
    {
        return ;
    }
    int i = left;
    int j = right;
    int key = a[left];
     
    while(i < j)                               /*控制在当组内寻找一遍*/
    {
        while(i < j && key <= a[j])
        /*而寻找结束的条件就是，1，找到一个小于或者大于key的数（大于或小于取决于你想升
        序还是降序）2，没有符合条件1的，并且i与j的大小没有反转*/ 
        {
            j--;/*向前寻找*/
        }
         
        a[i] = a[j];
        /*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是
        a[left]，那么就是给key）*/
         
        while(i < j && key >= a[i])
        /*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，
        因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/
        {
            i++;
        }
         
        a[j] = a[i];
    }
     
    a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
    Sort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
    Sort(a, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
                       /*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/
}