java 数组排序-java数组去重排序

0. 说明

最近工作中遇到了排序的需要，其实很简单，就是两个PO按照时间的字段排序后将结果返回前端java 数组排序，很简单的一个需求，但是却让我感觉应该将排序算法，整理一下。

今天在本文中，我们就先整理下冒泡排序的算法，在着重分析下怎么交换两个数据。

1. 冒泡排序

冒泡排序算法，理论很简单，就是通过遍历，每次遍历将最小（最大）值放在为排序数组中最前面的位置。画个图下看下大概的流程。图中的测试数据数组为[6,4,2,8,3,5]。

冒泡排序

可见，第一次遍历的时候，将最小值放在了数组的首位，也就是2放在了首位。第二次遍历的时候，将次小值放在了数组的次位，也就是3放在了数组的第二位。

理论上应该遍历的是n-1次，上面的示例，应该遍历的是5次，但是我们的图中遍历4次就结束了，是因为，遍历四次后，后面未排序的数组正好已经有序了，所以在实际开发中，结束遍历的条件，可以稍作修改，这样就可以提前结束遍历，节省计算资源。

新增一个标记位，每次遍历的时候，如果有数据交换，则将标记位标记是true，否则为false。在新一轮的遍历开始的时候，如果标记位为false,则直接结束遍历。可以提前结束遍历，节省不必要的遍历开销，但是增加了一个编辑位的存储，以及每次遍历的判断，但是当数据量大的时候，判断遍历是否进行的判断，比判断遍历内数据的对比少的多。另外存储标记位java 数组排序，是一种空间换时间的操作。

2. java实现。

笔者的主语言是Java，所以就用Java做一个简单的示例：

public class BubbleSort {
 public static int[] sort(int[] arr) throws Exception {
 if (arr == null) {
 throw new Exception("参数异常");
 }
 if (arr.length == 0 || arr.length == 1) {
 return arr;
 }
 for (int i = 0; i < arr.length - 1; i++) {
 for (int j = arr.length; j > i; j--) {
 if (arr[j] < arr[j - 1]) {
 int tmp = arr[j];
 arr[j] = arr[j - 1];
 arr[j - 1] = tmp;
 }
 }
 }
 return arr;
 }
}

测试代码：

@Test
public void test_bubble_sort() throws Exception {
 int[] arr = {6,4,2,8,3,5};
 arr = BubbleSort.sort(arr);
 System.out.println(Arrays.toString(arr));
 int[] arr2 = new int[100];
 Random random = new Random(10000);
 for (int i = 0 ; i < 100; i++) {
 arr2[i] = random.nextInt(10000);
 }
 System.out.println(Arrays.toString(arr2));
 arr2 = BubbleSort.sort(arr2);
 System.out.println(Arrays.toString(arr2));
}

运行结果：

[2, 3, 4, 5, 6, 8]
[2208, 572, 9116, 3475, 4500, 9574, 5641, 9166, 9727, 7670, 3030, 6816, 2621, 2172, 8074, 7634, 7455, 3468, 5423, 4888, 3594, 3684, 5136, 363, 4111, 6762, 4480, 4705, 3924, 4626, 72, 6234, 9073, 2345, 6824, 9818, 616, 5521, 4831, 30, 1515, 6297, 3430, 7197, 5985, 8791, 9926, 9276, 2467, 165, 8650, 9054, 8881, 326, 479, 1079, 7714, 5235, 2119, 9051, 456, 6343, 1629, 2903, 4130, 1667, 1219, 4171, 2075, 3998, 1896, 8627, 2752, 205, 565, 9185, 718, 9435, 8710, 25, 473, 1909, 9798, 8473, 7050, 4229, 9859, 8290, 4896, 3176, 1808, 6647, 4743, 2942, 2249, 4657, 2598, 3790, 9841, 5276]
[25, 30, 72, 165, 205, 326, 363, 456, 473, 479, 565, 572, 616, 718, 1079, 1219, 1515, 1629, 1667, 1808, 1896, 1909, 2075, 2119, 2172, 2208, 2249, 2345, 2467, 2598, 2621, 2752, 2903, 2942, 3030, 3176, 3430, 3468, 3475, 3594, 3684, 3790, 3924, 3998, 4111, 4130, 4171, 4229, 4480, 4500, 4626, 4657, 4705, 4743, 4831, 4888, 4896, 5136, 5235, 5276, 5423, 5521, 5641, 5985, 6234, 6297, 6343, 6647, 6762, 6816, 6824, 7050, 7197, 7455, 7634, 7670, 7714, 8074, 8290, 8473, 8627, 8650, 8710, 8791, 8881, 9051, 9054, 9073, 9116, 9166, 9185, 9276, 9435, 9574, 9727, 9798, 9818, 9841, 9859, 9926]

3. 总结

冒泡算法是最简单的排序算法之一，它需要由于又嵌套遍历，外部遍历次数为n-1，内部遍历次数平均为(n-1)/2，所以它的时间复杂度是O(n^2), 空间复杂度是O(1)，基本上只占有一个临时空间，但也可以做到不占用额外的空间，这个留作下一篇文章详细说明，如有兴趣可关注本公众号。该算法还是稳定的排序算法，因为两个相等的数据在遍历的时候，不会交换位置，而且所有的交换都是相邻两个数据的交换，所以该排序算法是稳定的排序算法。

希望本文对各位看官理解排序算法有所帮助。