冒泡排序

阅读更多关于冒泡排序

基础排序参考 https://blog.csdn.net/yushiyi6453/article/details/76407640 冒泡排序冒泡排序从小到大排序：一开始交换的区间为0~N-1 将第1个数和第2个数进行比较，前面大于后面，交换两个数，否则不交换。再比较第2个数和第三个数，前面大于后面，交换两个数否则不交换。依次进行，最大的数会放在数组最后的位置。然后将范围变为0~N-2，数组第二大的数会放在数组倒数第二的位置。依次进行整个交换过程，最后范围只剩一个数时数组即为有序。 package bubblesort;import java.util.Scanner;/** * @author WangXiaoeZhe * @Date: Created in 2019/11/21 16:04 * @description: */public class BubbleSort { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int[] arr = new int[5]; for (int i = 0; i < arr.length; i++) { arr[i] = scanner.nextInt(); } int[] ints = bubbleSort(arr)

实现高效率的冒泡排序

阅读更多关于实现高效率的冒泡排序

// 自己实现冒泡排序最简单的方式就是使用双层循环 var arr = [10,2,5,7,8,10,10,20,10,18,20,89,6,7,52] // 外层循环是我们需要将每一个数列都排序一次，那么需要排序的数列就是arr.length - 1次 for(var i = 0; i < arr.length - 1 ; i++){ for(var j = 0; j < arr.length - 1 -i; j++){ if(arr[j] > arr[j+1]){ var temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp } } } console.log(arr) // 上面效率是相对较低的，可以参考二分查找以及递归的思路我们实现效率高的排序方法 function quickSort(start,end){ if(start >= end){ return } // 二分查找的标志 var pivot = arr[start]; var left = start; var right = end; // 循环查找当左右不重合时我们交换left和right的位置 while(left != right){ // 循环如果right比标志小那么停止并记录当前位置 while(right > left && arr[right] >

python实现真正的冒泡排序算法（时间复杂度优化版）！

阅读更多关于 python实现真正的冒泡排序算法（时间复杂度优化版）！

近期很多童鞋在讨论大厂面试的算法题，有部分同学表示一脸懵逼，不知从何下手，还有一一部分同学写的冒泡排序算法是直接从网上复制下来的冒泡排序,大多数都没有考虑时间复杂度，说白了只是实现了冒泡的流程，严格来讲只能算是一个伪冒泡排序，那么接下来给大家来捋一捋冒泡排序的原理，只有搞懂排序的原理，才能更好的掌握，写出真正的冒泡排序算法： 1、冒泡排序原理直观点先看图（注：图片来源于网络）　　从上图我们可以看出冒泡排序的规则,归纳几点如下: 冒泡的规则：每一轮获取第一个数和后面的数据进行依次比较的过程，称为一轮冒泡的过程每一轮冒泡.都是先拿第一个数，依次比对相邻的两个数，如果前一个数比后一个数大，则交换他们的位置，这一轮比较完毕，会把最大的数放在最后面。然后反复重复上面的步骤（每一轮都能将前面数据中一个最大数，放到后面），直到一轮冒泡下来没有任何数据需交互位置,此时数据已经为有序状态冒泡的次数: 假设列表的长度为n，冒泡排序是每次拿出来第一个元素，需要拿多少次呢？应该是列表的长度减1，意味着每一个长度为n的列表，需要冒泡 n-1 次每次冒泡比较的次数：每一次冒泡，都能排好一个数据的顺序，第一次冒泡，需要进行依次比较的次数为n次，那么随着次的增加排好的数据也会越多，需要比较的数据就越少。关系图如下：第几次冒泡比较的次数 1 n-1 2 n-2 3 n-3 4 n-4

js--冒泡排序

阅读更多关于 js--冒泡排序

冒泡排序Bubble_Sort

阅读更多关于冒泡排序Bubble_Sort

