冒泡排序

排序算法说明: （1）对于评述算法优劣术语的说明 稳定 ：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定 ：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序 ：所有排序操作都在内存中完成； 外排序 ：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行； 时间复杂度 : 一个算法执行所耗费的时间。 空间复杂度 : 运行完一个程序所需内存的大小。 (2)排序算法图片总结: 　　 1.冒泡排序: 解析：1.比较相邻的两个元素，如果前一个比后一个大，则交换位置。 　　　2.第一轮的时候最后一个元素应该是最大的一个。 　　　3.按照步骤一的方法进行相邻两个元素的比较，这个时候由于最后一个元素已经是最大的了，所以最后一个元素不用比较。 2.快速排序: 解析：快速排序是对冒泡排序的一种改进，第一趟排序时将数据分成两部分，一部分比另一部分的所有数据都要小。然后递归调用，在两边都实行快速排序。 3.插入排序: 解析： （1） 从第一个元素开始，该元素可以认为已经被排序 （2） 取出下一个元素，在已经排序的元素序列中从后向前扫描 （3） 如果该元素（已排序）大于新元素，将该元素移到下一位置 （4） 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 （5）将新元素插入到下一位置中 （6） 重复步骤2 　　 2.二分查找: 解析

// 冒泡排序模板，升序 // 数组从下标1开始存储 // 存储n个数 // 只有n < 10000时才能用冒泡排序，否则应使用其他排序方法 #include <bits/stdc++.h> using namespace std; int a[10000001]; #define swap(a, b){int temp = a; a = b; b = temp;} void bubble_sort(){ for(int i = 1; i <= n; i++) for(int j = 1; j <= n - i; j++) if(a[i] > a[j + 1]) swap(a[j], a[j + 1]); } int main(){ ... for(int i = 1; i <=n; i++) scanf("%d", &a[i]); bubble_sort(); ... } 来源： https://www.cnblogs.com/lihello/p/11520707.html

