冒泡排序

需求：逐个输入10个学生成绩，并将从大到小输出。 分析：可使用 冒泡排序 将成绩数组进行交换排序 冒泡排序示例代码： void bubbleSort(int[] a){ int temp; for(int i = 1;i < a.length;i++) { for(int j = 0;j < a.length - i; j++) { if(a[j] > a[j+1]) { temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } System.out.print(String.format("第 %d 步排序结果：",i)); for(int k = 0; k < a.length; k++){ System.out.print(a[k] + " "); } System.out.println(); } } 实现从大到小打印成绩数组： import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class StuduentScore2 { // 逐个输入10个学生的成绩，并将其从大到小输出 // 10个学生保存到常量final int N = 10； // 输入：保存到double[] scores中 //

数据的排序方法有多种，每种排序都有各自的特点和优点，在实际的使用中需要根据实际的情况灵活的选择排序方式，不仅可以提高效率，还可以节约资源。以下用选择排序，冒泡排序和快速排序三种排序方法对相同大小的数据进行排序效率的比较。 以下是设计器代码： 1 namespace SortsCompare 2 { 3 partial class FormSort 4 { 5 /// <summary> 6 /// 必需的设计器变量。 7 /// </summary> 8 private System.ComponentModel.IContainer components = null; 9 10 /// <summary> 11 /// 清理所有正在使用的资源。 12 /// </summary> 13 /// <param name="disposing">如果应释放托管资源，为 true；否则为 false。</param> 14 protected override void Dispose(bool disposing) 15 { 16 if (disposing && (components != null)) 17 { 18 components.Dispose(); 19 } 20 base.Dispose(disposing); 21 } 22 23 #region

public class Sort { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println("请您输入整数的个数:"); int count = input.nextInt(); int[] array = new int[count]; for (int i = 0; i < count; i++) { System.out.println("请输入第" + (i + 1) + "个整数:"); array[i] = input.nextInt(); } input.close(); System.out.println("========================"); BubbleSort(array); System.out.println("========================"); selectSort(array); } // 冒泡排序从大到小排序 private static void BubbleSort(int[] array) { // 外层循环，是需要进行比较的轮数， for (int i = 0; i < array.length - 1; i++) { // 内层循环

文章来源： http://blog.seclibs.com/算法之排序（上）/ 排序算法有很多种，甚至有很多都完全没有听过，我们最常见，也最经典的就是：冒泡排序、插入排序、选择排序、归并排序、快速排序、计数排序、基数排序、桶排序。 按照时间复杂度来进行划分可以将其划分为三类 O(n2) ：冒泡、插入、选择；基于比较 O(nlogn)：快排、归并；基于比较 O(n)：桶、计数、基数；不基于比较 这次我们来说时间复杂度为O(n2)的 在说具体的排序方法之前，先明确排序算法的评价标准 首先是排序算法的执行效率，执行效率一般从最好、最坏、平均时间复杂度上分析，其分析时间复杂度时需要考虑系数、常数和低阶，因为时间复杂度是在数据规模特别大的时候的增长趋势，在平时的代码中，数量级都是比较小的，所以还需要考虑这些问题。在基于比较的排序算法中，数值比较的次数和数据的移动次数也都是需要考虑进去的。 其次是内存的消耗，算法的内存消耗可以用空间复杂度来表示，当空间复杂度为O(1)的算法也可以称之为原地排序算法。 最后是算法的稳定性，当一组数据中有两个相同的值时，排序之后两个值的顺序是如果没有交换那它就是具有稳定性的算法。 然后我们再引入两个概念， 有序度 和 逆序度 有序度 是数组中具有有序关系的元素对的个数。 比如说2、4、3、1、5、6这组数组的有序度是11，因为它有11个有序元素对，分别是(2,4)

package alg //冒泡排序 func Bubbling(arr []int) []int { len := len(arr) if len <= 1 { return arr } for i := 0; i < len; i++ { //提前退出冒泡循环的标志位 flag := false //len-i-1 减去已经排好序,不用再循环无畏的值 for j := 0; j < len-i-1; j++ { //交换值 if arr[j] > arr[j+1] { tmp := arr[j] arr[j] = arr[j+1] arr[j+1] = tmp //标识符 flag = true } } if !flag { break; } } return arr } 来源： oschina 链接： https://my.oschina.net/hackdebug/blog/3158298

冒泡排序原理：（升序）通过当前位置数和后一个位置数进行比较 如果当前数比后一个数大 则交换位置， 完成后 比较基数的位置变成下一个数。直到数组末尾,当程序运行完第一遍 最大的数已经排序到最后一个位置了。次数可以减少循环数不用管最后一个数 降序排序同理 不过是把比较方式变成判断当前数是否小于下一个数 如果小于则交换 下面直接上代码 双重循环方式： 1 using System; 2 using System.Collections.Generic; 3 4 namespace TestConsole 5 { 6 class Program 7 { 8 static void Main(string[] args) 9 { 10 //创建一个乱序数组 11 List<int> ints = new List<int> { 1, 2, 3, 4, 8, 6, 4, 1, 0, 5, 5, 0, 5, 1, 16, 1, 32, 1, 54, 68, 4, 21, 56, 14, 856, 48, 6, 12, 3, 5 }; 12 13 //获取数组长度 14 int count = ints.Count; 15 16 //外圈循环 数组有多少个数就循环多少次 每完成一次内部循环减少一次外部循环（最后一个数以经是最大 不用参与比较了） 17 for (int i = count; i >

吐个槽 又是一个不正经取名的排序算法。真要说和鸡尾酒间的关系，大概就是想喝到鸡尾酒（得到排序好的队列）就要摇晃酒杯让不同的成分混合均匀（向两个方向冒泡排序） 原理 鸡尾酒排序(Cocktail Sort)是 冒泡排序 的一种优化算法。原本的冒泡排序只能在一轮中挑出一个值移动到最后，而鸡尾酒则可以在一轮里挑最大的移到最后，再挑最小的移到最前面。实际上就是先正向进行一轮普通的冒泡排序，然后再逆向进行一轮反向冒泡，每轮冒泡都缩小一点范围。 复杂度 最好情况是正序排列的数列O(n)，最坏情况是逆序O(n^2)，平均还是O(n^2)。空间复杂度都是O(1)。 排序过程 特别找来一张图，方便理解。注意看图中红色标记的元素，每次向右都是把最大的元素交换到后面，向左都是把最小的交换到前面。 代码 package main import ( "time" "fmt" "math/rand" ) func main() { var length = 10 var list []int // 以时间戳为种子生成随机数，保证每次运行数据不重复 r := rand.New(rand.NewSource(time.Now().UnixNano())) for i := 0; i < length; i++ { list = append(list, int(r.Intn(1000))) } fmt

1，原理：比较两个相邻的数，值大的向后移动； 2，N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为（N-i）次，所以可以用双重循环实现 3，空间复杂度（O（1）） 时间复杂度（O（n^2）） 稳定性->稳定 4,冒泡排序及其优化： public class Test25 { //冒泡排序： public static void bubbleSort(int array[]){ if (array == null || array.length ==0) return; for (int i = 0; i < array.length-1; i++) { for (int j = 0; j < array.length-i-1; j++) { if (array[j] > array[j+1]){ int tmp = array[j]; array[j] = array[j+1]; array[j+1] = tmp; } } } } //优化 public static void optimizedbubbleSort(int array[]){ if (array == null || array.length ==0) return; boolean neednextsort = true; for (int i = 0; i < array.length-1 &&

一、冒泡排序的原理 冒泡排序：将待排序的一组数分为有序区间和无序区间。先在无序区间通过相邻数的比较，将无序区间的最大数依次冒泡到最上面，持续这个过程，直到整组数有序。 二、图解分析 以[3, 0, 5, 4, 1, 2]为例，进行冒泡排序。 第一趟： 从下往上依次两两比较，将最大数交换到最上面，第一趟完成后橙色部分为已排好的部分。 第二趟： 比较方法同上，橙色部分为排好的区间，我们发现有序区间比第一趟的有序区间多一个数。 第三趟： 第四趟： 第五趟： 最后排好的整组数： 我们发现，每次排好序的区间数的个数都比前一趟多一个，所以待排序的6个数共循环了5次。 三、代码实现 public static void bubbleSort(int[] array) { for(int bound = 0; bound < array.length - 1; bound++) { //外层循环（数组长度-1）次 for(int cur = 0; cur < array.length - 1 -bound; cur++) { //内层循环，有序区间不用再循环 if (array[cur] > array[cur + 1]) { int tmp = array[cur]; array[cur] = array[cur + 1]; array[cur + 1] = tmp; } } } } 来源：

排序是将一串数据按照其某个或者某些关键字的大小进行递增或递减排列的操作我，通常指的排序是升序，排序方式是原地排序 下面介绍下冒泡排序 冒泡排序 原理：在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序 冒泡排序是一个稳定的排序 实现方式 public void bubbleSort(int[] array) { for (int i = 0; i < array.length - 1; i++) { //定义标志位来判断待排序区间是否有序 boolean isSorted = true; for (int j = 0; j < array.length - 1 - i; j++) { if (array[j] > array[j + 1]) { swap(array, j, j + 1); //只要发生交换说明待排序区间初始并不是有序 isSorted = false; } } if(isSorted) { break; } } } private void swap(int[] array, int i, int j) { int tmp = array[i]; array[i] = array[j]; array[j] = tmp; } 性能分析 时间复杂度： 最好的情况：待排序有序时，时间复杂度为O(N) 最坏的情况：待排序逆序时