码迷,mamicode.com
首页 > 编程语言 > 详细

常用排序算法及Java实现

时间:2018-07-09 19:50:47      阅读:179      评论:0      收藏:0      [点我收藏+]

标签:begin   使用   lis   冒泡排序   之间   依赖   数字   end   简单选择排序   

排序算法,可以分为内部排序和外部排序两大种。这篇文章主要对内部排序进行介绍。内部排序又分为两类,基于比较的非线性时间类,和非比较的线性时间类。前一类又可以分为四种,交换排序(包括冒泡排序和快速排序),插入排序(包括简单插入排序和希尔排序),选择排序(包括简单选择排序和堆排序)以及归并排序;后者主要包含三种,计数排序,桶排序和基数排序。

总体来说,快排、堆排和归并排序是非线性时间中最快的三种。一般认为,快排的时间效率会比堆排更好。另一方面,快排和堆排都是不稳定的算法,只有归并排序、冒泡排序和插入排序是稳定的算法,因此Java中的sort算法在实现的时候,有一个阈值,大概是60左右。数组长度低于这个阈值的,直接使用插入排序;高于这个阈值的,如果元素是基本数据类型,救使用快排,如果是引用数据类型,就使用归并排序。而对于基于比较的排序算法,都很依赖于数据本身的分布——在数据均匀分布的情况下,效率可以很高。计数排序是用来排序0到100之间的数字的最好的算法,但是它不适合按字母顺序排序人名;计数排序则要求对每一位使用的排序算法都是稳定的。

下面我们对这九种算法进行详细的介绍。为了方便,我们设定所有的排序都基于整形数组,需要按照从小到大的顺序进行排列。在这些排序算法中,有一些公用的操作,比如元素交换,元素打印,寻找最大值最小值等,为了代码的复用,我们定义了工具类Tools,首先给出Tools类的代码。

 1 public class Tools {
 2     public static void swap(int[] arr, int i, int j) {
 3         int tmp = arr[i];
 4         arr[i] = arr[j];
 5         arr[j] = tmp;
 6     }
 7 
 8     public static void printArray(int[] arr) {
 9         int i = 0;
10         System.out.print("[");
11         for (; i < arr.length - 1; i++) {
12             System.out.print(arr[i] + ",");
13         }
14         System.out.println(arr[i] + "]");
15     }
16 
17     public static int findMax(int[] arr) {
18         int max = Integer.MIN_VALUE;
19         for (int num : arr) {
20             max = Math.max(max, num);
21         }
22         return max;
23     }
24 
25     public static int findMin(int[] arr) {
26         int min = Integer.MAX_VALUE;
27         for (int num : arr) {
28             min = Math.min(min, num);
29         }
30         return min;
31     }
32 }

 

1、交换算法

1.1 冒泡算法

整体思路:第i轮排序,从第0号元素到第(length-1-i)号元素,进行相邻元素的比较,并将较大的元素不断交换到后一位置。

特点:第i轮排序完成后,第i个最大值出现在下标为(length-1-i)的位置。

时间复杂度:最坏:O(n^2),平均:O(n^2),最好:O(n);

空间复杂度:O(1)

稳定性:稳定,但是当条件变为arr[j] >= arr[j + 1]时,就不稳定了

