冒泡排序的算法

思想(升序):

  1.比较两个相邻数据之间的大小,保证大的值在后面,最后,经过一次排序后会选出本次数组中的最大值,放在最后一位;

  2.在排除上一次的最大值数组中,再选出一位最大值放在最后一位;

  3.直到排除(选出)数组长度-1个最大值后,排序完成;

比如:数组为{10  ,34  ,300  ,56  ,6,  56  ,7  ,87  ,  5}数组长度为9;

  

public class find_em {
    public static void main(String[] args){
        int arr[]={10,34,300,56,6,56,7,87,5};
        System.out.println("原始数据:");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println("\n排序(升序):");

        //冒泡排序
        for(int j=1;j<arr.length;j++){  //控制循环次数,也就是选出几个最大值后停止
            for(int i=0;i<arr.length-j;i++){  //交换数据,选出最大值
                if(arr[i]>arr[i+1]){    //如果是降序只要将这里改为<号即可
                    int t=arr[i+1];
                    arr[i+1]=arr[i];
                    arr[i]=t;
                }
            }
            for(int i=0;i<arr.length;i++){
                System.out.print(arr[i]+"\t");
            }
            System.out.println("选出本次最大值:"+arr[arr.length-j]);
        }
        System.out.println("排序后的数据:");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }

    }
}

结果:

原始数据:
10    34    300    56    6    56    7    87    5
排序(升序):
10    34    56    6    56    7    87    5    300    选出本次最大值:300
10    34    6    56    7    56    5    87    300    选出本次最大值:87
10    6    34    7    56    5    56    87    300    选出本次最大值:56
6    10    7    34    5    56    56    87    300    选出本次最大值:56
6    7    10    5    34    56    56    87    300    选出本次最大值:34
6    7    5    10    34    56    56    87    300    选出本次最大值:10
6    5    7    10    34    56    56    87    300    选出本次最大值:7
5    6    7    10    34    56    56    87    300    选出本次最大值:6
排序后的数据:
5    6    7    10    34    56    56    87    300    

 比较次数:36
  交换次数:20

原文地址:https://www.cnblogs.com/feiquan/p/8973300.html

时间: 2024-07-31 15:40:26

冒泡排序的算法的相关文章

冒泡排序(算法源码)

算法源码: //BubbleSort.cpp #include <iostream>using namespace std; void BubbleSort(int a[], int n){ for(int i=n-1;i>0;i--) {for(int j=0;j<i;j++) { if (a[j]>a[j+1]) { int tmp = a[j]; a[j] = a[j+1]; a[j+1] = tmp; } } }}int main(){ int a[]={4,3,6,

冒泡排序及其算法优化分析

1.基本冒泡排序 冒泡排序的基本思想:假设被排序的记录数组d[1...N]垂直竖立,将每个记录d[i]看作是一个气泡,那么重的气泡就会向下下沉,轻的气泡就会向上升.每次都是相邻的两个气泡d[i]和d[i+1]进行比较.如果d[i]>d[i+1],那么就交换两个气泡,然后在比较d[i+1]和d[i+2],以此类推,知道所有的气泡都有序排列.假设排序20,37,11,42,29. 第1次冒泡:20.37,11,42,29 d[0]和d[1]比较 第2次冒泡:20,11,37,42,29 d[1]和d

内嵌汇编与C/C++实现的冒泡排序,快速排序算法排序500W个数据对比

内嵌汇编是微软为了提高程序的直接操作硬件能力,以及实现大任务程序效率的提高,而嵌入在VC中的,他不依赖于汇编器对内嵌汇编代码进行汇编,这些内嵌汇编代码由C编译器内部实现,可以使程序好像自陷到汇编状态一样.这意味着你如果在C/C++程序中使用了 inline  asm进行 汇编 那么 就注定无法跨平台的,对于没有汇编基础的同学是需要去学习下王爽的8086汇编程序设计.,因为有些时候C++程序员是不得不懂这些东西的 ,否则你永远无法知道编译器为你的函数做了什么,.你还有哪些地方需要优化, 不管处于什

冒泡排序之算法

一.定义冒泡排序是一种基于比较的排序算法,每次比较,小数字在左,大数字在右.比较是相邻的两个元素比较,交换也发生在这两个元素之间,大数字经过交换会慢慢“浮”到最后面.二.算法思想依次比较相邻的两个数,如果不符合排序规则,则调换两个数的位置.这样一遍比较下来,能够保证最大(或最小)的数排在最后一位.再对最后一位以外的数组,重复前面的过程,直至全部排序完成.三.具体实现因为有2层循环,所以有4种实现方式. //交换元素 function swap(arr,i,j){ var temp = arr[j

《冒泡排序》算法设计之二

冒泡排序过程 1.首先比较相邻的两个元素,如果前面数据大于后面数据的话,就将这两个数进行交换,依次推,直到完成第N-1个记录与第N个记录交换为止(第一趟起泡). 2.然后再进行第二趟气泡.由第一趟气泡,可知末尾是最大数,所以第二趟之比较前N-1个数 3.第三趟--   比较N-2个数 ................................................................................... 冒泡分析 通过上述的过程分析,可以知道冒泡就好

java 冒泡排序 经典算法题

//        冒泡排序:经典算法题.//        有一组数字 2,10,8,20,11,把这组数按照从大到小的顺序排列出来.20,11,10,8,2//        2,10,8,20,11 //        找出最大的数,放到第一位(1,2,3,4,5)//        20,10,8,2,11 //        从剩下的4个数中,找最大的(2,3,4,5)//        20,11,8,2,10 //        从剩下的3个数中,找最大的(3,4,5)//    

冒泡排序java算法

public class maopao { public static void main(String[] args) { int[] array = {332,94,65,4,15,64,16,5,4}; int temp = 0 ; /** * i:0-8 9 个 * 第一次: i=0 the inner for should loop 8 times so the number is * */ for(int i =0 ;i<array.length;i++){ for (int j =

冒泡排序改进算法

先上一段传统的选择排序的代码: public class SortTest2 { public static void main(String[] args) { int[] a = new int[args.length]; for(int i=0; i<args.length; i++) { a[i] = Integer.parseInt(args[i]); } print(a); selectSort(a); print(a); } private static void selectio

冒泡排序算法

冒泡排序(Bubble Sort)是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端. 本文地址:http://www.cnblogs.com/archimedes/p/bubble-sort-algorithm.html,转载请注明源地址. 冒泡排序对n个项目需要O(n2)的比较次数,且可以原地排序.尽