几种排序算法即原理实现

冒泡排序

是计算机科学领域的比较简单的排序算法
1.比较相邻的元素，如果前一个元素比后一个元素大，就交换这两个元素的位置
2.对每一对相邻元素做同样的工作，从开始第一对元素到最后一个元素，最终最后位置的元素就是最大值

public class bubble {
    public static void main(String[] args) {
        Integer [] a={6,1,3,4,5,2};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    public static void sort(Comparable [] a){
        for(int i=a.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                if(greater(a[j],a[j+1])){
                    exch(a,j,j+1);

                }            }
        }
    }
    private static boolean greater(Comparable a,Comparable b){
       return a.compareTo(b)>0;
    }
    private static void exch(Comparable [] a,int b,int c){
        Comparable temp;
        temp=a[b];
        a[b]=a[c];
        a[c]=temp;

    }
}

插入排序

排序的原理
1.把所有的元素分为两组，已经排序的和没有排序的
2.找到未排序组中的第一个元素，向已经排序的组中进行插入
3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入的元素，那么就把待插入元素放到这个位置，其他元素向后移动一位
同样通过比较和换位置来进行插入
示例代码如下

public class test {
    public static void main(String[] args) {
        Comparable []a={4,8,9,5,2,1};
        InsertionSort(a);
        System.out.println(Arrays.toString(a));

    }
    public static void InsertionSort(Comparable[] a){
        for(int i=1;i<a.length;i++){
            for(int j=i;j>0;j--){
                if(greater(a[j-1],a[j])){
                    exChange(a,j,j-1);
                }else{
                    break;
                }
            }
        }
    }
    public static  boolean greater(Comparable a,Comparable b){
        return a.compareTo(b)>0;
    }
    public static  void exChange(Comparable[] a,int b,int c){
        Comparable temp;
        temp=a[b];
        a[b]=a[c];
        a[c]=temp;

    }
}

选择排序

从待排序的数组元素中，选出最小的或者最大的放在序列的起始位置，直到排完了所有的数组元素。

    public static void main(String[] args) {
        Integer [] a={4,5,1,2,3};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    public static void sort(Comparable [] a){
        for(int i=0;i<=a.length-2;i++){
            int minindex=i;
            for(int j=i+1;j<a.length;j++){
                if(greater(a[minindex],a[j])){
                    minindex=j;
                }
            }
            exch(a,i,minindex);
        }    }
    private static  boolean  greater(Comparable a,Comparable b){
        return  a.compareTo(b)>0;
    }
    private  static  void exch(Comparable [] a,int b,int c){
        Comparable temp;
        temp=a[b];
        a[b]=a[c];
        a[c]=temp;
    }

希尔排序

希尔排序法介绍
希尔排序是希尔于1959年提出的一种排序算法，希尔排序也是一种插入排序，他是简单插入排序经过改进之后的一个更高效的版本，也被称为缩小增量排序。
希尔排序法基本思想
希尔排序是吧记录按下标的一定增量分组，对每组使用直接插入排序算法排序，随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
代码去实现的时候有两种方法
一个是交换式的另一个则是移动式的。
交换式相对来说较为繁琐，效率不一定比直接插入要高，因为要频繁的交换
代码如下

public class ShellSort {
    public static void main(String[] args) {
        int[] ints = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellsort(ints);
        System.out.println(Arrays.toString(ints));
        int[] ints1 = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort1(ints1);
        System.out.println(Arrays.toString(ints1));

    }
    //交换式
    //交换式的希尔排序并不能进行效率的优化，反而有可能比直接插入排序花费的时间更长
    public static void shellsort(int [] arr){
        for (int i = arr.length/2; i >=1 ; i=i/2) {
            for (int j = i; j <arr.length ; j++) {
                //遍历当前组内的所有元素
                for (int k = j-i;k>=0; k-=i) {
                    //判断并交换顺序
                    if(arr[k]>arr[k+i]){
                        int temp;
                        temp=arr[k];
                        arr[k]=arr[k+i];
                        arr[k+i]=temp;
                    }

                }
            }
        }
    }
    //移动法,结合直接插入排序去做
    public static  void shellSort1(int [] arr){
        for (int gap = arr.length/2; gap >0 ; gap/=2) {
            for (int i = gap; i <arr.length ; i++) {
                int j=i;
                int temp=arr[j];
                while (j-gap>=0 && temp<arr[j-gap]){
                    arr[j]=arr[j-gap];
                    j-=gap;
                }
                arr[j]=temp;
            }
        }
    }

}

快速排序

快速排序是对冒泡排序的一种改进
基本思想：通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都要比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以次达到整个数据变成有序序列。

public class QuickSort {
    public static void main(String[] args) {
//        int[] ints = new int[]{-9,78,0,23,-567,70};
        int [] ints=new int[]{1,6,4,4,5,2};
        quickSort(ints,0,ints.length-1);
        System.out.println(Arrays.toString(ints));
    }
    public static void quickSort(int[] arr,int left,int right){
        int l=left;
        int r=right;
        int pivot=arr[(left+right)/2];
        int temp=0;//临时变量，作为交换时使用
        while(r>l){
            //
            while(arr[l]<pivot){
                l+=1;
            }
            while(arr[r]>pivot){
                r-=1;
            }
            if(l>=r){
                break;
            }
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;
            //避免相同值一直死循环
            if(arr[l]==pivot){
                r-=1;
            }
            if(arr[r]==pivot){
                l+=1;
            }

        }
        //将数组分为左右两侧，递归进行快排
        if(l==r){
            l+=1;
            r-=1;
        }
        //向左递归
        if(left<r){
            quickSort(arr,left,r);
        }
        //向右递归
        if(right>l){
            quickSort(arr,l,right);
        }
    }
}

归并排序

归并排序(MERGF-SORT)是利用归并的思想实现的排序方法，该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案修补在一起，即分而治之)

