排序

一、冒泡排序

　　

package Sort;

public class BubbleSort {
    /*冒泡排序*/
    public static int[] sort(int[] array){
        //这里循环表示总共需要比较多少轮
        for(int i=1;i<array.length;i++){
            //设定一个标记，若为true,则表示此次循环没有进行交换，也就是待排序列已经有序，排序完成
            boolean flag=true;
            //这里的for循环表示每轮参与比较的元素下标，对下标0---length-i,进行排序
            for(int j=0;j<array.length-i;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag =false;
                }
            }
            if(flag){
                break;
            }
        }
        return  array;
    }
}

二、选择排序

package Sort;

public class ChooseSort {
    /*选则排序*/
    /*1.从待排序序列中，找到关键字最小的元素
    * 2.如果最小元素不是待排序序列的第一个元素，将其和第一个元素交换
    * 3.从剩余N-1个元素中，找到关键字最小的元素，重复1，2*/
    public static  int[] sort(int[] array){
        // 总共进行N-1轮比较
        for(int i=0;i<array.length-1;i++){
            int min=i;
            //每轮需要比较的次数
            for(int j=i+1;j<array.length;j++){
                if(array[j]<array[min]){
                    min=j;
                }
            }
            if(i!=min){
                int tem=array[i];
                array[i]=array[min];
                array[min]=tem;
            }
        }
        return array;
    }
}

三、插入排序

　　

package Sort;

public class InsertSort {
    /*插入排序*/
    /*直接插入排序的思想是每一步将一个待排序的记录插入到前面已经排好的有序序列中，直到插入完为止*/
    /*插入排序还分为直接插入排序，二分插入排序，链表插入排序，希尔排序等*/
    public static  int[] sort(int[] array){
        //从下标为1的元素开选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
        for(int i=1;i<array.length;i++){
            int tmp=array[i];//记录要插入的数据
           int j=i;
            while (j>0&&tmp<array[j-1]){//从已经排序的序列最右边开始比较，找到比其小的数
                array[j]=array[j-1];//向后挪动
                j--;
            }
            array[j]=tmp;//存在比其小的数，插入
        }
        return array;
    }
}

四、希尔排序

package Sort;

public class ShellSort {
    /*希尔排序 knuth间隔序列3h+1*/
    public  static  int[] sort(int[] array){
        int step=1;
        int len=array.length;
        while (step<=len/3){
            step= step*3+1;//根据数组长度选取间隔
        }
        while (step>0){
            for(int i=step;i<len;i++){
                int tmp=array[i];
                int j=i;
                while (j>step-1&&tmp<array[j-step]){
                    array[j]=array[j-step];
                    j-=step;
                }
                array[j]=tmp;
            }
            step=(step-1)/3;
        }
        return array;
    }

    public static void main(String[] args) {
        int [] a={1,4,5,6,2,3,5,1,5,65,3,23,12,33,44,66,33,22,21,14,15,31,15};
       sort(a);
        for (int i:a) {
            System.out.println(i);
        }
    }

}

五、快速排序

package Sort;

public class QuickSort {
    /*快速排序*/
    //数组中，下标为i,j的元素进行交换
    private  static  void swap(int[] array,int i,int j){
        int tmp=array[i];
        array[i]=array[j];
        array[j]=tmp;
    }
    public static  int getMiddle(int[] array,int left,int right){//查找分割元素排序后所在的位置
        int tmp=array[left];//数组的第一个元素作为分割元素
        while (left<right){
            while (left<right&&array[right]>=tmp){
                right--;
            }
            swap(array,left,right);
            while (left<right&&array[left]<tmp){
                left++;
            }
            swap(array,left,right);
        }
        return  left;//返回分割元素位置
    }
    public static  void sort(int[] array,int left,int right){
                if(left<right){
                    int middle=getMiddle(array,left,right);
                    sort(array,left,middle);
                    sort(array,middle+1,right);
                }
    }
    public static void main(String[] args) {
        int [] a={44,4,5,6,2,3,5,1,5,65,3,23,12,33,44,66,33,22,21,14,31,15};
        sort(a,0,a.length-1);
        for (int i:a
             ) {
            System.out.println(i);
        }
    }

}

六、归并排序

package Sort;

public class MergeSort {
    /*归并排序*/
        public static  void merge(int[] a,int low,int mid,int high){
                int[] tmp= new int[high-low+1];
                int i=low;
                int j=mid+1;
                int k=0;
                //把较小的数先移动到新数组中
                while (i<=mid&&j<=high){
                    if(a[i]<a[j]){
                        tmp[k++]=a[i++];
                    }else {
                        tmp[k++]=a[j++];
                    }
                }
                //把左边剩余的数移入数组
            while (i<=mid){
                tmp[k++]=a[i++];
            }
            //把右边剩余的数移入数组
            while(j<=high){
                tmp[k++]=a[j++];
            }
            //把新数组中的数覆盖原数组中的数
            for(int x=0;x<tmp.length;x++){
                a[x+low]=tmp[x];
            }
        }
        public static  int[] sort(int[] a,int low,int high){
            int mid = (low+high)/2;
            if(low <high){
                sort(a,low,mid);
                sort(a,mid+1,high);
                merge(a,low ,mid ,high);//左右归并
            }
            return  a;
        }
    public static void main(String[] args) {
        int [] a={1,4,5,6,2,3,5,1,5,65,3,23,12,33,44,66,33,22,21,14,15,31};
        sort(a,0,a.length-1);
        for (int i:a) {
            System.out.println(i);
        }
    }
}