排序 冒泡排序 ： 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 冒泡排序代码的算法思想 ： void BubbleSort(int arr[], int len) { int i = 0; int temp,j; for(i = 0; i < len - 1; i++)//趟数 { for(j = 0; j<=i; j++)//for(j=0;j<len-1-i;j++) { if(arr[j]>arr[j + 1]) { temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } for (i = 0; i < len; i++) { printf("%d ", arr[i]); } } 若走完某一趟，发现排序已经排好了，没有进行交换。减少后面的不必要循环次数（冒泡的优化法）： void BubbleSort1(int arr[],

单例是安全的么 选择排序 冒泡排序 冒泡排序时间复杂度 如果传一个已经排序的数据给冒泡排序 会造成资源浪费 如何解决这个问题 HashMap怎么遍历 HashMap长度能不能不为2^n HashMap怎么扩容 是否用过迭代器 C3P0需要配置哪些 线程的通信(等待和唤醒) 来源： https://blog.csdn.net/Cowbell/article/details/100822720

基本冒泡排序 1 public static void bubbleSort(int[] list) { 2 int temp = 0; // 用来交换的临时数 3 // 要遍历的次数 4 for (int i = 0; i < list.length; i++) { 5 // 从后向前依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上 6 for (int j = list.length - 1; j > i; j--) { 7 // 比较相邻的元素，如果前面的数大于后面的数，则交换 8 if (list[j - 1] > list[j]) { 9 temp = list[j - 1]; 10 list[j - 1] = list[j]; 11 list[j] = temp; 12 } 13 } 14 System.out.print(list[i]+","); 15 } 16 } 最优解冒泡排序 排序方法（优化：当某趟没有发生交换，说明数组已经有序，就中断程序） public static void bubbleSort(int[] arr) { //判断要排序的数据是否为空 if (arr == null || arr.length < 2) { //为空直接退出 return; } //开始排序 for (int i = arr.length - 1

https://www.cnblogs.com/onepixel/articles/7674659.html #include <stdio.h> /*【交换排序1之冒泡排序】冒泡排序:两两比较相邻记录的关键字，如果反序则交换，直到没有反序记录为止*/ int bubbleSort1(int *array, int length) //最初级的非严格冒泡排序：易懂但是效率低 { int i = 0; int j = 0; int *p = NULL; p = array; for (i = 0; i < length;i++) { for (j = i+1; j < length; j++) { //最小的放在在前面 if (p[i] > p[j]) { int temp = p[j]; p[j] = p[i]; p[i] = temp; } } } for (i = 0; i < length; i++) { printf("%-5d",p[i]); } printf("\n"); return 1; } int bubbleSort(int *array, int length) { int i = 0; int j = 0; int *p = NULL; p = array; for (i = 0; i < length; i++) { #if 0 for (j = 0; j

单链表的存储原理，简单易懂，head为头节点，他不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用，而每个节点中都有一个next引用，指向下一个节点，就这样一节一节往下面记录，直到最后一个节点，其中的next指向null。 而双链表相对于单链表的存储区别在节点不仅有一个next引用，还有一个pre引用指向上一个节点。 数组的优点： 随机访问性强 查找速度快 数组的缺点： 插入和删除效率低 可能浪费内存 内存空间要求高，必须有足够的连续内存空间。 数组大小固定，不能动态拓展 链表的优点： 插入删除速度快 内存利用率高，不会浪费内存 大小没有固定，拓展很灵活。 链表的缺点： 不能随机查找，必须从第一个开始遍历，查找效率低。 之前看了别人使用单链表实现的冒泡排序，发现有的好像实现有点问题，自己琢磨了下实现，跑了一下发现简单功能都能实现。代码及注释如下： package com.example.javalib.sort.quicksort; /** * 普通冒泡排序 链表冒泡排序 */ public class BubbleSort { public static void main(String[] args) { int[] array = new int[]{4, 6, 3, 15, 7, 1, 30, 40, 18, 5, 1, 14, 100, 494, 45

冒泡排序是运用蛮力法解决排序的一种算法，这种算法比较清晰易懂 基本思想 两两比较相邻数据，如果反序则交换，直到没有反序的数据为止 实现思路 在这里我们以升序排列为例子 将整个待排序的记录序列划分成有序区和无序区，初始时有序区为空 对无序区从前向后依次比较相邻记录，若反序则交换，从而使值较大的记录往后移动（像气泡一样浮上来） 重复执行第二步，直到无序区没有反序的记录 设计代码时，我们可以用一个标记来记载最后一次发生交换时的位置，这样，若这个值为0，则说明无序区内没有发生交换，此时无序区已经有序，算法即完成了 思想图解 初始序列，其中蓝色区域为无序区，红色为有序区，初始有序区为空，记载i=0 两两数字进行比较，反序则交换，最后一次发生交换是在6与7位置，记i=6，执行一趟排序后，有序区中有一个数据，新的无序区为[0，6] i不为0，则进行下一趟排序，并让i=0 同样执行第一趟的步骤，执行完后无序区为[0，4] i不为0，则进行下一趟排序，并让i=0 同样执行第一趟的步骤，执行完后无序区为[0，3] i不为0，则进行下一趟排序，并让i=0 执行完这一趟排序后，i=0，说明这一趟并没有反序交换（或者交换发生在0与1号位置），无序区数据都已有序，算法结束 算法代码 void bubbleSort(int r[], int n) { int bound, exchange = n - 1;

最简单易懂的冒泡排序思想＋程序解读 这仅仅是我学习时所记录的笔记等等，可能说的也很不好，但是还是和大家分享吧！ 1：冒泡排序算法是排序算法里面相对来说比较简单的，也是我们在学习算法时可能时最先接触的算法，它模仿的时水中气泡从水底到水面的一个过程。也就是自底向上的找，先找到最大的，在找其次的。举一个简单的例子： num[4]=[1,4,3,2] 1：我们需要自底向上的找： 第一次冒泡：if num[0]>num[1] 就交换他们两个的数据 第一次冒泡后的num=[1,4,3,2] 第二次冒泡：if num[1] >num[2] 交换数据 第二次冒泡后的num=[1,3,4,2] 第三次冒泡：if num[2]>num[3] 交换数据 第三次冒泡后：num=[1,3,2,4] 我们可以看出，这样我们就找了数组中的最大元素，并且放到了数组末尾。接下来重复执行，就可以排序完成。 2：冒泡排序算法最好时间复杂度是O(n),最差时间复杂度是O(n^2),空间复杂度是O(1)，是一个稳定的排序算法（排序算法的稳定性可以百度看看，在特定的数据排序情况下，稳定的排序算法会比不稳定的排序算法好很多）。 代码如下，仅仅是一个最简单的实现，但是思想都差不多。 # include <stdio.h> # define MAXSIZE 10 void Bubble_sort ( int * num ) {

''' 冒泡算法的原理是经过每一轮的比较都能确定这一轮的最大数 所以到后面的比较次数都是依次少一 例如[3,4,9,1,5] 第一轮比较，比较4次 由于是有5个数，相邻的两个数两两比较，5个数需要比较4次，N个数，需要比较N-1次 3,4比较不用变 4，9比较不用变 9,1比较要交换位置 变成1,9 9,5比较需要交换位置，变成5,9 这样就完成了第一轮的比较，第一轮确定了列表的最大一位数为9，之后的比较就可以把9祛除了 再去比较其他的数就好了，应为既是是比较了，位置也是不会改变，浪费资源而已 经过第一轮的比较列表变成了[3,4,1,5,9]，第二轮只需要比较三次 第二轮由于最后一个确定了，只需要比较三次就好了 3,4比较不用变 4,1比较需要交换，变成1,4 4,5比较，不用变， 由此我们确定了第二大的数是5 列表变成了[3,1,4,5,9] 第三轮比较，只需要比较两次 3,1比较需要交换，变成1,3 3,4比较不用改变， 列表变成了[1,3,4,5,9] 第四轮比较，只需要完成一次就行了 1,3比较不需要变化位置， 因此最终的列表为[1,3,4,5,9] ''' from random import randint l1 = [ randint(1,100) for _ in range(10)] print(l1) def dubbel_sort(arr): k = 0