package com.zrx.test.sort;

import java.util.Arrays;

public class MergetSort {
    public static void main(String[] args) {
        int [] arr={8,4,5,7,1,3,6,2};
        int [] temp=new int[arr.length];
        mergetSort(arr,0,arr.length-1,temp);
        System.out.println(Arrays.toString(arr));
    }
    public static void mergetSort(int [] arr,int left,int right,int [] temp){
        if(left<right){
            int mid=(left+right)/2;
            //向左递归进行分解
            mergetSort(arr,left,mid,temp);
            //向右递归进行分解
            mergetSort(arr,mid+1,right,temp);
            System.out.print(left);
            System.out.println(right);
            //合并
            merge(arr,left,mid,right,temp);

        }
    }
    public static void merge(int [] arr,int left,int  mid,int right,int [] temp){
        int i=left;//左边有序数列的索引
        int j=mid+1;//左边有序书列的索引
        int t=0;//指向中间数组的当前索引
        //先把左右两边的数据按规则填充到temp数组中
        //直到左右两边有一边处理完毕为止
        while(i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t]=arr[i];
                t+=1;
                i+=1;

            }else{
                temp[t]=arr[j];
                t+=1;
                j+=1;
            }
        }
        //哪边有剩余，将剩余的部分依次填充进temp数组中去
         while(i<=mid){
           temp[t]=arr[i];
           i+=1;
           t+=1;
        }
        while(j<=right){
            temp[t]=arr[j];
            j+=1;
            t+=1;
        }
        //将数组的元素从新拷贝进arr
        t=0;
        int tempLeft=left;
        while(tempLeft<=right){
            arr[tempLeft]=temp[t];
            t+=1;
            tempLeft+=1;
        }
    }
}

基数排序

