精华内容
下载资源
问答
  • //对34,5,22,-98,6,-76,0,-3这一从小到大排序 int arr[] = new int[]{34, 5, 22, -98, 6, -76, 0, -3}; //外层循环控制排序的次数 for (int i = 0; i < arr.length - 1; i++) { //内层循环读取数组的元素...

    冒泡排序

    适合新手,简单易懂,废话不多说,直接上JAVA代码:
    首先定义数组,定义两层循环
    int arr[] = new int[]{“这里填需要排序的数”};

    //对34,5,22,-98,6,-76,0,-3这一组数从小到大排序
    	int arr[] = new int[]{34, 5, 22, -98, 6, -76, 0, -3};
    //外层循环控制排序的次数
    	for (int i = 0; i < arr.length - 1; i++) {
    //内层循环读取数组的元素进行比较
    	for (int j = 0; j < arr.length - 1 - i; j++) {
    

    再来个if条件判断大小:

    //数组第一个元素与第二个元素相比较,如果第一个元素大
    //则交换位置,实现从小到大排序;如果从大到小,则是“<”符号
    	if (arr[j] > arr[j + 1]) {
    		  int temp = arr[j];
    		  arr[j] = arr[j + 1];
    		  arr[j + 1] = temp;
    	}
    

    最后输出排好序的数组:

    //循环遍历输出数组中的每一个元素
    	for (int i = 0; i < arr.length; i++) {
    		System.out.print(arr[i] + " ");
    	}
    

    完整代码:

    public class BubbleSort {
        public static void main(String[] args) {
            //对34,5,22,-98,6,-76,0,-3这一组数从小到大排序
            int arr[] = new int[]{34, 5, 22, -98, 6, -76, 0, -3};
            //外层循环控制排序的次数
            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;
                    }
                }
            }
            //循环遍历输出数组中的每一个元素
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
    
        }
    }
    
    

    运行结果:
    在这里插入图片描述
    似懂非懂???

    展开全文
  • 在实际开发中,有很多场景需要我们将数组元素按照从大到小(或者从小到大)的顺序排列,这样在查阅数据时会更加直观,例如: 一个保存了班级学号的数组,排序后更容易分区好学生和...以从小到大排序为例,冒泡排序...

    在实际开发中,有很多场景需要我们将数组元素按照从大到小(或者从小到大)的顺序排列,这样在查阅数据时会更加直观,例如:

    • 一个保存了班级学号的数组,排序后更容易分区好学生和坏学生;
    • 一个保存了商品单价的数组,排序后更容易看出它们的性价比。


    对数组元素进行排序的方法有很多种,比如冒泡排序、归并排序、选择排序、插入排序、快速排序等,其中最经典最需要掌握的是「冒泡排序」。

    以从小到大排序为例,冒泡排序的整体思想是这样的:

    • 从数组头部开始,不断比较相邻的两个元素的大小,让较大的元素逐渐往后移动(交换两个元素的值),直到数组的末尾。经过第一轮的比较,就可以找到最大的元素,并将它移动到最后一个位置。
    • 第一轮结束后,继续第二轮。仍然从数组头部开始比较,让较大的元素逐渐往后移动,直到数组的倒数第二个元素为止。经过第二轮的比较,就可以找到次大的元素,并将它放到倒数第二个位置。
    • 以此类推,进行 n-1(n 为数组长度)轮“冒泡”后,就可以将所有的元素都排列好。


    整个排序过程就好像气泡不断从水里冒出来,最大的先出来,次大的第二出来,最小的最后出来,所以将这种排序方式称为冒泡排序(Bubble Sort)。

    下面我们以“3  2  4  1”为例对冒泡排序进行说明。

    第一轮  排序过程
    3  2  4  1    (最初)
    2  3  4  1    (比较3和2,交换)
    2  3  4  1    (比较3和4,不交换)
    2  3  1  4    (比较4和1,交换)
    第一轮结束,最大的数字 4 已经在最后面,因此第二轮排序只需要对前面三个数进行比较。

    第二轮  排序过程
    2  3  1  4 (第一轮排序结果)
    2  3  1  4 (比较2和3,不交换)
    2  1  3  4 (比较3和1,交换)
    第二轮结束,次大的数字 3 已经排在倒数第二个位置,所以第三轮只需要比较前两个元素。

    第三轮  排序过程
    2  1  3  4  (第二轮排序结果)
    1  2  3  4  (比较2和1,交换)

    至此,排序结束。

    算法总结及实现

    对拥有 n 个元素的数组 R[n] 进行 n-1 轮比较。

    第一轮,逐个比较 (R[1], R[2]),  (R[2], R[3]),  (R[3], R[4]),  …….  (R[N-1], R[N]),最大的元素被移动到 R[n] 上。

    第二轮,逐个比较 (R[1], R[2]),  (R[2], R[3]),  (R[3], R[4]),  …….  (R[N-2], R[N-1]),次大的元素被移动到 R[n-1] 上。
    。。。。。。
    以此类推,直到整个数组从小到大排序。

    具体的代码实现如下所示:

    #include <stdio.h>
    int main(){
        int nums[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
        int i, j, temp;
    
        //冒泡排序算法:进行 n-1 轮比较
        for(i=0; i<10-1; i++){
            //每一轮比较前 n-1-i 个,也就是说,已经排序好的最后 i 个不用比较
            for(j=0; j<10-1-i; j++){
                if(nums[j] > nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
       
        //输出排序后的数组
        for(i=0; i<10; i++){
            printf("%d ", nums[i]);
        }
        printf("\n");
       
        return 0;
    }

    运行结果:
    1 2 3 4 5 6 7 8 9 10

     

    展开全文
  • PHP 冒泡对数组排序从小到大以及从大到小 冒泡排序可简单的理解为,从数组的第一个值开始,循环的与后面的所有值进行对比,选出大(小)的那个,继续与后续的值对比,继续选出大(小)的值一直到两两比较完,...

    PHP 冒泡排序法对数组排序,从小到大以及从大到小

    冒泡法排序可简单的理解为,从数组的第一个值开始,循环的与后面的所有值进行对比,选出大(小)的那个,继续与后续的值对比,继续选出大(小)的值一直到两两比较完,并把它放到最后;接下来就是进入循环 ,第二个依次与后面数组值比较,直到最后一个比较完成,则排序完成。

    自己多写几次,只要能理解两次循环的意义就基本掌握了。

    接下来是我写好的冒泡排序,代码如下:

    冒泡排序法(从小到大)

    <?php
    	
    	// 冒泡排序 从小到大
        function arrSort($arr) 
        {
        	$len = count($arr); // 数组长度
        	for ($i=0; $i < $len-1; $i++) {
        		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;
         			}
        		}
        	}
        	return $arr;
        }
        $arr = [9,56,3,7,100,43,15,88];
        // 调用排序方法
        $new_arr = arrSort($arr);
        // 打印排序号的新数组
        echo "<pre>";print_r($new_arr);echo "</pre>";
    

    得到结果如下:
    Array
    (
    [0] => 3
    [1] => 7
    [2] => 9
    [3] => 15
    [4] => 43
    [5] => 56
    [6] => 88
    [7] => 100
    )

    冒泡排序法(从大到小)

    	<?php
    	
    	// 冒泡排序 从大到小
        function arrSort($arr) 
        {
        	$len = count($arr); // 数组长度
        	for ($i=0; $i < $len-1; $i++) {
        		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;
         			}
        		}
        	}
        	return $arr;
        }
        $arr = [9,56,3,7,100,43,15,88];
        // 调用排序方法
        $new_arr = arrSort($arr);
        // 打印排序号的新数组
        echo "<pre>";print_r($new_arr);echo "</pre>";
    

    得到结果如下:
    Array
    (
    [0] => 100
    [1] => 88
    [2] => 56
    [3] => 43
    [4] => 15
    [5] => 9
    [6] => 7
    [7] => 3
    )

    展开全文
  • 一、冒泡排序 在实际开发中,有很多场景需要我们将数组元素按照从大到小(或者...以从小到大排序为例,冒泡排序的整体思想是这样的: 从数组头部开始,不断比较相邻的两个元素的大小,让较大的元素逐渐往后移动(交

    一、冒泡排序

    在实际开发中,有很多场景需要我们将数组元素按照从大到小(或者从小到大)的顺序排列,这样在查阅数据时会更加直观,例如:

    • 一个保存了班级学号的数组,排序后更容易分区好学生和坏学生;
    • 一个保存了商品单价的数组,排序后更容易看出它们的性价比。

    对数组元素进行排序的方法有很多种,比如冒泡排序、归并排序、选择排序、插入排序、快速排序等,其中最经典最需要掌握的是「冒泡排序」

    以从小到大排序为例,冒泡排序的整体思想是这样的:

    • 从数组头部开始,不断比较相邻的两个元素的大小,让较大的元素逐渐往后移动(交换两个元素的值),直到数组的末尾。经过第一轮的比较,就可以找到最大的元素,并将它移动到最后一个位置。
    • 第一轮结束后,继续第二轮。仍然从数组头部开始比较,让较大的元素逐渐往后移动,直到数组的倒数第二个元素为止。经过第二轮的比较,就可以找到次大的元素,并将它放到倒数第二个位置。
    • 以此类推,进行 n-1(n 为数组长度)轮“冒泡”后,就可以将所有的元素都排列好。


    整个排序过程就好像气泡不断从水里冒出来,最大的先出来,次大的第二出来,最小的最后出来,所以将这种排序方式称为冒泡排序(Bubble Sort)。

    下面我们以“3  2  4  1”为例对冒泡排序进行说明。

    第一轮  排序过程
    3  2  4  1    (最初)
    2  3  4  1    (比较3和2,交换)
    2  3  4  1    (比较3和4,不交换)
    2  3  1  4    (比较4和1,交换)
    第一轮结束,最大的数字 4 已经在最后面,因此第二轮排序只需要对前面三个数进行比较。

    第二轮  排序过程
    2  3  1  4 (第一轮排序结果)
    2  3  1  4 (比较2和3,不交换)
    2  1  3  4 (比较3和1,交换)
    第二轮结束,次大的数字 3 已经排在倒数第二个位置,所以第三轮只需要比较前两个元素。

    第三轮  排序过程
    2  1  3  4  (第二轮排序结果)
    1  2  3  4  (比较2和1,交换)


    至此,排序结束。


    二、算法总结及实现

    对拥有 n 个元素的数组 R[n] 进行 n-1 轮比较。

    第一轮,逐个比较 (R[1], R[2]),  (R[2], R[3]),  (R[3], R[4]),  …….  (R[N-1], R[N]),最大的元素被移动到 R[n] 上。

    第二轮,逐个比较 (R[1], R[2]),  (R[2], R[3]),  (R[3], R[4]),  …….  (R[N-2], R[N-1]),次大的元素被移动到 R[n-1] 上。
    。。。。。。
    以此类推,直到整个数组从小到大排序。


    具体的代码实现如下所示:

    #include <stdio.h>
    
    int main()
    {
        int nums[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
        int i, j, temp;
    
        //冒泡排序算法:进行 n-1 轮比较
        for(i=0; i<10-1; i++){
            //每一轮比较前 n-1-i 个,也就是说,已经排序好的最后 i 个不用比较
            for(j=0; j<10-1-i; j++){
                if(nums[j] > nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
       
        //输出排序后的数组
        for(i=0; i<10; i++){
            printf("%d ", nums[i]);
        }
        printf("\n");
       
        return 0;
    }

    运行结果:

    1 2 3 4 5 6 7 8 9 10

    三、优化算法

    上面的算法是大部分教材中提供的算法,其中有一点是可以优化的:当比较到第 i 轮的时候,如果剩下的元素已经排序好了,那么就不用再继续比较了,跳出循环即可,这样就减少了比较的次数,提高了执行效率。

    未经优化的算法一定会进行 n-1 轮比较,经过优化的算法最多进行 n-1 轮比较,高下立判。

    优化后的算法实现如下所示:

    #include <stdio.h>
    
    int main()
    {
        int nums[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
        int i, j, temp, isSorted;
       
        //优化算法:最多进行 n-1 轮比较
        for(i=0; i<10-1; i++){
            isSorted = 1;  //假设剩下的元素已经排序好
            for(j=0; j<10-1-i; j++){
                if(nums[j] > nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                    isSorted = 0;  //一旦需要交换数组元素,就说明剩下的元素没有排序好
                }
            }
            if(isSorted) break; //如果没有发生交换,说明剩下的元素已经排序好
        }
    
        for(i=0; i<10; i++){
            printf("%d ", nums[i]);
        }
        printf("\n");
       
        return 0;
    }

    在此额外设置一个变量 isSorted,用它作为标志,值为“真”表示剩下的元素已经排序好了,值为“假”表示剩下的元素还未排序好。

    每一轮比较之前,我们预先假设剩下的元素已经排序好了,并将 isSorted 设置为“真”,一旦在比较过程中需要交换元素,就说明假设是错的,剩下的元素没有排序好,于是将 isSorted 的值更改为“假”。

    每一轮循环结束后,通过检测 isSorted 的值就知道剩下的元素是否排序好。

    展开全文
  • 参考链接 ...冒泡法排序可简单的理解为,从数组的第一个值开始,循环的与后面的所有值进行对比,选出大(小)的那个,继续与后续的值...冒泡排序法(从小到大) <?php // 冒泡排序 从小到大 function arrSort($arr
  • 【程序设计】--------------------------------------------------功能:编写函数用冒泡排序对数组中的数据进行从小到大的排序。*********Begin**********和**********End*********...【程序设计】---------------...
  • 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从AZ)错误就把他们交换过来。走访元素的工作是重复...
  • 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从AZ)错误就把他们交换过来。走访元素的工作是重复...
  • Java对数组排序——冒泡排序

    千次阅读 2018-08-02 23:28:25
    排序问题,在很多地方会使用到,下面主要是对数组中的元素进行冒泡排序从小到大冒泡排序概念及算法原理,点击链接了解:https://baike.so.com/doc/2392104-2529369.html  冒泡排序代码: package ...
  • 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从AZ)错误就把他们交换过来。走访元素的工作是重复...
  • 5,编写一个控制台程序,要求用户输入一数字用空格间隔,对用户输入的数字从小到大输出。(Array.Sort方法和冒泡排序) Array.Sort()方法,CLR提供的排序方法,使用的是快速排序。 string str = Console....
  • 冒泡对数组进行排序

    千次阅读 2007-02-06 17:36:00
    //冒泡法算法// 目的:按要求从大到小或从小到大排序。//// 基本思路:对尚未排序的各元素从头到尾依次依次比较相邻的两个元素是否逆序(与欲排顺序相反),// 若逆序就交换这两元素,经过第一轮比较排序后便可把...
  • package com.company; public class Main { public static void main(String[] args) { int [] arr = new int[]{3,6,2,7,4,5}; bianli(arr);//打印没有排列之前的数组 pailie(arr);//对数组进行排列
  • 现有一数据,需要对其进行从小到大的进行排序1:冒泡排序,时间复杂度O(n2)public class popSort{ public static void main(String[] args) { int[] arr={1,161,151,2,5,6,7,46,4,22,545,232,11,58};...
  •  就想到能不能采用分而治之思想结合递归对数组进行排序, 代替以前的冒泡排序和选择排序呢?然后自己想着想着, 还真实现了! 代码如下: /** * 从小到大进行排序 指导思想: 分而治之+递归 */ package ...
  • 1,对数组排序。可以用选择,冒泡都行。  * 2,for嵌套和比较以及换位。  * 3,问题:以前排的是整数,比较用的比较运算符,可是现在是字符串对象。  *  字符串对象怎么比较呢?爽了,对象中提供了...
  • 冒泡排序

    2020-10-22 21:10:27
    对数组元素进行排序的方法有很多种,比如冒泡排序、归并排序、选择排序、插入排序、快速排序等,其中最经典最需要掌握的是「冒泡排序」。 以从小到大排序为例,冒泡排序的整体思想是这样的: 从数组头部开始,不断...
  • (3)用同样的方法把剩下的数据逐个进行比较,最后便可按照从小到大的顺序排好数组中各数据的顺序。 此排序法就像气泡在水中向上浮一样,所以也称为气泡排序法。 下面以一待排序的数据演示冒泡排序的过程,假设有6...
  • 给定一个字符串数组,按照字典顺序进行从小到大排序 { "nba", "abc", "cba", "zz", "qq", "haha" } 思路: 1,对数组排序。可以用选择,冒泡都行。 2,for嵌套和比较以及换位。 3,问题:以前排的是整数,比较...
  • 冒泡排序是非常容易理解和实现,以从小到大排序举例:设数组长度为N。1.比较相邻的前后二个数据,如果前面数据大于后面的数据,就将二个数据交换。2.这样对数组的第0个数据到N-1个数据进行一次...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 295
精华内容 118
关键字:

对数组进行从小到大冒泡排序