Java实现:

 1 /**
 2  *  3  *
 4  *         以整型数组为例,通过冒泡排序将数组中的元素按从小到大的顺序进行排列
 5  *         思路:第i轮排序,从第0号元素到第(length-1-i)号元素,进行相邻元素的比较,并将较大的元素交换到后一位置。
 6  *         特点:第i轮排序结束后,第i个最大值出现在下标为(length-1-i)的位置
 7  *         时间复杂度:最坏:O(n^2),平均:O(n^2),最好:O(n);
 8  *         空间复杂度:O(1)
 9  *         稳定性:稳定,但是当条件变为arr[j] >= arr[j + 1]时,就不稳定了
10  */
11 public class BubbleSort {
12     public static void bubbleSort(int[] arr) {
13         for (int i = 0; i < arr.length - 1; i++) {
14             for (int j = 0; j < arr.length - 1 - i; j++) {
15                 if (arr[j] > arr[j + 1]) {
16                     Tools.swap(arr, j, j + 1);
17                 }
18             }
19         }
20     }
21 
22     public static void main(String[] args) {
23         int[] arr = { 5, 6, 8, 3, 2, 1, 9, 7, 2 };
24         System.out.println("before sorting:");
25         Tools.printArray(arr);
26         bubbleSort(arr);
27         System.out.println("after sorting:");
28         Tools.printArray(arr);
29     }
30 }

1.2 快速排序

整体思路:通过递归的方式,不断将数组分为两部分,主元左边的都比主元小,右边的都比主元大。特点:每一轮的排序结束后,数组中的某一部分就会成为有序的序列。

时间复杂度:最坏O(n^2),平均O(nlog2n),最好O(nlog2n)。

空间复杂度:O(nlog2n),主要是由于递归调用造成的栈内存的使用。

稳定性:不稳定。

在每一轮的排序过程中,注意首先从右往左进行查找;在跳出循环后,将low索引指向的位置作为主元交换的位置。

Java实现:

 1 /**
 2  *  3  *
 4  *         以整型数组为例,通过快速排序将数组中的元素按从小到大的顺序进行排列
 5  *         思路:通过递归的方式,不断将数组分为两部分,主元左边的都比主元小,右边的都比主元大。
 6  *         特点:每一轮的排序结束后,数组中的某一部分就会成为有序的序列。
 7  *         时间复杂度:最坏O(n^2),平均O(nlog2n),最好O(nlog2n)
 8  *         空间复杂度:O(nlog2n),主要是由于递归调用造成的栈内存的使用
 9  *         稳定性:不稳定
10  *         
11  *         在每一轮的排序过程中,注意首先从右往左进行查找;在跳出循环后,将low索引指向的位置作为主元交换的位置
12  *         
13  */
14 public class QuickSort {
15     public static void quickSort(int[] arr, int first, int last) {
16         if (last < first) {
17             return;
18         }
19         int low = first;
20         int high = last;
21         int pivot = arr[first];
22         while (high > low) {
23             while (high > low && arr[high] >= pivot)
24                 high--;
25             while (high > low && arr[low] <= pivot)
26                 low++;
27             if (high > low) {
28                 Tools.swap(arr, low, high);
29             }
30         }
31 
32         Tools.swap(arr, first, low);
33         quickSort(arr, first, low - 1);
34         quickSort(arr, low + 1, last);
35     }
36 
37     public static void quickSort(int[] arr) {
38         quickSort(arr, 0, arr.length - 1);
39     }
40 
41     public static void main(String[] args) {
42         int[] arr = { 1, 5, 6, 8, 3, 2, 1, 9, 7, 2, 1, 1 };
43         //        int[] arr = { 5, 6, 8, 3, 2, 1, 9, 7, 2 };
44         System.out.println("before sorting:");
45         Tools.printArray(arr);
46         quickSort(arr);
47         System.out.println("after sorting:");
48         Tools.printArray(arr);
49     }
50 }

 

2. 选择排序

2.1 简单选择排序

整体思路:第i轮排序,找到第i个最小值,将其交换到下标为i的位置。

特点:第i轮排序结束后,第i个最小值出现在下标为i的位置。

 

时间复杂度:三种情况都是O(n^2)。

空间复杂度:O(1)。

稳定性:不稳定

在每一轮选择最小元素的过程中,可以在每次符合条件时都进行换位,也可以将这一轮中最小值的索引记下来,这一轮结束时进行一次换位。这样减少了在堆内存中的操作,更加高效。

