几种常用排序

选择排序：把第一个元素和其他元素依次对比，第一次比较完后 ，和最小的交换位置，即第一次最小的值出现在前面。然后第二个数和后面的进行比较 以此类推。(具体可参考https://www.cnblogs.com/nullering/p/9537321.html)

//简单选择排序,按自然顺序
public static void selectsort(int[] array){
int min, index, temp;//定义最小值索引 。
for(int i = 0; i < array.length - 1; i++){ // N - 1 趟
min = i;
//查找选择最小元素值的下标索引值
for(index = i + 1; index < array.length; index++){
if(array[min] > array[index])
min = index;
}
//交换位置
if(min != i){
temp = array[min];
array[min] = array[i];
array[i] = temp;
}
}
}

冒泡排序：相邻元素两两比较，大的往后放，第一次比较完后，最大值出现在末尾即最大索引处。时间复杂度O（n²）

public static int maopao(int[ ] arr){

for(int i=0;i<arr.length-1;i++){

for(int j=0;j<arr.length-1-i;j++){

  if(a[j]>a[j+1]){

int temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;}

} 

return temp;

19  }
}

插入排序：第一个数据不动，从第二个开始和它前面的进行比较，比它大的向后排，比它小则不动。

1，

2，

3，

import java.util.Arrays;

//插入排序
//第一个数据不动，从第二个开始和它前面的进行比较，比它大的向后排，比它小则不动
public class Insert {
    public static void sort(int[] arr) {
        
        int insertData;// 要插入的数据 
        // 从数组的第二个元素开始循环将数组中的元素插入 
        for (int i = 1; i < arr.length; i++) { 
            insertData = arr[i]; 
            /*for(int j=i-1;j>=0;j--){
              if(a[i]<a[j]){
                  arr[j + 1] = arr[j]; 
              }else{
                break;
              }
            }*/
          int j = i - 1; 
          // 如果要插入的元素小于第j个元素，就将第j个元素向后移 
          while ((j >= 0) && insertData < arr[j]) { 
            arr[j + 1] = arr[j]; 
            j--;  
          } 
          // 直到要插入的元素不小于第j个元素,将insertNote插入到数组中 
          arr[j + 1] = insertData; 
          //System.out.println(Arrays.toString(arr));
        } 
        System.out.println(Arrays.toString(arr));
     }

    public static void main(String[] args) {
        int arr[]={2,6,5,4,7,8};
        //int arr[]=null;
        //int arr[]={2,1};
        //int arr[]={2};//[2]
        sort(arr);
        
    }

}

归并排序：

package zh.ysj;

class guibingpaixu {

    public static int[] sort(int[] a,int low,int high){
        int mid = (low+high)/2;
        if(low<high){
            sort(a,low,mid);
            sort(a,mid+1,high);
            //左右归并
            paixu(a,low,mid,high);
        }
        return a;
    }
     
    public static void paixu(int[] a, int low, int mid, int high) {
        int i= low;
        int j = mid+1;
        int k=0;
        int[] temp = new int[high-low+1];
        // 把较小的数先移到新数组中
        while(i<=mid && j<=high){
            if(a[i]<a[j]){
                temp[k++] = a[i++];
            }else{
                temp[k++] = a[j++];
            }
        }
        // 把左边剩余的数移入数组 
        while(i<=mid){
            temp[k++] = a[i++];
        }
        // 把右边边剩余的数移入数组
        while(j<=high){
            temp[k++] = a[j++];
        }
        // 把新数组中的数覆盖数组
        for(int x=0;x<temp.length;x++){
            a[x+low] = temp[x];
        }
    }
    
    
    
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
       int[]a ={2,5,8,7,4,5,3};
       sort(a,0,a.length);
    

}
}

快速排序

import java.util.Arrays;
/*
* 快速排序：
* 一趟快速排序的算法是： 　　
* 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1； 　　
* 2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； 　　
* 3）从j开始向前搜索，即由后开始向前搜索（j=j-1即j--），
* 找到第一个小于key的值A[j]，A[i]与A[j]交换； 　　
* 4）从i开始向后搜索，即由前开始向后搜索（i=i+1即i++），
* 找到第一个大于key的A[i]，A[i]与A[j]交换； 　　
* 5）重复第3、4、5步，直到 I=J；
* (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。
* 找到并交换的时候i， j指针位置不变。
* 另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。）
*/

public class speedSort {
public static void sort(int[] data) {
quickSort(data, 0, data.length - 1);
}

private static void quickSort(int[] data, int i, int j) {
int pivotIndex = (i + j) / 2;
// swap
swap(data, pivotIndex, j);//交换位置

int k = partition(data, i - 1, j, data[j]);
swap(data, k, j);//交换位置
if ((k - i) > 1)
quickSort(data, i, k - 1);//交换位置
if ((j - k) > 1)
quickSort(data, k + 1, j);//交换位置

}

/**
* @param data
* @param i
* @param j
* @return
*/
private static int partition(int[] data, int l, int r, int pivot) {
do {
while (data[++l] < pivot)
;
while ((r != 0) && data[--r] > pivot)
;
swap(data, l, r);//交换位置
} while (l < r);
swap(data, l, r);//交换位置
return l;
}
public static void main(String[] args) {
int[] arr = { 2, 5, 3, 1, 4 };
System.out.println("排序前：" + Arrays.toString(arr));
// InsertSort.sort(arr);
// BubbleSort.sort(arr);
// SelectionSort.sort(arr);
// ShellSort.sort(arr);
sort(arr);
// MergeSort.sort(arr);
// HeapSort.sort(arr);
System.out.println("排序后：" + Arrays.toString(arr));
}

/*
* 交换数组中的两个元素
*/
public static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}


}