基数排序
1.基数排序(radix Sort)属于分配式排序，又称桶子法，他是通过键值的各个位的值，将要排序的元素分配至某些桶中，达到排序的作用
2.基数排序法属于稳定的排序，基数排序法是效率高的稳定性排序法
3.基数排序法是桶排序的扩展
4.基数排序法是这样实现的：将整数位按照位数切割成不同的数字，然后按每个部位分别比较
基数排序的基本思想
将所有待比较数值统一为同样的数位长度，数位较短的数前边补零。然后。从最低位开始，依次进行一次排序，这样从最低为排序一直到最高位排序完成以后，数列就变成一个有序数列
基数排序的说明
1.基数排序是对传统桶排序的扩展，速度很快
2.基数排序是经典的空间换时间的方式，占用内存很大，当海量 数据排序时，容易造成内存溢出
3.基数排序是稳定的【假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序。这些记录的相对次序保持不变。】

package com.zrx.test.sort;


import java.util.Arrays;

public class radixSort {
    public static void main(String[] args) {
        int [] arr={53,3,542,748,14,214};
        radixsort(arr);
        System.out.println(Arrays.toString(arr));
        //速度测试
        long l = System.currentTimeMillis();
        int [] arrs=new int[80000000];
        for (int i = 0; i <80000000 ; i++) {
            arrs[i]=(int)(Math.random()*80000000);
        }
        long l1 = System.currentTimeMillis();
        long time=(l1-l)/1000;
        System.out.println("time:(s)"+(l- l1));

    }
    //基数排序算法
    public static void radixsort(int [] arr){
        //得到数组中最大数的位数
        int max=arr[0];
        for (int i = 1; i <arr.length ; i++) {
            if(arr[i]>max){
                max=arr[i];
            }
        }
        int maxLength=(max+"").length();
        //定义10个桶0-9每个桶就是一个一维数组
        //二维数组包含10个1维数组
        //一维数组为了防止数据溢出  数组大小为arr.length
        //很明确的是基数排序是用空间换时间的经典算法
        int [][] bucket=new int[10][arr.length];
        //为了记录每个桶中实际存放了多少个数据，我们定义一个一维数组记录各个桶每次放入的数据个数
        int [] bucketElementCounts=new int[10];
        for (int k = 0,n=1; k <maxLength ; k++,n=n*10) {
            for (int i = 0; i <arr.length ; i++) {
                //取出每个元素个位数的值
                int digitOfElement=arr[i]/n%10;
                //放入对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[i];
                bucketElementCounts[digitOfElement]++;
            }
            //按照桶的顺序将数放回数组
            int index=0;
            for (int i = 0; i <bucketElementCounts.length ; i++) {
                if(bucketElementCounts[i]!=0){
                    for (int j = 0; j <bucketElementCounts[i]; j++) {
                        arr[index]=bucket[i][j];
                        index++;
                    }
                }
                bucketElementCounts[i]=0;
            }
        }
    }
}

堆排序

在顺序存储二叉树的基础上
通过将数组对应的二叉树调整成大顶堆或者小顶堆的方式来实现从小到大或者从大到小的排序。
在这里就不过多的赘述实现原理
代码如下

package com.cxf;

import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args) {
        int [] arr={3,4,7,2,1,9,8};
//        for (int i = 0; i <arr.length ; i++) {
//            System.out.println(arr[i]);
//        }
        System.out.println("排序之前");
        System.out.println(Arrays.toString(arr));
        heapSort(arr);
        System.out.println("排序之后");
        System.out.println(Arrays.toString(arr));
    }
    public static void heapSort(int [] arr){
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }
    }

    /**
     * 功能：完成将以i对应的非叶子节点的树调整成大顶堆
     * 举例：int arr[]={4,6,8,5,9};=>i=1=>adjustHeap=>得到{4，9，8，5，6}
     * 如果我们再次调整adjustHeap 传入的是i=0=》得到{4，9，8，5，6}=》{9，6，8，5，4}
     * @param arr 待调整的数组
     * @param i   i表示非叶子节点在数组中索引
     * @param length   表示对多少个元素继续调整，length 是在逐渐的较少
     */
    public static void adjustHeap(int [] arr,int i,int length){
        int temp = arr[i];//先取出当前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;//为什么不直接进行值传递？ 因为是从右到左，从下到上的进行判断，在调整到上边的非叶子节点时，可能会对下边已经调整好的子树进行改变，就通过这个来进行调整
            }else{
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置

    }
    /**
     * 交换元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

}