Java实现:

 1 /**
 2  * @author hr
 3  * 
 4  *         以整型数组为例,通过选择排序将数组中的元素按从小到大的顺序进行排列 
 5  *         思路:第i轮排序,找到第i个最小值,将其交换到下标为i的位置。
 6  *         特点:第i轮排序结束后,第i个最小值出现在下标为i的位置
 7  *         
 8  *         在每一轮选择最小元素的过程中,可以在每次符合条件时都进行换位,也可以将这一轮中最小值的
 9  *         索引记下来,这一轮结束时进行一次换位。这样减少了在堆内存中的操作,更加高效。
10  *         时间复杂度:三种情况都是O(n^2)
11  *         空间复杂度:O(1)
12  *         稳定性:不稳定
13  *         
14  */
15 public class SelectionSort {
16     public static void selectionSort(int[] arr) {
17         for (int i = 0; i < arr.length - 1; i++) {
18             int minIndex = i;
19             for (int j = i + 1; j < arr.length; j++) {
20                 if (arr[j] < arr[minIndex])
21                     minIndex = j;
22             }
23             if (minIndex != i)
24                 Tools.swap(arr, i, minIndex);
25         }
26     }
27 
28     public static void main(String[] args) {
29         int[] arr = { 5, 6, 8, 3, 2, 1, 9, 7, 2 };
30         System.out.println("before sorting:");
31         Tools.printArray(arr);
32         selectionSort(arr);
33         System.out.println("after sorting:");
34         Tools.printArray(arr);
35     }
36 }

2.2 堆排序

整体思路:首先,将给定的数组建立起一个大顶堆,这也意味着找到了最大的元素;然后,将最大的元素换到堆的末尾(也就是数组的末尾),将剩下的元素重新建立起一个大顶堆,不断找到剩余元素中的最大值。

特点:第i轮排序结束后,第i个最大值出现在下标为length - i的位置 。

时间复杂度:三种情况都是O(nlog2n)。

空间复杂度:O(1)。

稳定性:不稳定。

在最开始建立大顶堆时,只需要遍历前半部分数组即可,初始的循环遍历条件设为(length - 1) / 2,直到0为止。随后每次找最大值,也是从后面的元素开始向上遍历。而对大顶堆进行调整的时候,则是从给定的元素开始不断向下进行调整。每次对堆进行调整的循环停止条件为:当前节点不存在左孩子节点,或者当前节点值已经是三个节点中的最大值了。

Java实现:

/**
 * @author hr
 * 
 *         以整型数组为例,通过堆排序将数组中的元素按从小到大的顺序进行排列 
 *         思路:首先,将给定的数组建立起一个大顶堆,这也意味着找到了最大的元素;然后,将最大的元素换到堆的末尾
 *         (也就是数组的末尾),将剩下的元素重新建立起一个大顶堆,不断找到剩余元素中的最大值。
 *         特点:第i轮排序结束后,第i个最大值出现在下标为length - i的位置
 *         
 *         在最开始建立大顶堆时,只需要遍历前半部分数组即可,初始的循环遍历条件设为(length - 1) / 2,直到0为止
 *         随后每次找最大值,也是从后面的元素开始向上遍历。
 *         而对大顶堆进行调整的时候,则是从给定的元素开始不断向下进行调整。
 *         时间复杂度:三种情况都是O(nlog2n)
 *         空间复杂度:O(1)
 *         稳定性:不稳定
 *         
 */
public class HeapSort {
    private static void heapify(int[] arr, int index, int heapSize) {
        int left = 2 * index + 1;
        int right = 2 * index + 2;
        int largest = index;
        while (left < heapSize) {
            if (arr[left] > arr[largest])
                largest = left;
            if (right < heapSize && arr[right] > arr[index])
                largest = right;
            if (index != largest) {
                Tools.swap(arr, index, largest);
                index = largest;
                left = 2 * index + 1;
                right = 2 * index + 2;
            } else
                break;
        }
    }

