Java版数据结构之八大排序算法

排序算法简介

• 交换排序：冒泡排序、快速排序
• 插入排序：直接插入排序、希尔排序
• 选择排序：简单选择排序、堆排序
• 归并排序
• 基数排序

对比

代码实现

冒泡排序

//冒泡排序
    public static void sort(int[] arr){
        if(arr==null||arr.length<=0){
            return;
        }
        for(int i=0;iarr[j+1]){
                    int temp=-1;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

快速排序

//基于荷兰国旗的快速排序
    public static void quickSort(int[] arr,int start,int end){
        if(arr==null||arr.length<=0){
            return;
        }
        if(start>=end){
            return;
        }
        int left=start;
        int less=start-1;
        int more=end+1;
        int index= (int) (Math.random()*(end-start+1)+start);
        int temp=arr[index];
        while (lefttemp){
                swap(arr,left,--more);
            }else {
                left++;
            }
        }
        quickSort(arr,start,less);
        quickSort(arr,more,end);
    }

    //交换数组中两个元素
    private static void swap(int[] arr, int left, int right) {
        int temp;
        temp=arr[left];
        arr[left]=arr[right];
        arr[right]=temp;
    }

直接插入排序

//插入排序
    public static void sort(int[] arr){
        //判断输入参数合法性
        if(arr==null||arr.length<=0){
            return;
        }
        //从第二个元素开始逐个插入
        for(int i=1;i=0&&arr[j]>temp;j--){
                    arr[j+1]=arr[j];
                }
                //将哨兵放置
                arr[j+1]=temp;
            }
        }
    }

希尔排序

//希尔排序
    public static void shellSort(int[] arr){
        if(arr==null||arr.length<=0){
            return;
        }
        int k = 1;
        // 遍历所有的步长
        for (int d = arr.length / 2; d > 0; d /= 2) {
            // 遍历所有有元素
            for (int i = d; i < arr.length; i++) {
                // 遍历本组中所有的元素
                for (int j = i - d; j >= 0; j -= d) {
                    // 如果当前元素大于加上步长后的那个元素
                    if (arr[j] > arr[j + d]) {
                        int temp = arr[j];
                        arr[j] = arr[j + d];
                        arr[j + d] = temp;
                    }
                }
            }
            System.out.println("第" + k + "次排序结果：" + Arrays.toString(arr));
            k++;
        }
    }

简单选择排序

//选择排序
    public static void sort(int[] arr){
        if(arr==null||arr.length<=0){
            return;
        }
        for(int i=0;i

堆排序

//堆排序
    public static void heapsort(int[] arr){
        if(arr==null||arr.length<=0){
            return;
        }
        int size=arr.length;
        heapiFy(arr,size);
        while(size>0){
            swap(arr,0,--size);
            heapiFy(arr,size);
        }
    }

    //调整大根堆
    public static void heapiFy(int[] arr,int size){
        if(arr==null||arr.length<=0){
            return;
        }
        int i=size/2-1;
        while(i>=0){
            if(2*i+1

归并排序

//归并排序
    public static void mergwSort(int[] arr,int low,int high){
        if(arr==null||arr.length<=0){
            return;
        }
        //结束条件
        if(low

基数排序

//基数排序
    private static void radixSort(int[] arr) {
        if(arr==null||arr.length<=0){
            return;
        }
        //取出最大值
        int max=0;
        for(int i=0;imax){
                max=arr[i];
            }
        }
        //获取循环次数
        int len=(max+"").length();
        //循环按各位数字排序
        int n=1;//辅助变量计算数字
        int[][] temp=new int[10][arr.length];//保存数字的数组
        int[] counts=new int[10];//保存各数组存储数据个数
        for(int j=0;j