Java版数据结构之八大排序算法_if(arr == null || low < 0 || low > high)什么意思

排序算法简介

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

对比

代码实现

冒泡排序

//冒泡排序
    public static void sort(int[] arr){
        if(arr==null||arr.length<=0){
            return;
        }
        for(int i=0;i<arr.length-1;i++){//控制比较轮数
            for(int j=0;j<arr.length-1-i;j++){//控制比较索引
                if(arr[j]>arr[j+1]){
                    int temp=-1;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

快速排序

//基于荷兰国旗的快速排序
    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 (left<more){
            if(arr[left]<temp){
                swap(arr,left++,++less);
            }else if(arr[left]>temp){
                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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

直接插入排序

//插入排序
    public static void sort(int[] arr){
        //判断输入参数合法性
        if(arr==null||arr.length<=0){
            return;
        }
        //从第二个元素开始逐个插入
        for(int i=1;i<arr.length;i++){
            //当比前面元素小
            if(arr[i]<arr[i-1]){
                //保存当前哨兵值
                int temp=arr[i];
                //将比哨兵大的值向后移一位
                int j;
                for(j=i-1;j>=0&&arr[j]>temp;j--){
                    arr[j+1]=arr[j];
                }
                //将哨兵放置
                arr[j+1]=temp;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

希尔排序

//希尔排序
    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++;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

简单选择排序

//选择排序
    public static void sort(int[] arr){
        if(arr==null||arr.length<=0){
            return;
        }
        for(int i=0;i<arr.length-1;i++){//控制哨兵位置
            for(int j=i+1;j<arr.length;j++){//控制比较索引
                if(arr[j]<arr[i]){
                    int temp=-1;
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

堆排序

//堆排序
    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<size&&arr[i]<arr[2*i+1]){
                swap(arr,i,2*i+1);
            }
            if(2*i+2<size&&arr[i]<arr[2*i+2]){
                swap(arr,i,2*i+2);
            }
            i--;
        }
    }

    //交换数组两个位置的元素
    private static void swap(int[] arr, int left, int right) {
        int temp;
        temp=arr[left];
        arr[left]=arr[right];
        arr[right]=temp;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

归并排序

//归并排序
    public static void mergwSort(int[] arr,int low,int high){
        if(arr==null||arr.length<=0){
            return;
        }
        //结束条件
        if(low<high){
            int mid=(low+high)/2;
            //递归调用左边
            mergwSort(arr,low,mid);
            //递归调用右边
            mergwSort(arr,mid+1,high);
            //左右归并
            merge(arr,low,mid,high);
        }
    }

    //数组归并操作
    private static void merge(int[] arr, int low, int mid, int high) {
        if(arr==null||arr.length<=0){
            return;
        }
        //归并数组
        int[] temp=new int[high-low+1];
        int i=low;
        int j=mid+1;
        int index=0;
        while (i<=mid&&j<=high){
            if(arr[i]<arr[j]){
                temp[index]=arr[i];
                i++;
                index++;
            }
            if(arr[j]<arr[i]){
                temp[index]=arr[j];
                j++;
                index++;
            }
        }
        //处理剩余
        while (i<=mid){
            temp[index]=arr[i];
            i++;
            index++;
        }
        while (j<=high){
            temp[index]=arr[j];
            j++;
            index++;
        }
        //为数组赋值
        for(int k=0;k<temp.length;k++){
            arr[k+low]=temp[k];
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

基数排序

//基数排序
    private static void radixSort(int[] arr) {
        if(arr==null||arr.length<=0){
            return;
        }
        //取出最大值
        int max=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                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<len;j++){
            //按各位数字存储
            for(int k=0;k<arr.length;k++){
                int pos=arr[k]/n%10;
                temp[pos][counts[pos]]=arr[k];
                counts[pos]++;
            }
            //将分组结果赋值给原数组，继续下一轮
            int loa=0;
            for(int p=0;p<10;p++){
                for(int m=0;m<counts[p];m++){
                    arr[loa]=temp[p][m];
                    loa++;
                }
                counts[p]=0;//恢复0，以免影响下一轮
            }
            n*=10;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37