    public static void buildHeap(int[] arr) {
        for (int i = (arr.length - 1) / 2; i >= 0; i--) {
            heapify(arr, i, arr.length);
        }
    }

    public static void heapSort(int[] arr) {
        buildHeap(arr);
        for (int i = arr.length - 1; i >= 0; i--) {
            Tools.swap(arr, 0, i);
            heapify(arr, 0, i);
        }
    }

    public static void main(String[] args) {
        int[] arr = { 5, 6, 8, 3, 2, 1, 9, 7, 2 };
        System.out.println("before sorting:");
        Tools.printArray(arr);
        heapSort(arr);
        System.out.println("after sorting:");
        Tools.printArray(arr);
    }

}

3. 插入排序

 3.1 简单插入排序

整体思路:

第i轮排序,是将第i号元素插入由0,1,2...(i-1)号元素组成的有序表中。

特点:第i轮排序结束后,由0,1,2...i号元素组成的序列是有序的。

时间复杂度:最坏(数组是反序的)O(n^2),平均O(n^2),最好(数组本身就是正序的)O(n)。

空间复杂度:O(1)。

稳定性:稳定。

由于第i个元素之前都是有序的,因此在插入第i个元素的时候,可以从前往后遍历,找到合适的位置就停止。

Java实现:

 1 /**
 2  * @author hr
 3  *
 4  *         以整型数组为例,通过插入排序将数组中的元素按从小到大的顺序进行排列
 5  *         思路:第i轮排序,是将第i号元素插入由0,1,2...(i-1)号元素组成的有序表中
 6  *         特点:第i轮排序结束后,由0,1,2...i号元素组成的序列是有序的
 7  *         时间复杂度:最坏(数组是反序的)O(n^2),平均O(n^2),最好(数组本身就是正序的)O(n)
 8  *         空间复杂度:O(1)
 9  *         稳定性:稳定
10  *         
11  *         由于第i个元素之前都是有序的,因此在插入第i个元素的时候,可以从前往后遍历,
12  *         找到合适的位置就停止
13  */
14 public class InsertionSort {
15     public static void insertionSort(int[] arr) {
16         for (int i = 1; i < arr.length; i++) {
17             int curNum = arr[i];
18             int j;
19             for (j = i - 1; j >= 0 && arr[j] > curNum; j--) {
20                 arr[j + 1] = arr[j];
21             }
22             arr[j + 1] = curNum;
23         }
24     }
25 
26     public static void main(String[] args) {
27         int[] arr = { 5, 6, 8, 3, 2, 1, 9, 7, 2 };
28         System.out.println("before sorting:");
29         Tools.printArray(arr);
30         insertionSort(arr);
31         System.out.println("after sorting:");
32         Tools.printArray(arr);
33     }
34 }

3.2 希尔排序

整体思路:初始将数组均分为gap组,所有下标之差为gap的元素在同一组内,然后对每一组进行插入排序;最后不断调整gap的值进行循环,直到gap为0。 

时间复杂度:最坏O(n^2),平均O(n^1.3),最好O(n)。

空间复杂度:O(1)。

稳定性:不稳定。

实际实现的时候,并不是一组插入排序结束之后再进行另外一组,而是每一组交叉进行。

Java实现:

 1 /**
 2  * @author hr
 3  * 
 4  *         以整型数组为例,通过希尔排序将数组中的元素按从小到大的顺序进行排列 
 5  *         思路:初始将数组均分为gap组,所有下标之差为gap的元素在同一组内,然后对每一组进行插入排序;
 6  *         最后不断调整gap的值进行循环。
 7  *        
 8  *         
 9  *         实际实现的时候,并不是一组插入排序结束之后再进行另外一组,而是每一组交叉进行
10  *         时间复杂度:最坏O(n^2),平均O(n^1.3),最好O(n)
11  *         空间复杂度:O(1)
12  *         稳定性:不稳定
13  *         
14  */
15 
16 public class ShellSort {
17     public static void ShellSort(int[] arr) {
18         for (int gap = arr.length / 2; gap > 0; gap /= 2) {
19             for (int i = gap; i < arr.length; i++) {
20                 for (int j = i - gap; j >= 0; j -= gap) {
21                     if (arr[j] > arr[j + gap]) {
22                         Tools.swap(arr, j, j + gap);
23                     }
24                 }
25             }
26         }
27     }
28 
29     public static void main(String[] args) {
30         int[] arr = { 5, 6, 8, 3, 2, 1, 9, 7, 2 };
31         System.out.println("before sorting:");
32         Tools.printArray(arr);
33         ShellSort(arr);
34         System.out.println("after sorting:");
35         Tools.printArray(arr);
36     }
37 }

