常用的排序算法

概述

常用的内部排序算法包括三大类，分别是插入、选择、交换。其共同的特征是：都是将原始无序的数组分为两个段，有序的数组与无序的数组。在对有序数组与无序数组进行划分的时候，便于编写的可以选择消耗空间的方式，新建立一个有序数组。也可以使用在原始数组上进行操作。

1. 插入思想

1.1 直接插入排序

     算法思想：将无序数组中的第一个值插入到有序数组中，这样一个个的从无序数组中拿无序的值，放入有序中，保证了算法的稳定性。

    public static void InsertSort(int[] number){
        if(number.length<=1){
            return;
        }
        int i=0; // 已经排序好的数组的最后一位的下标
        while (i+1<number.length){
            if(number[i+1]<number[i]){
                // 这里可以进行交换也可以直接进行覆盖
                for (int p=i;p>=0 && number[p+1]<number[p];p--){
                    int temp=number[p+1];
                    number[p+1]=number[p];
                    number[p]=temp;
                }
            }
            i++;
        }
    }

    public static void InsertSort_Normal(int[] number){
        if(number.length<=1){
            return;
        }
        int i=0,p; // 已经排序好的数组的最后一位的下标
        while (i+1<number.length){
            int temp=number[i+1];
            if(temp<number[i]){
                for (p=i;p>=0 && temp<number[p];p--){
                    number[p+1]=number[p];
                }
                // 采用向前覆盖的这种方式，当插入值找到比自己小的值的时候也就是当前p位置的值，所以该值应该位于p的前面一个值，注意由于是覆盖，所以他前面的值是原始位置的值
                number[p+1]=temp; 
            }
            i++;
        }
    }

1.2 Shell 排序

假设有一组逆序的数组，进行直接插入排序，那么每次插入的元素就需要在已排序数组中对比到第一个元素为止，因此我们通过设置gap(增量)让相差gap的元素进行直接插入排序，直到gap值为1也就退化到原始的直接插入排序了。所以该排序是不稳定的，且对于不是几乎逆序的数组不见得有多好的作用。

  public static void shell(int[] number){
        if(number.length<=1){
            return;
        }
        int gap= (int) Math.ceil(number.length/2.0);
        do{
            // 控制相差gap的元素进行直接插入排序
            for (int i=0;i<number.length-gap;i++){
                //直接插入排序
                int p;
                while (i+gap<number.length){
                    int temp=number[i+gap];
                    if(temp<number[i]){
                        for (p=i;p>=0 && temp<number[p];p--){
                            number[p+gap]=number[p];
                        }
                        number[p+gap]=temp;
                    }
                    i+=gap;
                }
            }
            
            int gap_=(int) Math.ceil(gap/2.0);
            if(gap_==gap){
                break;
            }
            gap=gap_;
        }while (true);
    }

2.选择排序

每次从未排序的数组中选择一个该序列中最小的值，放到已经排序好的数组中，注意是不稳定的。

    /**
     * 为什么选择排序是不稳定的？
     * 如：[5 8 5 2 9]
     * @param number
     */
    public static void select(int[] number){
        if(number.length<=1){
            return;
        }
        // 开始的时候已排序好的为0 为排序的是从0下标开始，意味着0下标应该是插入排序好的下一个元素的位置
        for (int i = 0; i < number.length-1; i++) {
            int min=number[i];
            int index=i;
            for (int j = i+1; j < number.length; j++) {
                 if(number[j]<min){
                     min=number[j];
                     index=j;
                 }
            }
            int temp=number[i];
            number[i]=number[index];
            number[index]=temp;
        }
    }

3.交换排序

3.1冒泡排序

 通过相互交换数组元素的值，从左向右依次比较把小的向前面放置，或者反过来吧大的向后面放，最后有序。稳定

    private static void SwapSort(int[] number){
      if(number.length<=1){
          return;
      }
      for (int j=0; j<number.length; j++) {
          // 不管是选择还是插入排序，冒泡排序，j 都被看作插入位置 通过选择、交换、插入等手段放入合适的元素
          int flag=0;
            for (int i = number.length-1; i > j ; i--) {
                 if(number[i]<number[i-1]){
                     int temp;
                     temp=number[i];
                     number[i]=number[i-1];
                     number[i-1]=temp;
                     flag=1;
                 }
            }
            if(flag==0){
                break;
            }
        }
    }

3.2 快速排序

我们选择一个元素， 将数组分为两部分，小于该元素的与大于该元素的。重复次步骤直到每个子数组只有一个元素。不稳定

public static void quickSort(int[] number,int start,int end){
        int s_=start;
        int e_=end;
        if(number.length<=1 || (end-start)<=0){
            return;
        }
        int temp=number[start];
        int flag=-1,flag_=0;
        while (start!=end) {
            try {
                if(flag==-1){
                    while (start!=end){
                        if(number[end]<temp){
                            // 交换
                            flag_++;
                            int temp2=number[start];
                            number[start]=number[end];
                            number[end]=temp2;
                            start++;
                            flag=1;
                            break;
                        }
                        else {
                            end--;
                        }
                    }
                }
                else {
                    while (start!=end){
                        if(number[start]>temp){
                            // 交换
                            int temp2=number[start];
                            number[start]=number[end];
                            number[end]=temp2;
                            end--;
                            flag=-1;
                            break;
                        }else {
                            start++;
                        }
                    }
                }
            }catch (ArrayIndexOutOfBoundsException e) {
                System.out.println(start+" "+end);
            }
        }
        if(flag_==0){
            return;
        }
        for (int s:number){
            System.out.print(s+" ");
        }
        System.out.println();
        quickSort(number, s_,start-1);
        quickSort(number, start+1, e_);
    }