十大排序算法

冒泡排序

package sort;

import java.util.Arrays;

/*冒泡排序*/
//1、判断arr不符合的情况，直接返回null,如arr==null或者arr的长度=0
//2、定义一个boolean变量swap，可以加快效率，当在遍历的时候没有元素发生交换，则直接返回结果
//3、两层遍历：
    //（1）i代表走的趟数，2个2个比较，所以只要走n-1次就可以了
    //（2）j=i+1,相当于i的后一位，i之前的已经冒泡出去了
    // (3)如果数组中arr[j]比较小，则让他与arr[i]互换，相当于把元素值比较大的值往后移动，相当于泡泡一样，越大的泡泡先上去。
//时间复杂度 O(n)~O(n^2)： 因为存在两层循环
//空间复杂度:O(1)
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr={10,21,4,62,7,2};
        int[] res = bubbleSort(arr);
        System.out.println(Arrays.toString(res));
    }

    public static int[] bubbleSort(int[] arr){
        if (arr==null||arr.length==0){
            return arr;
        }
        int n=arr.length;
        boolean swap;
        for (int i = 0; i < n-1; i++) {
            swap=false;
            for (int j = i+1; j <n ; j++) {
                if(arr[j]<arr[i]){
                    int temp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=temp;
                    swap=true;
                }
            }
            if(!swap)
                return arr;
        }
        return arr;
    }
}

选择排序

package sort;

import java.util.Arrays;

/*选择排序*/
public class SelectSort {
    public static void main(String[] args) {
        int[] arr={2,3,6,2,1,1,12,7};
        int[] res = selectSort(arr);
        System.out.println(Arrays.toString(res));
    }

    public static int[] selectSort(int[] arr){
        int n=arr.length;
        if(arr==null||n<=1)
            return arr;
        for (int i = 0; i < n-1; i++) {
            int min=i;
            for (int j = i+1; j < n; j++) {
                if(arr[min]>arr[j])
                    min=j;
            }
            int temp=arr[i];
            arr[i]=arr[min];
            arr[min]=temp;
        }
        return arr;
    }
}

插入排序

package sort;

import java.util.Arrays;

/*插入排序*/
public class InsertSort {
    public static void main(String[] args) {
        int[] arr={12,7,6,2,1};
        int[] res = insertSort(arr);
        System.out.println(Arrays.toString(res));
    }

    public static int[] insertSort(int[] arr){
        if(arr==null||arr.length<2)
            return arr;
        int n=arr.length;
        for (int i = 1; i <n; i++) {
            int temp=arr[i];
            int k=i-1;
            //大于temp时，k--
            while(k>=0&&temp<=arr[k]){
                k--;
            }
            //后移
            for (int j = i; j >k+1; j--) {
                arr[j]=arr[j-1];
            }
            arr[k+1]=temp;
        }
        return arr;
    }
}

快速排序

package sort;

import java.util.Arrays;

/*快速排序*/
public class QuickSort {

    public static void main(String[] args) {
        int[] arr={12,3,5,7,1,2};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }

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

    private static void quickSort(int[] arr,int low,int high){
        if(low>=high) return;
        int pivot=partition(arr,low,high);
        quickSort(arr,low,pivot-1);
        quickSort(arr,pivot+1,high);
    }

    private static int partition(int[] arr,int low,int high){
        int pivot=arr[low];
        while(low<high){
            while(low<high&&arr[high]>=pivot){
                high--;
            }
            arr[low]=high;
            while(low<high&&arr[low]<=pivot){
                low++;
            }
            arr[high]=arr[low];
        }
        arr[low]=pivot;
        return low;
    }
}

希尔排序

package sort;

import java.util.Arrays;

/*希尔排序*/
public class ShellSort {
    public static void main(String[] args)
    {
        int[] ins = {2,3,5,1,23,6,78,34,23,4,5,78,34,65,32,65,76,32,76,1,9};
        int[] res = shellSort(ins);
        System.out.println(Arrays.toString(res));
    }
    public static int[] shellSort(int[] arr){
        int n=arr.length;
        int gap=n/2;
        while(gap>0){
            for (int i = gap; i <n ; i++) {
                int j=i;
                while(j>=gap&&arr[j-gap]>arr[j]){
                    int temp=arr[j];
                    arr[j]=arr[j-gap];
                    arr[j-gap]=temp;
                    j-=gap;
                }
            }
            gap/=2;
        }
        return arr;
    }
}

计数排序

package sort;

import java.util.Arrays;

/*计数排序*/
public class CountSort {
    public static void main(String[] args) {
        int[] array = new int[] {95,94,91,98,99,90,99,93,91,92};
        int[] sortedArray = countSort(array);
        System.out.println(Arrays.toString(sortedArray));
    }

    public static int[] countSort(int[] arr){
        int n=arr.length;
        //求出最大值和最小值，求出差值
        int min=Integer.MAX_VALUE;
        int max=Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            if(arr[i]>max)
                max=arr[i];
            if(arr[i]<min)
                min=arr[i];
        }
        int d=max-min;

        //新建一个统计数组，并赋值
        int[] countArray=new int[d+1];
        for (int i = 0; i <n ; i++) {
            countArray[arr[i]-min]++;
        }

        //统计数组数值累加，表示排名
        int sum=0;
        for (int i = 0; i < countArray.length; i++) {
            sum+=countArray[i];
            countArray[i]=sum;
        }

        //新建排序后的数组，将统计数组的值倒叙加入排序后的数组，返回数组
        int[] sortedArray=new int[n];
        for (int i = arr.length-1 ; i >= 0; i--) {
            sortedArray[countArray[arr[i]-min]-1]=arr[i];
            countArray[arr[i]-min]--;
        }
        return sortedArray;
    }
}