4. 归并排序

整体思路:归并排序采用的是分治法。首先不断将数组分为左右两部分,直到每部分都只包含一个元素为止。然后对所有的子序列两两合并,最终得到有序序列。

时间复杂度:最坏O(nlog2n),平均O(nlog2n),最好O(nlog2n)。

空间复杂度:O(n)。

稳定性:稳定。

Java实现:

 1 /**
 2  * @author hr
 3  * 
 4  *         以整型数组为例,通过归并排序将数组中的元素按从小到大的顺序进行排列 
 5  *         思路:归并排序采用的是分治法。首先不断将数组分为左右两部分,直到每部分都只包含一个元素为止。
 6  *         然后对所有的子序列两两合并,最终得到有序序列。
 7  *        
 8  *         时间复杂度:最坏O(nlog2n),平均O(nlog2n),最好O(nlog2n)
 9  *         空间复杂度:O(n)
10  *         稳定性:稳定
11  *         
12  */
13 public class MergeSort {
14     //将arr[first~mid]和arr[mid~last]合并到tmp中
15     public static void mergeArray(int[] arr, int first, int mid, int last) {
16         int[] tmp = new int[last - first + 1];
17         int begin1 = first;
18         int begin2 = mid + 1;
19         int end1 = mid;
20         int end2 = last;
21         int k = 0;
22         while (begin1 <= end1 && begin2 <= end2) {
23             if (arr[begin1] < arr[begin2]) {
24                 tmp[k++] = arr[begin1++];
25             } else {
26                 tmp[k++] = arr[begin2++];
27             }
28         }
29         while (begin1 <= end1) {
30             tmp[k++] = arr[begin1++];
31         }
32         while (begin2 <= end2) {
33             tmp[k++] = arr[begin2++];
34         }
35         //将辅助数组tmp的数据写回arr
36         for (begin1 = 0; begin1 < k; begin1++) {
37             arr[first + begin1] = tmp[begin1];
38         }
39     }
40 
41     public static void mergeSort(int[] arr, int first, int last) {
42         if (last - first > 0) {
43             int mid = (last + first) / 2;
44             mergeSort(arr, first, mid);
45             mergeSort(arr, mid + 1, last);
46             mergeArray(arr, first, mid, last);
47         }
48     }
49 
50     public static void mergeSort(int[] arr) {
51         mergeSort(arr, 0, arr.length - 1);
52     }
53 
54     public static void main(String[] args) {
55         int[] arr = { 5, 6, 8, 3, 2, 1, 9, 7, 2 };
56         System.out.println("before sorting:");
57         Tools.printArray(arr);
58         mergeSort(arr);
59         System.out.println("after sorting:");
60         Tools.printArray(arr);
61     }
62 }

5.计数排序

整体思路:统计出数组中每个元素出现的次数,然后将元素按顺序填入就可得到有序序列。

时间复杂度:三种情况都是O(n + k)。

空间复杂度:O(n + k),k代表数组的宽度。

稳定性:稳定。

在统计每个元素出现的次数时,首先找到数组的宽度(数组最大值和最小值之差再加一),这样,统计数组中的下标就和元素值联系在一起(相差为min)。得到统计值之后,统计数组中的下标可以找到原数组中对应的元素,统计数组的元素值代表原数组对应元素的出现次数

