冒泡排序

算法 遍历数组，在此查看N+1的元素是不是比N元素大，如果大则交换位置，每次遍历后保证本次遍历最大的元素在最后 #include <iostream> using namespace std; void bubble_sort(int* arr, int length) { bool tidy; // 判断数组是否已经有序 for (int i = 0; i < length; i ++) { tidy = true; for (int j = 0; j < length; j ++) { if (arr[j] > arr[j + 1]) { tidy = false; swap(arr[j], arr[j + 1]); } } if (tidy) { // 如果有序则退出遍历 break; } } } int main() { int* arr = new int[10]; for (int i = 0; i < 10; i ++) { arr[i] = 10 - i; } for (int i = 0; i < 10; i ++) { cout << arr[i] << " "; } cout << "\n"; bubble_sort(arr, 10); for (int i = 0; i < 10; i ++) { cout << arr[i] << " "; }

package com.rao.sort;import java.util.Arrays;/** * @author Srao * @className BubbleSort * @date 2019/12/4 12:33 * @package com.rao.sort * @Description 冒泡排序 */public class BubbleSort { /** * 冒泡排序 * @param 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; } } } } public static void main(String[] args) { int[] arr = new int[]{3,6,2,5,9,1,0,8}; System.out.println(Arrays.toString(arr)); bubbleSort(arr); System.out.println(Arrays.toString(arr

例22 插入排序 问题描述 排序是计算机程序设计中的一种重要操作，它的功能是将一个数据元素或记录的任意序列，重新排列成一个以关键字递增（或递减）排列的有序序列。 排序的方法有很多，简单插入排序就是一种简单的排序算法。 插入排序的基本思想是顺序将一个待排序的记录按其关键字值的大小插入到一个有序的序列中，插入后该序列仍然是有序的。 简单插入排序是一种最简单的排序方法。它的排序过程为：先将待排序序列中第1个记录看成是一个有序的子序列，然后从第2个记录起依次逐个地插入到这个有序的子序列中去。这很像玩扑克牌时一边抓牌一边理牌的过程，抓一张牌就插入到其应有的位置上去。 简单插入排序的排序过程如下图1所示。图1中方括号[ ]中为已排好序的记录关键字的子序列，下划线的关键字表示当前插入到有序子序列中的记录。 图1 简单插入排序的排序过程示例 编写一个程序，用简单插入排序方法将输入的N个整数按从小到大的顺序排列输出。 输入格式 第一行是一个正整数N (1 ≤ N ≤ 100000)，代表数组中元素的个数。 第二行有N个整数，表示待排序的N个数组元素。 输出格式 一行，有N个整数，这N个整数按从小到大的顺序排列输出。 输入样例 10 7 2 5 4 9 6 3 10 1 8 输出样例 1 2 3 4 5 6 7 8 9 10 （1）编程思路。 将整个数组（n个元素）看成是由有序的（a[0]，…，a[i

public class 冒泡排序1 {public static void main(String[]args) {int [] arr= {7,3,4,1,6};System.out.print("冒泡排序前："); printArray(arr);bubbleSort(arr);System.out.print("冒泡排序后：");printArray(arr);}public static void printArray(int []arr) {for(int i=0;i<arr.length;i++) {System.out.print(arr[i]+" ");}System.out.print("\n");}public static void bubbleSort(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;}}System.out.print("第"+(i+1)+"轮排序后:");printArray(arr);}} } 来源： https://www.cnblogs.com/aojie/p/11978309.html

一、内排序 排序类别 排序方法 最好时间复杂度 平均时间复杂度 最坏时间复杂度 辅助空间 稳定性 备注 插入类 插入 O(n) O(n 2 ) O(n 2 ) O(1) 稳定 大部分已排序时较好 希尔排序 - O(n s )，1<s<2 - O(1) 不稳定 s是所选分组 交换类 冒泡排序 O(n) O(n 2 ) O(n 2 ) O(1) 稳定 n小时较好 快速排序 O(nlogn) O(nlogn) O(n 2 ) O(logn) 不稳定 n大时较好 选择类 选择 O(n 2 ) O(n 2 ) O(n 2 ) O(1) 不稳定 n小时较好 堆排序 O(nlogn) O(nlogn) O(nlogn) O(1) 不稳定 n大时较好 归并排序 O(nlogn) O(nlogn) O(nlogn) O(n) 稳定 n大时较好 基数排序 O(d(n+rd)) O(d(n+rd)) O(d(n+rd)) O(rd) 稳定 见下文 1．插入排序（InsertSort） 插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的

算法例题 用随机函数生成16个2位正整数（10~99），利用 双向冒泡排序法 将其排序。 算法思路 个人概括 在我看来 双向冒泡排序 就是 冒泡排序 的一个小改变，并不是改进优化。 每一趟排序分成两个部分，同时在得到最后的有序序列前，把有序序列分成两部分，一部分在原无序序列后（和普通冒泡排序一样），一部分在原无序序列前。最后将有序序列①和有序序列②合并。 排序①（和普通冒泡排序一样），从左到右通过无序序列中元素的比较和交换位置，将无序序列中最大的元素移到最后，将其更新为有序序列②中的最小元素。 排序②，从右到左通过无序序列中元素的比较和交换位置，将无序序列中最小的元素移到最前，将其更新为有序序列①中的最小元素。 1.引入一个无序序列 2.第一趟 第一部分 比较第一个元素和第二个元素 第一个元素小于第二个元素，无需交换 比较第二个元素和第三个元素 第二个元素大于第三个元素，进行交换 （省略中间比较交换n步）比较第十二个元素和第十三个元素 第十二个元素大于第十三个元素，进行交换 将排在无序序列中最后一个元素，即第十三个元素，更新为有序序列② 第二部分 从无序序列中最后一个元素开始比较，即比较第十二个元素和第十一个元素 第十二个元素大于第十一个元素，无需交换 比较第十一个元素和第十个元素 第十一个元素小于第十个元素，进行交换 （省略中间比较交换n步）比较第二个元素和第一个元素

排序图表: 一、插入排序 　　每次将一个待排序的数据，跟前面已经有序的序列的数字一一比较找到自己合适的位置，插入到序列中，直到全部数据插入完成。 二、希尔排序 　　先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。由于希尔排序是对相隔若干距离的数据进行直接插入排序，因此可以形象的称希尔排序为“跳着插” 三、冒泡排序 通过交换使相邻的两个数变成小数在前大数在后，这样每次遍历后，最大的数就“沉”到最后面了。重复N次即可以使数组有序。 冒泡排序改进1：在某次遍历中如果没有数据交换，说明整个数组已经有序。因此通过设置标志位来记录此次遍历有无数据交换就可以判断是否要继续循环。 冒泡排序改进2：记录某次遍历时最后发生数据交换的位置，这个位置之后的数据显然已经有序了。因此通过记录最后发生数据交换的位置就可以确定下次循环的范围了。 四、快速排序 “挖坑填数+分治法”，首先令i =L; j = R; 将a[i]挖出形成第一个坑，称a[i]为基准数。然后j--由后向前找比基准数小的数，找到后挖出此数填入前一个坑a[i]中，再i++由前向后找比基准数大的数，找到后也挖出此数填到前一个坑a[j]中。重复进行这种“挖坑填数”直到i==j。再将基准数填入a[i

1、冒泡排序 依次对数组中相邻数字进行比较(两两比较)，大的放后面 var arr = [5,99,2,9,1,5,67] 　　　　　//定义一个杂乱的数组 for(var i=0;i<arr.length-1;i++){ //大循环，用于遍历数组每个元素 for(var j=0;j<arr.length-i-1;j++){ //小循环，用于将数组中的某个元素与其它所有元素相比较 var sum; //声明一个局部变量，当作第三个空瓶子 if(arr[j]>arr[j+1]){ //判断当前元素和后一个元素的大小，如果当前元素比后一个元素大 sum = arr[j+1]; //将后一个元素（小元素）放在空瓶子里 arr[j+1] = arr[j]; //将当前元素（大元素）放在后一个元素的位置 arr[j] = sum; //将小元素从空瓶子中拿出来，放在当前元素的位置 } } } console.log(arr); //完成循环之后，初始数组的顺序已经发生改变 2、选择排序 将第一位依次与后面的元素相比较，得到最小值，与第一位交换。再用第二位依次与后面元素相比较，得到最小值，与第二位交换。从原始数据中找到最小元素，并放在数组的最前面。 然后再从下面的元素中找到最小元素，放在之前最小元素的后面，直到排序完成。 var arr = [5,99,2,9,1,5,67,23] for

冒泡排序和选择排序都是数组排序。 数组排序方法：sort()排序，字符的排序，逐位比较　　　　　　　　 　　　　　　　　arr.sort(function(a,b){ 　　　　　　　　　　　　return a-b; 　　　　　　　　　　}); 　　　　　　　　　　console.log(arr)； a-b从小到大数值排序，b-a从大到小排序。 冒泡排序：两两比较。 案例：arr[5,7,4,8,3] 　　确定比较次数 　　0-1 1-2 2-3 3-4　　 0~length-1-0 　　0-1 1-2 2-3　　 　　 0~length-1-1 　　0-1 1-2 　　　　　　 0~length-1-2 　　0-1 　　　　　　　　　 0~length-1-3 　　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 ls = arr[j]; 　　　　　　arr[j] = arr[j+1]; 　　　　　　arr[j+1] = ls; 　　　　} 　　　　} 　　　　　} 选择排序：将第一位和后面所有相比较，最小的交换，放在第一位。 案例：arr[5,7,4,8,3] 分析： 0-1 0-2 0-3

　　快速排序（ Quick Sort ）与冒泡排序均为 交换类排序 。快排是对冒泡排序的一种改进。由于 关键字的比较和交换是跳跃进行 的，因此，快速排序是一种 不稳定 的排序方法。 0. 序 1. 冒泡排序 2. 快速排序 2.1 基本思想 2.2 一趟快速排序（一趟划分） 2.3 过程 2.4 实现 2.5 复杂度分析 2.5.1 时间复杂度（包含证明） 2.5.2 空间复杂度 0. 序 　　快速排序算法最早由图灵奖获得者 Tony Hoare 设计出来的，他在形式化方法理论以及 ALGOL60 编程语言的发明中都有卓越的贡献，是上世纪最伟大的计算机科学家之一。 　　快速排序被列为 20 世纪十大算法之一。 　　1. 冒泡排序 　　假设在排序过程中，记录序列 R[1...n] 的状态为： 　　更多的冒泡排序讲解见 https://www.cnblogs.com/datamining-bio/p/9715774.html 　　2. 快速排序 　　快速排序也是通过不断比较和移动交换来实现排序的，只不过它的实现，增大了记录的比较和移动的距离，将 关键字较大的记录从前面直接移动到后面，关键字较小的记录从后面直接移动到前面，从而减少了总的比较次数和移动交换次数 。 　　2.1 基本思想 　　通过一趟排序将待排记录 分割成独立的两部分 ，其中一部分记录的关键字均比另一部分记录的关键字小