基本原理：对于冒泡排序来说，基本思想是从第一个元素开始，数组中的数据依次和它后面相邻的数据进行比较，即1和2比较，2和3比较，a和a+1比较，直到倒数第二位和倒数第一位的比较，如果顺序不对就进行交换，这样一次下来最大的元素会被放置在最后的位置上【以升序为例，这里是理解冒泡排序的重点。】接着，在进行一次这样的排序，只不过到倒数第二就截止。最后呢就剩第一位置的元素和第二位置的元素进行比较。这个应该比较好理解，就不上图了吧。不过如果有足够的时间，我还是愿意把图补上的。时间复杂度：显然是O(n^2) 代码： static void bubble(int [] a) { for (int i = 0; i < a.length - 1; i++) for (int j = 0; j < a.length - 1 - i; j++) if (a[j] > a [j+1]) { int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } public static void main(String []args) { int [] a = {3, 2, 5, 1, 8, 1, 11, 8}; bubble(a); for (int i : a) System.out.print(i+" "); } 来源： https://www.cnblogs

Java排序

阅读更多关于 Java排序

目录冒泡排序冒泡排序冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复n次，就完成了n个数据的排序工作。 package BubbleSort; import java.util.Arrays; public class generalBubble { public static void main(String[] args) { int[] arr=new int[] {5,7,2,9,4,1,0,5,8,7}; System.out.println(Arrays.toString(arr)); bubbleSort(arr); System.out.println(Arrays.toString(arr)); } //冒泡排序 public static void bubbleSort(int[] arr) { //控制共比较多少轮 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=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } } }

冒泡排序——从小到大排序

阅读更多关于冒泡排序——从小到大排序

li=[1,5,2,44,66,564,33,76,378]def bubble_sort(li): #获取列表的长度 n=len(li) #遍历列表长度减1次 for i in range(1,n): #创建一个变量，用来几率冒泡，是否有数据交换位置 status=False #每次遍历获取第一个元素，依次和后面的元素进行比较 for j in range(n-i): #判断当前元素和后一个元素的值 if li[j]>li[j+1]: #交换当前元素和后一个元素的值 li[j],li[j+1]=li[j+1],li[j] #只有有数据交换位置，则修改status的值 status=True #每一轮冒泡结束之后，判断当前status是否为False，如果为False，则说明上一轮冒泡没有任何数据的顺序（即数据是有序的） if not status: return li return lires=bubble_sort(li)print(res) 来源： https://www.cnblogs.com/python-squirrel/p/11881920.html

冒泡排序

阅读更多关于冒泡排序

1、排序思想：冒泡排序主要利用的是从头开始两两元素相比，大的沉底。例如：排序过程如下 2,5,3,1,7,6 2,3,1,5,6,7 一次排序，7排好了位置 2,1,3,5,6,7 二次排序，6排好了位置。。。每次排序都可以确定一个元素的位置，一个一个大的元素沉底 2、代码如下 //升序 public void bubleSort(int[] arr){ //从第一位开始，不断比较相邻两个元素大小，大的就交换 //外层循环控制总共比多少趟。从首位开始比，比到倒数第二位 for(int i=0;i<arr.length-1;i++){ //内层循环控制每趟如何比 //每比一趟，就排好了一个元素,这个元素在底部 for(int j=0;j<arr.length-i-1;j++){ if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } } 3、时间及空间复杂度时间复杂度：双层for循环，O（n^2）空间复杂度：没有借助外部空间，O（1）来源： https://www.cnblogs.com/guoyu1/p/11880351.html

排序算法

阅读更多关于排序算法

排序算法 -------1. 插入排序 -----------直接插入排序 -----------希尔插入排序 -------2. 交换排序 -----------冒泡排序 -----------快速排序 -------3. 选择排序 -----------直接选择排序 -----------堆排序 -------4. 归并排序 -------5. 基数数排序一般企业会让你说出几种排序算法，而且要求你用一种排序算法给一个数组排序，查看你的变成和代码编写的熟练程度。下面我将给大家介绍四种常见而且常考的排序算法： 1. 直接插入排序 ------算法思想：------------------------ 2.要处理的数据A和前面的数据依次比较(从前向后)，如果该数据比前面数据小， * 将该点作为插入点，备份数据A， * 将插入点之后处理数据A之前的数据整体向后移动覆盖A的位置， * 然后将备份数据插入到插入点的位置 3.取下一个待处理数据，执行步骤2 4.循环步骤3直到，需要处理的数据为0 ------代码实现：------------------------ public void straightInsertionSort(double[] sorted){ //获取待排序数组的长度 int sortedLen = sorted.length; //从第二个数据开始处理

排序算法分析1--冒泡排序、插入排序、选择排序

阅读更多关于排序算法分析1--冒泡排序、插入排序、选择排序

排序算法分析1--冒泡排序、插入排序、选择排序 0.综述 1.冒泡排序(Bubble sort) 1.1冒泡排序算法原理 1.2冒泡排序算法优化与代码实现 1.3冒泡排序算法分析 2.插入排序(Insertion sort) 2.1插入排序算法原理 2.2直接插入排序代码实现 2.3直接插入排序算法分析 2.4折半插入排序算法 3.选择排序(Slection sort) 3.1选择排序算法原理 3.2选择排序代码实现 3.3选择排序算法分析 0.综述所谓排序，就是将原本无序的序列重新排列成有序序列的过程。排序算法对任何一个程序员来说都是一项基本功，在实际的项目中我们也经常需要使用排序。排序算法的选择和使用不仅要针对实际数据的特点，有时候排序的稳定性也必须考虑。这样可以提高程序的运行效率，让开发工作事半功倍。学习排序算法不能仅仅停留在了解算法原理和使用代码实现这两步，我们应该在此基础上学会去分析和评价一个算法。我们可以从以下几各方面去衡量一个排序算法：对于排序算法执行效率的分析，包括最好、最坏、平均情况下的时间复杂度，算法运行过程中数据比较和交换的次数等。对于排序算法的内存消耗分析。算法的内存消耗通过空间复杂度来衡量。排序算法的稳定性。所谓稳定性，就是待排序的序列中的值相同的元素经过排序算法处理后是否保持原先的位置关系，若保持，则称这个排序算法为稳定的排序算法

订阅冒泡排序