简单选择排序：
package cn.mdj.test;
public class SelectSort {
public static void sort(int array[]){
int len = array.length;
int temp; //临时变量
int index; //最小元素索引
for(int i=0;i<len;i++){
index = i;//假设第一个元素最小
for(int j=i+1;j<len;j++){//将当前的最小元素与后面元素比较，获取最小的元素
if(array[j]<array[index]){
index = j;//交换索引，索引永远指向最小的那个元素
}
}
//与后面元素遍历完后，看是否需要进行交换
if(index != i){
temp = array[index];
array[index] = array[i];
array[i] = temp;
}
}
}
public static void main(String[] args) {
int[] array = new int[]{1,3,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}
简单插入排序：
package cn.mdj.test;
public class InsertSort {
public static void sort(int[] array){
int len = array.length;
for(int i=1;i<len;i++){
int temp = array[i]; //保存要插入的元素
int j=0; //有序区，内首先有一个元素
//对有序区开始排序，从有序区的后面开始比较大小进行交换
for(j=i-1;j>-1&&temp < array[j];j--){
//如果待插入的元素比其小，则它前面的元素要后移
array[j+1] = array[j];
}
//直到，temp比前面的元素大，即停止，此时的j即该元素的位置，但因j--，所以位置还有要回填1
array[j+1]=temp;
}
}
public static void main(String[] args) {
int[] array = new int[]{1,3,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}
简单冒泡排序：
package cn.mdj.test;
public class BubbleSort {
public static void sort(int[] array){
int len = array.length;
for(int i=0;i<len;i++){
for(int j=i+1;j<len;j++){
if(array[i]>array[j]){
int temp = array[i];
array[i]=array[j];
array[j]= temp;
}
}}}
堆排序：
public class HeapSort {
public static void sort(int[] array){
int len = array.length;
//建立大顶堆
buildMaxHeap(array,len);
for(int i=len-1;i>0;i--){
int temp = array[i];
array[i] = array[0];
array[0] = temp;
MaxHeapify(array,1,i);
}
}
public static void buildMaxHeap(int[] arr,int len){
//从中间元素开始，调整使其变成大顶堆
for(int i=len/2;i>0;i--){
MaxHeapify(arr,i,len);
}
}
public static void MaxHeapify(int[] arr,int index,int len){
int left = 2*index; //当前索引的左孩子
int right = left+1; //当前索引的右孩子
int lagest; //用于储存最大索引
//如果左叶子节点索引小于堆大小，比较当前值和左叶子节点的值，取值大的索引值
if(left <= len&&arr[left-1]>arr[index-1]){
lagest = left;
}else{
lagest = index;
}
//如果右叶子节点索引小于堆大小，比较右叶子节点和之前比较得出的较大值，取大的索引值
if(right<=len&&arr[right-1]>arr[lagest-1]){
lagest = right;
}
//交换位置，并继续递归调用该方法调整位置。
if(lagest != index){
int temp = arr[index-1];
arr[index-1] = arr[lagest-1];
arr[lagest-1] = temp;
MaxHeapify(arr,lagest,len);
}
}
public static void main(String[] args) {
int[] array = new int[]{1,3,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}
希尔排序：
package cn.mdj.test;
public class ShellSort {
public static void sort(int[] array){
int len = array.length;
int h = 1;
while(h<=len/3){ //当分区的区间没有超过len数据的长度，即 继续按照固定增量法，增加
h = h*3 + 1; //初始增量，最后得到h为划分的合理区间
}
while(h>0){ //直到h=1;为止
for(int i=h;i<len;i++){ //和插入排序类似，从分区域的第二个元素开始，所以是i=h;；
//只所以是i++;是因为控制的是外面的，都要分区
int temp = array[i]; //保存第二个元素
int j = array[i-h];//有序区中的一个元素
//开始对有序区中的元素进行排序，从后往前，即从i-h,
for(j=i-h;j>-1&&temp<array[j];j=j-h){ //注意是j-h
//往后移动
array[j+h] = array[j];
}
array[j+h] = temp;
}
h = (h-1)/3; //不断缩小区间，直到为1
}
}
public static void main(String[] args) {
int[] array = new int[]{1,3,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}
快速排序：
package cn.mdj.test;
public class QuickSort {
public static void sort(int[] array){
int len = array.length;
quickSort(array,0,len-1);
}
public static void quickSort(int arr[],int l,int r){
//l 左 r 右
int left = l;
int right = r;
int jizhunzhi = arr[left];
while(left < right){ //左 没有超过 右的时候
while(left<right&&jizhunzhi<arr[right]){
right--;
}
if(left<right){ //否则当 jizhunzhi>arr[right] 时候，说明要开始交换了
arr[left] = arr[right];
left++;//开始移动到下一个位置
}
//同样，右边完成后，左边要开始了
while(left<right&&jizhunzhi>arr[left]){
left++;
}
if(left<right){//否则 jizhunzhi<arr[left]
arr[right] = arr[left];
right--;
}
}
//最后直到left = right 停止，那么第一元素，也就是我们假设的jizhunzhi的位置也就确定好了
arr[left] = jizhunzhi;
if(l<left) quickSort(arr,l,right-1);
if(left<r) quickSort(arr,right+1,r);
}
public static void main(String[] args) {
int[] array = new int[]{1,13,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}