Java实现:

 1 /**
 2  * @author hr
 3  * 
 4  *         以整型数组为例,通过计数排序将数组中的元素按从小到大的顺序进行排列 
 5  *         思路:统计出数组中每个元素出现的次数,然后将元素按顺序填入就可得到有序序列
 6  *         
 7  *         在统计每个元素出现的次数时,首先找到数组的宽度(数组最大值和最小值之差再加一),
 8  *         这样,统计数组中的下标就和元素值联系在一起(相差为min)。得到统计值之后,统计
 9  *         数组中的下标可以找到原数组中对应的元素,统计数组的元素值代表原数组对应元素的出现次数
10  *        
11  *         时间复杂度:三种情况都是O(n + k)
12  *         空间复杂度:O(n + k),k代表数组的宽度
13  *         稳定性:稳定
14  *         
15  */
16 public class CountSort {
17 
18     public static void countSort(int[] arr) {
19         int max = Tools.findMax(arr);
20         int min = Tools.findMin(arr);
21         int[] count = new int[max - min + 1];
22         for (int num : arr) {
23             count[num - min]++;
24         }
25         int index = 0;
26         for (int i = 0; i < count.length; i++) {
27             while (count[i] != 0) {
28                 arr[index++] = i + min;
29                 count[i]--;
30             }
31         }
32     }
33 
34     public static void main(String[] args) {
35         int[] arr = { 5, 6, 8, 3, 2, 1, 9, 7, 2 };
36         System.out.println("before sorting:");
37         Tools.printArray(arr);
38         countSort(arr);
39         System.out.println("after sorting:");
40         Tools.printArray(arr);
41     }
42 }

6. 桶排序

整体思路:根据数组的宽度,生成数量合适的桶。遍历数组,将元素放入对应的桶中。然后对每个桶进行排序,这样,桶内和桶间就都是有序的了。

时间复杂度:最坏:O(n^2),平均:O(n + k),最好:O(n)。

空间复杂度:O(n + k),其中k为数组的宽度。

稳定性:稳定。

实现时,用list<list>代表一个桶,将桶的数量设置为(max - min) / arr.length + 1,这样,(num - min) / arr.length = i的元素就放在第i个桶中。桶内元素我们利用简单插入排序。

Java实现:

 1 /**
 2  * @author hr
 3  *
 4  *         以整型数组为例,通过桶排序将数组中的元素按从小到大的顺序进行排列
 5  *         思路:根据数组的宽度,生成数量合适的桶。遍历数组,将元素放入对应的桶中。然后对每个桶进行排序,
 6  *         这样,桶内和桶间就都是有序的了。
 7  *         
 8  *         实现时,用list<list>代表一个桶,将桶的数量设置为(max - min) / arr.length + 1,这样,
 9  *         (num - min) / arr.length = i的元素就放在第i个桶中。桶内元素我们利用简单插入排序。
10  *          
11  *         时间复杂度:最坏:O(n^2),平均:O(n + k),最好:O(n);
12  *         空间复杂度:O(n + k),其中k为数组的宽度
13  *         稳定性:稳定
14  */
15 public class BucketSort {
16     public static void insertionSort(ArrayList<Integer> bucket) {
17         for (int i = 1; i < bucket.size(); i++) {
18             int j;
19             int curNum = bucket.get(i);
20             for (j = i - 1; j >= 0 && bucket.get(j) > curNum; j--) {
21 
22                 bucket.set(j + 1, bucket.get(j));
23 
24             }
25             bucket.set(j + 1, curNum);
26         }
27     }
28 
29     public static void bucketSort(int[] arr) {
30         int max = Integer.MIN_VALUE;
31         int min = Integer.MAX_VALUE;
32         max = Tools.findMax(arr);
33         min = Tools.findMin(arr);
34         int bucketNum = (max - min) / arr.length + 1;
35         ArrayList<ArrayList<Integer>> buckets = new ArrayList<>();
36         for (int i = 0; i < bucketNum; i++) {
37             buckets.add(new ArrayList<>());
38         }
39 
40         for (int num : arr) {
41             int index = (num - min) / arr.length;
42             buckets.get(index).add(num);
43         }
44 
45         int index = 0;
46         for (int i = 0; i < buckets.size(); i++) {
47             insertionSort(buckets.get(i));
48             for (int num : buckets.get(i)) {
49                 arr[index++] = num;
50             }
51         }
52     }
53 
54     public static void main(String[] args) {
55         int[] arr = { 5, 6, 8, 3, 2, 1, 9, 7, 2 };
56         System.out.println("before sorting:");
57         Tools.printArray(arr);
58         bucketSort(arr);
59         System.out.println("after sorting:");
60         Tools.printArray(arr);
61     }
62 }

