1.冒泡排序：
（1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
（2）外面再套个循环就行。
算法复杂度：O(N2) 不罗嗦，上代码：
//冒泡排序（两两交换，外加一个外循环） public static void bubbleSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=0;i 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
3.插入排序：
（1）基本操作就是将一个数据插入到已经排好序的有序数据中：
//插入排序，把大的往后移动 public static void insertSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=1;i =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 =0&&temp
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 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 =key) --last; a[first] = a[last]; while(first
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
所有可运行代码：
//gjspublic class sort { public static void printValue(int sortData[]){ for (int i = 0;i 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 =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 =0&&temp =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