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);
}