1.冒泡排序：
（1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
（2）外面再套个循环就行。
算法复杂度：O(N2) 不罗嗦，上代码：
//冒泡排序（两两交换，外加一个外循环）
public static void bubbleSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=0;i<len-1;i++){
for (j=1;j<len-i;j++){
if (sortData[j-1] > sortData[j]){
swap(sortData,j-1,j);
}
}
}
}
2. 选择排序
（1）每次从剩下无序中选择最小的元素，进行交换
算法复杂度：O(N2) 不罗嗦，上代码：
//选择排序（从剩下的选最大的交换） public static void selectionSort(int sortData[]){ int i,j,min,index,temp; int len = sortData.length; for (i=0;i<len;i++){ min = sortData[i]; index = i; for (j=i+1;j<len;j++){ if (sortData[j] < min){ min = sortData[j]; index = j; } } swap(sortData,i,index); } }
3.插入排序：
（1）基本操作就是将一个数据插入到已经排好序的有序数据中：
//插入排序，把大的往后移动
public static void insertSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=1;i<len;i++){
temp = sortData[i];
for (j = i-1;j>=0 && temp < sortData[j];j--){
sortData[j+1] = sortData[j];
}
sortData[j+1] = temp;
}
}
3.希尔排序：
是插入排序的改进版，主要是希尔通过引入增量，加强了插入排序的威力。随着增量的减少，就有序了。
//希尔排序 public static void shellSort(int sortData[]){ int i,j,temp; int len = sortData.length; int gap = len/2; while(gap>=1){ for (i=gap;i<len;i++){ temp = sortData[i]; for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){ sortData[j+gap] = sortData[j]; } sortData[j+gap] = temp; } gap = gap/2; } }
4.堆排序
（1）初始堆 （2）adjust到最小堆或最大堆的格式 （3）排序，根位置和最后一个位置换一下位置，再adjust。
利用最大堆，最小堆这一特性，使得每次从无序的列表中选择最大或者最小的数据。
其基本思想为(大顶堆)：
1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；
2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n];
3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
1）运行时间消耗：构建初始堆 和 重建堆的反复筛选上。
构建堆：
每次从最下层的最右边的非终端节点构建，将他和期孩子节点进行比较，每次最多进行两次比较和交互，因此这个构建时间是N
重建堆（排序）：
第i次取堆顶需要logi，那么要去n-1次，所以时间复杂度是nlogn
由于堆排序对原始记录的排序状态并不敏感，因此它无论是最好、最坏和平均时间复杂度均为O(nlogn)。
2） 空间复杂度上，它只有一个用来交换的暂存单元，也算是非常的不错。不过由于记录的比较与交换是跳跃式进行，因此堆排序也是一种不稳定的排序方法。
另外，由于初始构建堆所需的比较次数较多，因此，它并不适合待排序序列个数较少的情况。
public static void heapSort(int sortData []){
buildMaxHeap(sortData);
for(int i=sortData.length-1;i>=1;i--){
swap(sortData,0,i);
maxHeap(sortData,i,0);
}
}
public static void buildMaxHeap(int sortData[]){
int half = sortData.length/2;
for(int i=half;i>=0;i--){
maxHeap(sortData,sortData.length,i);
}
}
public static void maxHeap(int sortData[],int heapSize,int index){
int left = 2*index+1;
int right = 2*index+2;
int largest = index;
if (left < heapSize && sortData[left]>sortData[index]){
largest = left;
}
if(right < heapSize && sortData[right]>sortData[largest]){
largest = right;
}
if (index != largest){
swap(sortData,index,largest);
maxHeap(sortData,heapSize,largest);
}
}
5. 快速排序：
其实是二分法，一般来说以第一个位置做为分界点，把小的放到这个分界点前面，大的放到后面。递归这两部分。
基本思想：选择一个基准元素，通常是选取第一个或者最后一个元素，通过一趟扫描，将待排序的序列分成两部分，一部分比基准元素小，一部分比基准元素大。此时基准元素就在排好序的正确位置。然后采用相同的方法，递归排序划分左右数据。
算法复杂度：平均和最好都是： nlog（n） 最坏情况（逆序）： n2 不稳定
//快速排序
public static void quickSort(int sortData[],int start,int end){
if (start >=end) return;
int i=start,j=end,value = sortData[i];
boolean flag = true;
while(i!=j){
if (flag){
if (value > sortData[j]){
swap(sortData,i,j);
flag=false;
}else{
j--;
}
}else{
if (value<sortData[i]){
swap(sortData,i,j);
flag=true;
}else{
i++;
}
}
}
//printValue(sortData);
quickSort(sortData,start,j-1);
quickSort(sortData,i+1,end);
}
c++
//快排
void qsort(int a[],int low,int high){
if (low >= high) return;
int first = low;
int last = high;
int key = a[first];
while(first<last){
while(first<last && a[last]>=key) --last;
a[first] = a[last];
while(first<last && a[first]<=key) ++first;
a[last] = a[first];
}
a[first] = key;
qsort(a,low,first-1);
qsort(a,first+1,high);
}
6 归并排序 c++
void merge(int array[],int low,int mid,int high){
int i = low;
int j = mid+1;
int k = 0;
int *array2 = new int [high-low+1];
while(i <= mid && j <= high){
if (array[i] < array[j]){
array2[k] = array[i];
i++;
k++;
}else{
array2[k] = array[j];
j++;
k++;
}
}
while(i <= mid){
array2[k] = array[i];
k++;
i++;
}
while(j <= high){
array2[k] = array[j];
k++;
j++;
}
for(k=0,i=low;i<=high;i++,k++){
array[i] = array2[k];
}
}
void mergeSort(int a[],int low,int high){
if (low<high){
int mid = (low+high)/2;
mergeSort(a,low,mid);
mergeSort(a,mid+1,high);
merge(a,low,mid,high);
}
}
int main(){
int arr [10] = {3,4,2,4,6,2,5,7,0,2};
int len;
ARR_LEN(arr,len);
mergeSort(arr,0,len-1);
for(auto x: arr){
cout << x << " ";
}
}
所有可运行代码：
//gjs public class sort { public static void printValue(int sortData[]){ for (int i = 0;i<sortData.length;i++){ System.out.print(sortData[i]+" "); } System.out.println(); } public static void swap(int [] data ,int pos1, int pos2){ int temp = data[pos1]; data[pos1] = data[pos2]; data[pos2] = temp; } //冒泡排序（两两交换，外加一个外循环） public static void bubbleSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=0;i<len-1;i++){ for (j=1;j<len-i;j++){ if (sortData[j-1] > sortData[j]){ swap(sortData,j-1,j); } } } } //选择排序（从剩下的选最大的交换） public static void selectionSort(int sortData[]){ int i,j,min,index,temp; int len = sortData.length; for (i=0;i<len;i++){ min = sortData[i]; index = i; for (j=i+1;j<len;j++){ if (sortData[j] < min){ min = sortData[j]; index = j; } } swap(sortData,i,index); } } //插入排序，把大的往后移动 public static void insertSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=1;i<len;i++){ temp = sortData[i]; for (j = i-1;j>=0 && temp < sortData[j];j--){ sortData[j+1] = sortData[j]; } sortData[j+1] = temp; } } //希尔排序 public static void shellSort(int sortData[]){ int i,j,temp; int len = sortData.length; int gap = len/2; while(gap>=1){ for (i=gap;i<len;i++){ temp = sortData[i]; for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){ sortData[j+gap] = sortData[j]; } sortData[j+gap] = temp; } gap = gap/2; } } public static void heapSort(int sortData []){ buildMaxHeap(sortData); for(int i=sortData.length-1;i>=1;i--){ swap(sortData,0,i); maxHeap(sortData,i,0); } } public static void buildMaxHeap(int sortData[]){ int half = sortData.length/2; for(int i=half;i>=0;i--){ maxHeap(sortData,sortData.length,i); } } public static void maxHeap(int sortData[],int heapSize,int index){ int left = 2*index+1; int right = 2*index+2; int largest = index; if (left < heapSize && sortData[left]>sortData[index]){ largest = left; } if(right < heapSize && sortData[right]>sortData[index]){ largest = right; } if (index != largest){ swap(sortData,index,largest); maxHeap(sortData,heapSize,largest); } } //快速排序 public static void quickSort(int sortData[],int start,int end){ if (start >=end) return; int i=start,j=end,value = sortData[i]; boolean flag = true; while(i!=j){ if (flag){ if (value > sortData[j]){ swap(sortData,i,j); flag=false; }else{ j--; } }else{ if (value<sortData[i]){ swap(sortData,i,j); flag=true; }else{ i++; } } } //printValue(sortData); quickSort(sortData,start,j-1); quickSort(sortData,i+1,end); } public static void main(String[] args) { int [] a={2,4,1,5,8,9,43,3,7,8,9,0,3}; printValue(a); //bubbleSort(a); //selectionSort(a); //insertSort(a); //heapSort(a); //shellSort(a); quickSort(a,0,a.length-1); printValue(a); } }