1：交换排序

1.1：冒泡排序

public static void bubbleSort(int [] array){
        for(int i=0;i<array.length-1;i++){
            boolean flag=false;
            for(int j=0;j<array.length-1;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=true;
                }
            }
            if(flag=false){
                break;
            }
        }
}

1.2：快速排序

递归：

public static void quickSort(int[] array){
        quick(array, 0, array.length-1);
}
private static void quick(int [] array,int start,int end){

        if(start>=end){
           return;
        }

        int pivot=partition(array,start,end);

        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
}

private static int partition(int array[],int left,int right){
    int tmp=array[left];

    while (left<right){
        while (left<right && array[right]>=tmp){
            right--;
        }
        array[left]=array[right];
        while (left<right && array[left]<=tmp){
            left++;
        }
        array[right]=array[left];
    }

    array[left]=tmp;
    return left;
}

非递归：

public static void quickSortNotRecursive(int[] array){
    Stack<Integer> stack=new Stack<>();

    int start=0;
    int end=array.length-1;
    int pivot=partition(array,start,end);

    
    if(pivot>start+1){
        stack.push(start);
        stack.push(pivot-1);
    }

    if(pivot<end-1){
        stack.push(pivot+1);
        stack.push(end);
    }

    while (!stack.isEmpty()){
        end=stack.pop();
        start=stack.pop();
        pivot=partition(array,start,end);
        if(pivot>start+1){
            stack.push(start);
            stack.push(pivot-1);
        }
        if(pivot<end-1){
            stack.push(pivot+1);
            stack.push(end);
        }
    }
}

2：归并排序

递归：

public static void mergeSort(int[] array){
        mergeSortFunction(array,0,array.length-1);
    }

    private static void mergeSortFunction(int []array,int low,int high){

        if(low>=high){
            return;
        }

        int mid=low+high >>> 1;
        mergeSortFunction(array,low,mid);
        mergeSortFunction(array,mid+1,high);

        merage(array,low,high,mid);
    }

    private static void merage(int[] array,int low,int high,int mid){
                int[] tmp=new int[high-low+1];
                int k=0;
                int s1=low;
                int e1=mid;
                int s2=mid+1;
                int e2=high;

                while (s1<=e1 && s2<=e2){
                    if(array[s1]<=array[s2]){
                        tmp[k++]=array[s1++];
                    }else {
                        tmp[k++]=array[s2++];
                    }
                }

                while (s1<=e1){
                    tmp[k++]=array[s1++];
                }
                while (s2<=e2){
                    tmp[k++]=array[s2++];
                }

                for(int i=0;i<k;i++){
                    array[i+low]=tmp[i];
                }
    }

非递归：

public static void mergerSortNotRecursive(int[] array){
    int gap=1;

    while (gap < array.length){
        for(int i = 0 ; i < array.length ; i += 2*gap){
            int low = i;
            int mid = low + gap - 1;
            if(mid >= array.length){
                mid = array.length - 1;
            }
            int high = mid + gap;
            if(high >= array.length){
                high = array.length - 1;
            }
            merage(array,low,high,mid);
        }
        gap = 2 * gap;
    }

}