排序算法

　

　//冒泡排序，思想就是每个数据与下一个数据一个个对比下去

public static void sort(int[] nums){
    if(nums==null||nums.length==0){
        return;
    }
    for(int i =0;i<nums.length;i++){
        for(int j=1;j<nums.length-i;j++){
            if(nums[j]<nums[j-1]){
                int temp = nums[j-1];
                nums[j-1]=nums[j];
                nums[j]=temp;
            }
        }
    }
}
//插入排序 思想就是和前面的数据一个个比下去，因为前面已经是有序的了，所以只要比较到比自己小的位置插入就好
public static void insertSort(int[] nums){
    if(nums==null||nums.length==0){
        return;
    }
    int insertNode;
    int j;
    for(int i=1;i<nums.length;i++){
        j = i-1;
        insertNode = nums[i];
        while (j>=0&&insertNode<nums[j]){
                nums[j+1] = nums[j];
                j--;
        }
        nums[j+1] = insertNode;
    }
}
//选择排序 思想就是每次寻找到最小的那个值，进行替换就可以了，替换的次数比冒泡小，就是把最小的往前扔
public static void selectSort(int[] nums){
    if(nums==null||nums.length==0){
        return;
    }
    for(int i=0;i<nums.length;i++){
        int pos = i;
        for(int j=i+1;j<nums.length;j++){
            if(nums[pos]>nums[j]){
                pos=j;
            }
        }
        if(pos!=i){
            int temp = nums[i];
            nums[i] = nums[pos];
            nums[pos] = temp;
        }
    }
}

补充：三种排序  因为插入排序不用每次都扫描整个链路，所在不在绝对的情况下，性能最优，冒泡最次，选择居中

//排序王者快排 思想是将数组按一个数值不断做二分。

public static void quickSort(int[] nums){
    if(nums==null||nums.length==0){
        return;
    }
    sort(nums,0,nums.length-1);
}

private static void sort(int[] nums, int start, int end) {
    if(start>=end){
        return;
    }
    int pivot = nums[start];
    int left = start;
    int right = end;
    while (left<=right){
        while (left<=right&&nums[left]<pivot){
            left++;
        }
        while (left<=right&&nums[right]>pivot){
            right--;
        }
        if(left<=right){
            int temp=nums[left];
            nums[left]=nums[right];
            nums[right]=temp;
            left++;
            right--;
         }
    }
    sort(nums,start,right);
    sort(nums,left,end);
}

//merge Sort归并排序 性能和快排不相上下  思想主要是将数组分成最小组合，然后分别排序，然后进行合并，这样每一个合并的左右都是有序的，所以只需要从各自的第一个开始相互比较即可，需要你个临时数组来存放有序的集合，最后复制到需要排序的数组就完成了
public static void mergeSort(int[] array) {
    int[] temp = new int[array.length];
    mergeSortImpl(array, 0, array.length - 1, temp);
}

private static void mergeSortImpl(int[] array, int start, int end, int[] temp) {
    if(start>=end){
        return;
    }
    int mid = start+(end-start)/2;
    mergeSortImpl(array,start,mid,temp);
    mergeSortImpl(array,mid+1,end,temp);
    merge(array,start,mid,end,temp);
}

private static void merge(int[] array, int start, int mid, int end, int[] temp) {
    int left = start;
    int right = mid+1;
    int index = start;
    while (left<=mid&&right<=end) {
        if (array[left] < array[right]) {
            temp[index++] = array[left++];
        } else {
            temp[index++] = array[right++];
        }
    }
    while (left<=mid){
        temp[index++]=array[left++];
    }
    while (right<=end){
        temp[index++]=array[right++];
    }
    for(index=start;index<=end;index++){
        array[index] = temp[index];
    }
}

排序算法到此结束