常用排序算法代码实现（java）

冒泡排序：每次比较两个数据，位置不对则调换

 public static void bubbleSort(int nums[]){
        int len = nums.length;
        for(int i = 0; i < len; i++){
            for(int j = i+1; j < len; j++){
                if(nums[j] < nums[i])
                    swap(nums,i,j);
            }
        }
    }

选择排序：每次从剩余元素中找到最小的放在合适的位置

public static void selectSort(int nums[]){
        int len = nums.length;
        for(int i = 0; i < len; i ++){
            int minNumIndex = i;
            int minNum = Integer.MAX_VALUE;
            for(int j = i; j < len; j++){
                if(nums[j] < minNum){
                    minNum = nums[j];
                    minNumIndex = j;
                }
            }
            swap(nums,i,minNumIndex);
        }

    }

插入排序：对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入

public static void insertSort(int nums[]){
         int len = nums.length;
         if(len == 0) return;
         for(int i = 1; i < len; i++){
             if(nums[i] < nums[i-1]){
                 int temp = nums[i];
                 int j = i - 1;
                 while(j >= 0 && nums[j] > temp){
                     nums[j+1] = nums[j];
                     j--;
                 }
                 nums[j + 1] = temp;
             }
         }
    }

归并排序：将原数组分部分排序，排序完之后将有序数组进行合并

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

    private static void mergeSort(int[] nums, int left, int right) { //排序
        if(left >= right)
            return;
        int mid = left + (right - left)/2;
        mergeSort(nums,left,mid);
        mergeSort(nums,mid+1,right);
        merge(nums,left,right);
    }

    private static void merge(int[] nums, int left, int right) { // 合并有序数组
        int mid = left + (right - left)/2;
        int p1 = left;
        int p2 = mid+1;
        int len = right - left + 1;
        int res[] = new int[len];
        int i = 0;
        while (p1 <= mid && p2 <= right){
            if(nums[p1] < nums[p2]){
                res[i++] = nums[p1++];
            }else{
                res[i++] = nums[p2++];
            }
        }
        for(int k = p1; k <= mid; k++){
            res[i++] = nums[k];
        }
        for(int k = p2; k <= right; k++){
            res[i++] = nums[k];
        }

        i = 0;
        for(int k = left; k <= right; k++){
            nums[k] = res[i++];
        }
    }

快速排序：每轮排序找到基准的位置，其前均为小于它的数，其后均为大于它的数。

 public static void quickSort(int nums[]){
        quickSort(nums,0,nums.length - 1);
    }

    private static void quickSort(int[] nums, int left, int right) {
        int low = left, high = right;
        if(low >= high)
            return;
        int num = nums[low];

        while(low != high){
            while(high >= 0 && nums[high] >= num) //因为nums[high] 可能等于 num ，会导致high减到-1
                high--;
            if(high <= low)
                break;
            swap(nums,low,high);

            while(low <= right && nums[low] < num)
                low++;
            swap(nums,low,high);
        }

        quickSort(nums,left,low - 1);
        quickSort(nums,low + 1, right);
    }


    public static void swap(int nums[],int i,int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

总结：