常用排序算法 java实现

import java.util.*;

/**
 * Created by 91407 on 2019/3/27.
 */
public class TestDemo {
    public static void main(String[] args) {
int[] arr=new int[]{
  10,7,5,8,2,3,6,9,1,4,11
};
    quickSort(arr,0,arr.length-1);
        printResult(arr);
    }
    /*
    交换
     */
    public static  void swarp(int[]arr ,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    public static  void printResult(int arr[]){
        for(int t:arr){
            System.out.print(t+" ");
        }
    }

    /*
    冒泡排序 依次比较,小数上浮
     */
    public static int[] bubbleSort(int arr[ ]){
            int len=arr.length;
            for(int i=0;i<len;i++){
                for(int j=i;j<len;j++){
                    if(arr[i]>arr[j]){
                        swarp(arr,i,j);
                    }
                }
            }
return  arr;
    }
    /*
    选择排序  从未排序列中找到最小(大)的数放在首位 最后有序
     */
    public static int [] selectionSort(int arr[]){
        int minIndex;
        int len=arr.length;
        for(int i=0;i<len;i++){
            minIndex=i;
            for(int j=i;j<len;j++){
                if(arr[j]<arr[minIndex]){
                    minIndex=j;
                }
            }
            swarp(arr,minIndex,i);
        }
        return arr;
    }
    /*
    插入排序 从后面未排序的队列取第一个值插入到前面排好顺序的队列适合的位置中,前面的队列依旧有序
     */
    public static int [] insertionSort(int[] arr){
        int sortedIndex;
        int len=arr.length;
        for(int i=1;i<len;i++){
            sortedIndex=i;
            for(int j=0;j<sortedIndex;j++){
                if(arr[j]>arr[sortedIndex]){
                    swarp(arr,j,sortedIndex);
                }
            }
        }
        return arr;
    }
    /*
    希尔排序 取一个中值,作为比较间隔,然后互换, 再把间隔减小知道间隔为0,
     */
    public  static  int[] shellSort(int arr[]){
        int len=arr.length;
        int space=len/2;//间隔
        while(space>0){
            int j=0;
            for(int i=space;i<len;i++){
                if(arr[i]<arr[j]){
                    swarp(arr,i,j);
                }
                j++;
            }
            space/=2;
        }
        return arr;
    }
    /*
    归并排序 对一个需要排序的数组一分为二,并对每个子数组递归排序,然后合并这两个子数组
     */
    public  static int[] mergeSort(int arr[]){
        int len=arr.length/2;
        if(arr.length>1){
            int arr1[],arr2[];
            arr1=Arrays.copyOfRange(arr,0,len);
            arr2= Arrays.copyOfRange(arr,len,arr.length);
            //对子数组递归排序
            return merge(mergeSort(arr1), mergeSort(arr2));
        }
        return arr;
    }
    //合并
    public static int[] merge(int arr1[],int arr2[]){
        int arr[]=new int[arr1.length+arr2.length];
        int i=0,j=0,k=0;
        while(i<arr1.length&&j<arr2.length){
            if(arr1[i]<arr2[j]){
                arr[k]=arr1[i];
                i++;
            }else{
                arr[k]=arr2[j];
                j++;
            }
            k++;
        }
        if(i==arr1.length) {
            for(int p=j;p<arr2.length;p++){
                arr[k]=arr2[p];
                k++;
            }
        }
        else{
            for(int p=i;p<arr1.length;p++){
                arr[k]=arr1[p];
                k++;
            }
        }
        return arr;
    }
    /*
    快速排序 取一个基准,大的在后,小的在右,子数组递归
     */
    public static void quickSort(int arr[],int low,int high) {
        int start=low,end=high;
        int key=arr[low];
        while(end>start){
            //从后往前
            while(end>start&&arr[end]>=key)end--;
            //找到比key小的了
            if(arr[end]<=key)
            swarp(arr,start,end);
            //从前往后
            while(end>start&&arr[start]<=key)start++;
            if(arr[start]>=key)
                swarp(arr,start,end);
        }
        if(start>low)quickSort(arr,low,start-1);
        if(end<high)quickSort(arr,end+1,high);
    }
}