7. 基数排序

整体思路:本质上和桶排序是一样的,只是这个桶是固定的10个。排序的过程,就是将所有元素,从个位开始,不断进行桶排序。当所有的数位都排序一遍之后,就得到了有序序列。

时间复杂度:三种情况都是O(n + k)。

空间复杂度:O(n + k),其中k为数组的宽度。

稳定性:稳定。

实现时,可以用list<list>代表一个基数的计数桶;也可以用一个和原数组等长的临时数组,和一个大小为10的计数数组来进行统计。但是用后者会在一次排序的过程中,遍历两遍数组。

Java实现:

 1 /**
 2  * @author hr
 3  *
 4  *         以整型数组为例,通过基数排序将数组中的元素按从小到大的顺序进行排列
 5  *         思路:本质上和桶排序是一样的,只是这个桶是固定的10个。排序的过程,就是将所有元素,从个位开始,
 6  *         不断进行桶排序。当所有的数位都排序一遍之后,就得到了有序序列。
 7  *         
 8  *         实现时,可以用list<list>代表一个基数的计数桶;也可以用一个和原数组等长的临时数组,
 9  *         和一个大小为10的计数数组来进行统计。但是用后者会在一次排序的过程中,遍历两遍数组
10  *          
11  *         时间复杂度:三种情况都是O(n + k);
12  *         空间复杂度:O(n + k),其中k为数组的宽度
13  *         稳定性:稳定
14  */
15 public class RadixSort {
16     public static void radixSort(int[] arr) {
17         ArrayList<ArrayList<Integer>> tmp = new ArrayList<>();
18         for (int i = 0; i < 10; i++) {
19             tmp.add(new ArrayList<>());
20         }
21 
22         int maxNum = Tools.findMax(arr);
23         int maxLength = Integer.toString(maxNum).length();
24 
25         int radix = 1;
26         for (int i = 0; i < maxLength; i++) {
27             for (int k = 0; k < 10; k++) {
28                 tmp.add(new ArrayList<>());
29             }
30 
31             for (int num : arr) {
32                 int digit = (num / radix) % 10;
33                 tmp.get(digit).add(num);
34             }
35 
36             int index = 0;
37             for (int j = 0; j < tmp.size(); j++) {
38                 for (int num : tmp.get(j)) {
39                     arr[index++] = num;
40                 }
41             }
42 
43             radix *= 10;
44             tmp.clear();
45         }
46     }
47 
48     public static void main(String[] args) {
49         int[] arr = { 15, 6, 8, 3, 2, 1, 9, 7, 2 };
50         System.out.println("before sorting:");
51         Tools.printArray(arr);
52         radixSort(arr);
53         System.out.println("after sorting:");
54         Tools.printArray(arr);
55     }
56 }

 

常用排序算法及Java实现

标签:begin   使用   lis   冒泡排序   之间   依赖   数字   end   简单选择排序   

原文地址:https://www.cnblogs.com/hrcnblogs/p/9277015.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!