合并两个无序数组java_Java实现十大排序算法(上)
概念
概念解释稳定如果a原本在b前面,而a=b,排序之后a仍然在b的前面。不稳定如果a原本在b的前面,而a=b,排序之后 a 可能会出现在 b 的后面。时间复杂度对排序数据的总的操作次数,反映当n变化时,操作次数所呈现规律。空间复杂度算法在计算机内执行时所需存储空间,反映当n变化时,存储空间所呈现规律。
1、冒泡排序/简单比较排序
冒泡排序是简单比较排序。 冒泡排序对数组的无序部分进行循环比较,每次比较两个元素,如果顺序错误就进行位置交换,循环结束后会在无序部分的尾部得到最值,成为有序部分;然后继续对剩余的无序部分进行循环比较,直到整个数组都成为有序部分为止。
助记码:
i∈[0,N-1) //循环N-1遍j∈[0,N-1-i) //每遍循环要处理的无序部分swap(j,j+1) //相邻元素排序并交换位置
复杂度和稳定性:
复杂度解释时间复杂度外循环和内循环以及判断和交换元素的时间开销 (n-1) + (n-2) + (n-3) + … + 1 = n*(n-1)/2空间复杂度在交换元素时那个临时变量所占的内存空间平均时间复杂度最差时间复杂度无顺序标志位最优时间复杂度有顺序标志位最优时间复杂度杂序 O( n^2 )逆序 O( n^2 )顺序无标志位 O( n^2 )顺序有标志位 O(n)平均空间复杂度最差空间复杂度最优空间复杂度杂序 O(1)逆序 O(1)顺序且不使用临时空间来交换两个元素O(0)稳定性稳定不使用临时空间来交换两个元素a = a + b; b = a - b; a = a - b;a = a * b; b = a / b; a = a / b;a = a ^ b; b = a ^ b; a = a ^ b;
Java代码实现:
public class BubbleSort {public static void main(String[] args) {//TODO 冒泡排序int[] arr = new int[]{10, 9, 8, 7, 6, 5, 4, 3, 2, 1};int[] result = sort(arr);System.out.println("结果");for (int value : result) {System.out.print(value + " ");}}/*** @param arr 待排序的数组* @return*/private static int[] sort(int[] arr) {//数组大小int n = arr.length;//临时值放在循环外,提高效率int temp;for (int i = 0; i < n - 1; i++) {//外层循环,n个数比较,只需要循环比较n-1次。for (int j = 0; j < arr.length - 1 - i; j++) {//内层无序部分循环,循环结束后,将取出最值置于数组后端有序部分。if (arr[j] > arr[j + 1]) {//相邻元素比较替换,前者大于后者替换为升序,前者小于后者替换为降序。temp = arr[j + 1];arr[j + 1] = arr[j];arr[j] = temp;}}System.out.println("第" + (i + 1) + "次");for (int value : arr) {System.out.print(value + " ");}System.out.println(" ");}return arr;}
}
运行结果:
第1次
9 8 7 6 5 4 3 2 1 10
第2次
8 7 6 5 4 3 2 1 9 10
第3次
7 6 5 4 3 2 1 8 9 10
第4次
6 5 4 3 2 1 7 8 9 10
第5次
5 4 3 2 1 6 7 8 9 10
第6次
4 3 2 1 5 6 7 8 9 10
第7次
3 2 1 4 5 6 7 8 9 10
第8次
2 1 3 4 5 6 7 8 9 10
第9次
1 2 3 4 5 6 7 8 9 10
结果
1 2 3 4 5 6 7 8 9 10
有判断是否顺序的标志位的冒泡排序,Java代码实现:
public class BubbleSort {public static void main(String[] args) {//TODO 冒泡排序int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};int[] result = sort(arr);System.out.println("结果");for (int value : result) {System.out.print(value + " ");}}/*** @param arr 待排序的数组* @return*/private static int[] sort(int[] arr) {//数组大小int n = arr.length;//临时值放在循环外,提高效率int temp;//是否顺序的标志位int flag = 1;for (int i = 0; i < n - 1; i++) {//外层循环,n个数比较,只需要循环比较n-1次。for (int j = 0; j < arr.length - 1 - i; j++) {//内层无序部分循环,循环结束后,将取出最值置于数组后端有序部分。if (arr[j] > arr[j + 1]) {//相邻元素比较替换,前者大于后者替换为升序,前者小于后者替换为降序。temp = arr[j + 1];arr[j + 1] = arr[j];arr[j] = temp;flag = 0;}}System.out.println("第" + (i + 1) + "次");for (int value : arr) {System.out.print(value + " ");}System.out.println(" ");//是顺序if (flag==1) break;}return arr;}
}
运行结果:
第1次
1 2 3 4 5 6 7 8 9 10
结果
1 2 3 4 5 6 7 8 9 10
2、简单选择排序
简单选择排序,将数组的无序部分中的元素进行比较,得到最值,并与无序部分的首部交换位置,成为数组的有序部分;然后继续对剩余的无序部分执行相同操作,直到整个数组都成为有序部分为止。
助记码:
i∈[0,N-1) //循环N-1遍j∈[i+1,N) //每遍循环要处理的无序部分select(min) //选择最值swap(i, min) //交换最值和无序部分的首部位置
复杂度和稳定性:
平均时间复杂度最差时间复杂度最优时间复杂度空间复杂度稳定性O( n^2 )O( n^2 )O( n^2 )O(1)不稳定
Java代码实现:
public class SelectionSort {public static void main(String[] args) {//TODO 选择排序int[] arr = new int[]{10, 2, 8, 3, 6, 8, 4, 7, 9, 1};int[] result = sort(arr);System.out.println("结果");for (int value : result) {System.out.print(value + " ");}}/*** @param arr 待排序的数组* @return*/private static int[] sort(int[] arr) {//临时值放在循环外,提高效率int miniIndex, miniValue;for (int i = 0; i < arr.length - 1; i++) {//外层循环,n个数比较,只需要循环比较n-1次。miniIndex = i;for (int j = i + 1; j < arr.length; j++) {//内层循环,对无序部分进行比较,得到最值if (arr[miniIndex] > arr[j]) {miniIndex = j;}}//得到最值后,将最值与无序部分的首部进行位置互换,成为数组的有序部分miniValue = arr[miniIndex];arr[miniIndex] = arr[i];arr[i] = miniValue;System.out.println("第" + (i + 1) + "次");for (int value : arr) {System.out.print(value + " ");}System.out.println(" ");}return arr;}
}
运行结果:
第1次
1 2 8 3 6 8 4 7 9 10
第2次
1 2 8 3 6 8 4 7 9 10
第3次
1 2 3 8 6 8 4 7 9 10
第4次
1 2 3 4 6 8 8 7 9 10
第5次
1 2 3 4 6 8 8 7 9 10
第6次
1 2 3 4 6 7 8 8 9 10
第7次
1 2 3 4 6 7 8 8 9 10
第8次
1 2 3 4 6 7 8 8 9 10
第9次
1 2 3 4 6 7 8 8 9 10
结果
1 2 3 4 6 7 8 8 9 10
3、简单插入排序
取出未排序无序序列中的首部元素,在数组首部已排序有序序列中从后向前扫描,找到相应位置并插入,也就是未找到相应位置时进行位置交换,找到相应位置时停止位置交换,成为有序序列;然后继续从剩余无序序列中取出首部元素,进行插入,直到整个数组成为有序序列。例如扑克牌排序。
简单插入排序在小规模数据数据或者基本有序或者时十分高效。数据有序程度越高,越高效,移动少。
复杂度和稳定性:
平均时间复杂度最差时间复杂度最优时间复杂度空间复杂度稳定性O( n^2 )O( n^2 )O( n )O(1)稳定
Java实现代码:
public class InsertionSort {public static void main(String[] args) {//TODO 插入排序int[] arr = new int[]{10, 2, 8, 3, 6, 5, 4, 7, 9, 1};int[] result = sort(arr);System.out.println("结果");for (int value : result) {System.out.print(value + " ");}}/*** @param arr 待排序的数组* @return*/private static int[] sort(int[] arr) {if (arr == null || arr.length < 2) {return arr;}int len = arr.length;int preIndex, current;//可以把数组首部元素,当做已排序的有序序列for (int i = 1; i < len; i++) {//已排序序列的最后一个元素preIndex = i - 1;//未排序序列的第一个元素current = arr[i];//寻找当前元素在有序序列中的相应位置,未结束循环且有序序列前一个元素比当前元素大,则继续寻找while (preIndex >= 0 && arr[preIndex] > current) {//交换位置arr[preIndex + 1] = arr[preIndex];//继续寻找preIndex--;}//如果已排序序列已经循环完毕,或者,已经找到对应位置arr[preIndex + 1] = current;System.out.println("第" + i + "次");for (int value : arr) {System.out.print(value + " ");}System.out.println(" ");}return arr;}
}
运行结果:
第1次
2 10 8 3 6 5 4 7 9 1
第2次
2 8 10 3 6 5 4 7 9 1
第3次
2 3 8 10 6 5 4 7 9 1
第4次
2 3 6 8 10 5 4 7 9 1
第5次
2 3 5 6 8 10 4 7 9 1
第6次
2 3 4 5 6 8 10 7 9 1
第7次
2 3 4 5 6 7 8 10 9 1
第8次
2 3 4 5 6 7 8 9 10 1
第9次
1 2 3 4 5 6 7 8 9 10
结果
1 2 3 4 5 6 7 8 9 10
4、希尔排序/改进版简单插入排序/缩小增量排序/递减增量排序
希尔排序改进插入排序,使得对较大规模并且无序的数据也非常有效率
与简单插入排序的不同之处在于,希尔排序会优先比较距离较远的元素。
首先它在逻辑上把较大的数据集合分割成若干个小组,然后对每一个小组分别进行插入排序,此时,插入排序所作用的每一个小组的数据量比较小,插入的效率比较高。
当增量为1时,整个数组已经接近有序了,插入排序效率高。
希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列,也可以动态的定义间隔序列。
希尔排序的时间度分析极其复杂,有的增量序列的复杂度至今还没人能够证明出来。
Hibbard提出了另一个增量序列{1,3,7,...,2^k-1 },这种序列的时间复杂度(最坏情形)为O(n^1.5 )
Sedgewick提出了几种增量序列,其最坏情形运行时间为O(n^1.3 )
,其中最好的一个序列是{1,5,19,41,109,...}
虽然插入排序是稳定的,但是希尔排序在插入的时候是跳跃性插入的,有可能破坏稳定性。
复杂度和稳定性:
空间复杂度稳定性O(1)不稳定
Java代码实现:
public class ShellSort {public static void main(String[] args) {//TODO 希尔排序int[] arr = new int[]{10, 2, 8, 3, 6, 8, 4, 7, 9, 1};int[] result = sort(arr);System.out.println("结果");for (int value : result) {System.out.print(value + " ");}}private static int[] sort(int[] arr) {int length = arr.length;int current;int incrementTime=0;for (int increment = length / 2; increment >= 1; increment /= 2) {incrementTime++;System.out.println("第" + incrementTime + "组" + increment +"增量");int insertTime = 0;for (int i = increment; i < length; i++) {insertTime++;System.out.println("第" + insertTime + "次插入排序");//此处是简单插入排序//分组已排序序列的最后一个元素current = arr[i];//局部未排序序列的第一个元素int preIndex = i - incrementTime;//寻找当前元素在分组有序序列中的相应位置,未结束循环且分组有序序列前一个元素比当前元素大,则继续向前寻找while (preIndex >= 0 && arr[preIndex] > current) {//交换位置arr[preIndex + incrementTime] = arr[preIndex];//继续寻找preIndex -= incrementTime;}//如果分组已排序序列已经循环完毕,或者已经找到对应位置,则结束寻找arr[preIndex + incrementTime] = current;for (int value : arr) {System.out.print(value + " ");}System.out.println(" ");}}return arr;}
}
运行结果:
第1组5增量
第1次插入排序
10 2 8 3 6 8 4 7 9 1
第2次插入排序
10 2 8 3 4 6 8 7 9 1
第3次插入排序
10 2 8 3 4 6 7 8 9 1
第4次插入排序
10 2 8 3 4 6 7 8 9 1
第5次插入排序
1 10 2 8 3 4 6 7 8 9
第2组2增量
第1次插入排序
1 10 2 8 3 4 6 7 8 9
第2次插入排序
1 8 2 10 3 4 6 7 8 9
第3次插入排序
1 8 2 10 3 4 6 7 8 9
第4次插入排序
1 4 2 8 3 10 6 7 8 9
第5次插入排序
1 4 2 8 3 10 6 7 8 9
第6次插入排序
1 4 2 7 3 8 6 10 8 9
第7次插入排序
1 4 2 7 3 8 6 10 8 9
第8次插入排序
1 4 2 7 3 8 6 9 8 10
第3组1增量
第1次插入排序
1 4 2 7 3 8 6 9 8 10
第2次插入排序
1 4 2 7 3 8 6 9 8 10
第3次插入排序
1 4 2 7 3 8 6 9 8 10
第4次插入排序
1 3 2 7 4 8 6 9 8 10
第5次插入排序
1 3 2 7 4 8 6 9 8 10
第6次插入排序
1 3 2 6 4 8 7 9 8 10
第7次插入排序
1 3 2 6 4 8 7 9 8 10
第8次插入排序
1 3 2 6 4 8 7 9 8 10
第9次插入排序
1 3 2 6 4 8 7 9 8 10
结果
1 3 2 6 4 8 7 9 8 10
5、归并排序
和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。
•把长度为n的输入序列分成两个长度为n/2的子序列;
•对这两个子序列分别采用归并排序;
•将两个排序好的子序列合并成一个最终的排序序列。
复杂度和稳定性:
平均时间复杂度最差时间复杂度最优时间复杂度空间复杂度稳定性O(n log2 n)O(n log2 n)O(n log2 n)O(n)稳定
归并排序迭代版,Java代码实现:
public class MergeSortIteration {public static void main(String[] args) {//TODO 归并排序迭代版int[] arr = new int[]{10, 2, 8, 3, 6, 5, 4, 7, 9, 1};sort(arr);}public static void sort(int[] arr) {if (arr == null || arr.length < 2) {return;}int[] orderedArr = new int[arr.length];for (int i = 2; i < arr.length * 2; i *= 2) {for (int j = 0; j < (arr.length + i - 1) / i; j++) {int left = i * j;int mid = left + i / 2 >= arr.length ? (arr.length - 1) : (left + i / 2);int right = i * (j + 1) - 1 >= arr.length ? (arr.length - 1) : (i * (j + 1) - 1);int start = left, l = left, m = mid;while (l < mid && m <= right) {if (arr[l] < arr[m]) {orderedArr[start++] = arr[l++];} else {orderedArr[start++] = arr[m++];}}while (l < mid)orderedArr[start++] = arr[l++];while (m <= right)orderedArr[start++] = arr[m++];System.arraycopy(orderedArr, left, arr, left, right - left + 1);}}}
}
归并排序递归版,Java代码实现:
public class MergeSortRecursive {public static void main(String[] args) {//TODO 归并排序递归版int[] arr = new int[]{10, 2, 8, 3, 6, 5, 4, 7, 9, 1};sort(arr);}private static void sort(int[] arr) {if (arr == null || arr.length < 2) {return;}int[] result = new int[arr.length];merge_sort_recursive(arr, result, 0, arr.length - 1);}private static void merge_sort_recursive(int[] arr, int[] result, int start, int end) {if (start >= end)return;int len = end - start, mid = (len >> 1) + start;int start1 = start, end1 = mid;int start2 = mid + 1, end2 = end;merge_sort_recursive(arr, result, start1, end1);merge_sort_recursive(arr, result, start2, end2);int k = start;while (start1 <= end1 && start2 <= end2)result[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];while (start1 <= end1)result[k++] = arr[start1++];while (start2 <= end2)result[k++] = arr[start2++];for (k = start; k <= end; k++)arr[k] = result[k];}
}
欢迎关注Android技术堆栈,专注于Android技术学习的公众号,致力于提高Android开发者们的专业技能!
合并两个无序数组java_Java实现十大排序算法(上)相关推荐
- 合并两个无序数组java_Java 合并两个排序数组
题目:将两个排序好的数组组成一个新的排序好的数组,给出A=[1,2,3,4],B=[2,4,5,6],返回[1,2,2,3,4,4,5,6] 挑战 你能否优化你的算法,如果其中一个数组很大而另一个数组 ...
- <<算法很美>>——(三)十大排序算法(上)
目录 前言 冒泡排序 图解冒泡 代码实现 冒泡优化 选择排序 图解选排 代码实现 插入排序 图解插入 代码实现 希尔排序 图解希尔 代码实现: 归并排序 图解归并 代码实现 快速排序 图解快排 ...
- 十大排序算法之快速排序(两种方法)
十大排序算法之快速排序 本文采用Java书写选择排序,其他语言类似可以借鉴着写 思想:在待排序序列中选择一个分割元素,将待排序序列中所有比分割元素关键字小的元素移动到分割元素左侧位置:将待排序序列中所 ...
- 「干货总结」程序员必知必会的十大排序算法
点击上方 好好学java ,选择 星标 公众号 重磅资讯.干货,第一时间送达 今日推荐:硬刚一周,3W字总结,一年的经验告诉你如何准备校招! 个人原创100W+访问量博客:点击前往,查看更多 绪论 身 ...
- 「归纳|总结」程序员必知必会的十大排序算法
微信搜一搜「bigsai」关注这个有趣的程序员 新人原创公众号,求支持一下!你的点赞三连肯定对我至关重要! 文章已收录在 我的Github bigsai-algorithm 欢迎star 本文目录 绪 ...
- 程序员必知必会的十大排序算法
绪论 身为程序员,十大排序是是所有合格程序员所必备和掌握的,并且热门的算法比如快排.归并排序还可能问的比较细致,对算法性能和复杂度的掌握有要求.bigsai作为一个负责任的Java和数据结构与算法方向 ...
- mysql外部排序算法_「干货总结」程序员必知必会的十大排序算法
绪论 身为程序员,十大排序是是所有合格程序员所必备和掌握的,并且热门的算法比如快排.归并排序还可能问的比较细致,对算法性能和复杂度的掌握有要求.bigsai作为一个负责任的Java和数据结构与算法方向 ...
- 【C#】十大排序算法(动图演示+代码实现)
文章目录 1.冒泡排序 2.插入排序 3.选择排序 4.快速排序 5.希尔排序 6.堆排序 7.归并排序 8.计数排序 9.桶排序 10.基数排序 参考 1.冒泡排序 口诀: 外层循环 n-1;内层循 ...
- 十大排序算法(C++)
十大排序算法Sorting algorithm(C++) 百度百科: 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列 ...
最新文章
- 百度重磅发布云手机:低配置也可玩大型游戏 21
- java继承----类的复用
- 线程、进程、程序区别
- JS中URL编码解码
- 细数25个硅谷最热创业公司 寻找创业灵感
- 修改mysql数据库名称
- redis源码剖析(2):基础数据结构ADLIST
- 智能优化算法论文python复现,附代码--鲸鱼优化算法(WOA)-1
- Java面试宝典4.0版
- 测试驱动开发、验收测试驱动开发和行为驱动开发
- 马哥SRE第八周课程作业
- 游戏建模师真实状况,入行4K?网上吐槽的是真的吗?
- Java程序性能优化 !
- solr4.4 索引mysql数据库数据_solr4.4 索引mysql数据库数据(DataImport DIH QuickStart)
- 隐式图层动画 (Implicit Layer Animation)
- Android 模拟器显示不全的解决方案
- ITGO重装上阵、谁与争锋
- 谈谈爬虫背后的法律风险
- 《刷题笔记》牛客网 字符集合(一刷)
- 自定义拍照时 拍照界面_摄影技巧,拍照时模特的眼睛应看向哪里?不同的眼神方向有何区别...