堆排序

package sort;

import java.util.Arrays;

/*堆排序*/
public class HeapSort {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 5,2, 0,10,6};
        arr = heapSort(arr, arr.length);
        System.out.println(Arrays.toString(arr));
    }

    //堆下沉
    private static int[] downAdjust(int[] arr,int parent,int length){
        int temp=arr[parent];
        int child=2*parent+1; //左孩子结点，规律
        while(child<length){
            if(child+1<length&&arr[child]>arr[child+1]){
                child++;
            }
            if(temp<=arr[child])
                break;
            arr[parent]=arr[child];
            parent=child;
            child=2*parent+1;
        }
        arr[parent]=temp;
        return arr;
    }

    //堆排序
    public static int[] heapSort(int[] arr,int length){
        //构建堆:从最后一个非叶子开始
        //(length-2)/2表示最后一个非叶子结点
        for (int i = (length-2)/2; i >=0;i--) {
            arr=downAdjust(arr,i,length);
        }
        //堆排序，最后的元素与顶元素互换,之后顶元素再进行下沉,长度为i，互换过的就不需要再遍历
        for (int i = length-1; i >=1 ; i--) {
            int temp=arr[i];
            arr[i]=arr[0];
            arr[0]=temp;
            arr=downAdjust(arr,0,i);
        }
        return arr;
    }
}

桶排序

package sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;

/*桶排序*/
public class BucketSort {
    public static void main(String[] args) {
        double[] array = new double[] {4.12,6.421,0.0023,3.0,2.123,8.122,4.12, 10.09};
        double[] sortedArray = bucketSort(array);
        System.out.println(Arrays.toString(sortedArray));
    }

    public static double[] bucketSort(double[] arr){
        //求最大值最小值，差值
        double max=arr[0];
        double min=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max)
                max=arr[i];
            if(arr[i]<min)
                min=arr[i];
        }
        double d=max-min;

        //新建一个数组<链表>桶临时存放,初始化
        int bucketNum=arr.length;
        ArrayList<LinkedList<Double>> bucketList=new ArrayList<LinkedList<Double>>(bucketNum);
        for (int i = 0; i < bucketNum; i++) {
            bucketList.add(new LinkedList<Double>());
        }
        //将元素放进桶内
        for (int i = 0; i < arr.length; i++) {
            int num=(int)((arr[i]-min)/(d/(bucketNum-1)));
            bucketList.get(num).add(arr[i]);
        }
        //桶内需要进行排序
        for (int i = 0; i < bucketList.size(); i++) {
            Collections.sort(bucketList.get(i));
        }

        //新建排序后的数组
        double[] sortedArray=new double[arr.length];
        int index=0;
        for(LinkedList<Double> list:bucketList){
            for(double element:list){
                sortedArray[index++]=element;
            }
        }
        return sortedArray;
    }
}

归并排序

package sort;

import java.util.Arrays;

/*归并排序*/
public class InternalMergeSort {
    public static void main(String[] args) {
        int[] arr={12,1,7,2,3,8};
        intervalMergeSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void intervalMergeSort(int[] arr){
        int[] temp=new int[arr.length];
        intervalMergeSort(arr,temp,0,arr.length-1);
    }

    //分与合
    private static void intervalMergeSort(int[] arr,int[] temp,int left,int right){
        if(left<right){
            int mid=(left+right)/2;
            intervalMergeSort(arr,temp,left,mid);
            intervalMergeSort(arr,temp,mid+1,right);
            mergeSortedArray(arr,temp,left,mid,right);
        }
    }

    //合
    private static void mergeSortedArray(int[] arr,int[] temp,int left,int mid,int right){{
        //将arr分为两边，然后比较两边
        int i=left;
        int j=mid+1;
        int k=0;
        //左边和右边都存在
        while(i<=mid&&j<=right){
            temp[k++]=arr[i]<arr[j]?arr[i++]:arr[j++];
        }
        //只有一边存在
        while(i<=mid){
            temp[k++]=arr[i++];
        }
        while(j<=right){
            temp[k++]=arr[j++];
        }
        //将临时数组复制回原数组
        for (int l = 0; l < k; l++) {
            arr[left+l]=temp[l];
        }
    }

    }


}

基数排序

package sort;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;


public class RadixSort {
    public static void main(String[] args) {
        int[] arr={12,7,6,2,1,22,23,611};
        int[] res = radixSort(arr);
        System.out.println(Arrays.toString(res));
    }

    public static int[] radixSort(int[] arr) {
        //特殊情况
        if(arr == null || arr.length < 2) return arr;

        int n = arr.length;
        int max = arr[0];
        // 找出最大值
        for (int i = 1; i < n; i++) {
            if(max < arr[i]) max = arr[i];
        }

        // 计算最大值是几位数
        int num = 1;
        while (max / 10 > 0) {
            num++;
            max = max / 10;
        }

        // 创建10个桶
        ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(10);

        //初始化桶
        for (int i = 0; i < 10; i++) {
            bucketList.add(new LinkedList<Integer>());
        }

        // 进行每一趟的排序，从个位数开始排
        for (int i = 1; i <= num; i++) {
            for (int j = 0; j < n; j++) {
                // 获取每个数最后第 i 位是数组
                //pow(10,i-1)表示10的几次方
                int radio = (arr[j] / (int)Math.pow(10,i-1)) % 10;
                //放进对应的桶里
                bucketList.get(radio).add(arr[j]);
            }

            //合并放回原数组
            int k = 0;
            for (int j = 0; j < 10; j++) {
                for (Integer t : bucketList.get(j)) {
                    arr[k++] = t;
                }
                //取出来合并了之后把桶清光数据
                bucketList.get(j).clear();
            }
        }

        return arr;
    }
}