精华内容
下载资源
问答
  • 冒泡法数组排序

    2018-08-18 11:07:00
    冒泡法数组从小到大和从小到大排序 import java.util.Scanner; public class six4{ public static void main(String []args){ int score[]=new int [10]; Scanner s=new Scanner(System.in)...

    用冒泡法给数组从小到大和从小到大排序

     

    import java.util.Scanner;        
    public class six4{
        public static void main(String []args){
            int score[]=new int [10];
            Scanner s=new Scanner(System.in);
            for(int i=0;i<score.length;i++)
                score[i]=s.nextInt();        
            for(int i=1;i<score.length;i++)
                for(int j=0;j<score.length;j++)
                if(score[i]<score[j]){         //交换位置
                    int temp=score[i];        //定义一个临时变量存放数据
                    score[i]=score[j];
                    score[j]=temp;
                }
            for(int i=0;i<score.length;i++)        //按从小到大的顺序输出
                System.out.print(score[i]+"\t"); 
            for(int i=score.length-1;i>=0;i--)    //按从大到小的顺序输出
                System.out.print(score[i]+"\t");
        }
    }

     运行结果如下:

     

    转载于:https://www.cnblogs.com/l666/p/9496553.html

    展开全文
  • 主要介绍了Java简单数组排序,实例分析了基于冒泡法实现数组排序的相关技巧,简单实用,具有一定参考借鉴价值,需要的朋友可以参考下
  • Java 数组排序算法 :冒泡排序 例如:对数组 a[]={23,3,45,12,34,4,5,78}分别进行升序和降序排列 public class Arrays { public static void main(String[] args) { // TODO 自动生成的方法存根 int a[]...

    Java  数组排序算法   :冒泡排序

    例如:对数组 a[]={23,3,45,12,34,4,5,78}分别进行升序和降序排列


    public class Arrays {
    
    	public static void main(String[] args) {
    		// TODO 自动生成的方法存根
    		int a[]={23,3,45,12,34,4,5,78};//创建一个数组,这个数组的元素是乱序的
    		System.out.println("----升序排序----");
    		for(int i=1;i<a.length;i++){   //用i表示算法的第几次循环
    			for(int j=0;j<a.length-i;j++){
    				if(a[j]>a[j+1]){
    					int tmp=a[j];
    					a[j]=a[j+1];
    					a[j+1]=tmp;//利用临时变量对符合循环条件的元素的互换
    				}
    			}
    		}		
    		for(int e:a){
    			System.out.print(e+" ");//利用foreach语句遍历数组
    		}
    		System.out.println("\n----降序排序----");
    		for(int x=1;x<a.length;x++){
    			for(int y=0;y<a.length-x;y++){
    				if(a[y]<a[y+1]){
    					int tmp=a[y];
    					a[y]=a[y+1];
    					a[y+1]=tmp;
    				}
    			}
    		}		
    		for(int w:a){
    			System.out.print(w+" ");
    		}
    	}
    	
    
    }
    

    输出结果:
    展开全文
  • ava 数组排序 冒泡法

    2011-11-22 14:48:45
    java 冒泡法数组排序 package javaapplication3; import java.util.Scanner; public class 数组排序 { public static void main(String[] args) { int a[],id,i,j,d; a=new int [10]; Scanner input = new ...
  • 一、数组排序算法 1.1 冒泡排序 在程序设计中,经常需要将一组数列进行排序,这样更加方便统计与查询。 冒泡排序是最常用的数组排序算法之一,它排序数组元素的过程总是将小数往前放、大数往后放,类似水中气泡...

    一、数组排序算法

        1.1  冒泡排序

        在程序设计中,经常需要将一组数列进行排序,这样更加方便统计与查询。

        冒泡排序是最常用的数组排序算法之一,它排序数组元素的过程总是将小数往前放、大数往后放,类似水中气泡往上升的动作,所以称作冒泡排序。

        ( 1 )基本思想

        冒泡排序的基本思想是对比相邻的元素值,如果满足条件就交换元素值,把较小的元素移动数组前面,把大的元素移动数组后面(也就是两个元素交换位置),这样较小的元素就想气泡一样从底部上升到顶部。

        ( 2 )算法示例

        冒泡算法由双层循环实现,其中外层循环用于控制排序轮数,一般为要排序的数组长度减 1 次,因为最后一次循环只剩下一个数组元素,不需要对比,同时数组已经完成排序。而内层循环主要用于对比数组中每个临近元素的大小,以确定是否交换位置,对比和交换次数随排序轮数而减少。

        ( 3 )算法实现

        eg :实现冒泡排序,正排序。

    public class BubbleSort{
        public static void main(String[] args){
            int[] array = { 63, 4, 24, 1, 3, 15 };         //创建一个数组,这个数组元素是乱序
            BubbleSort sorter = new BubbleSort();          //创建冒泡排序类的对象
            sorter.sort(array);                            //调用排序方法将数组排序
        }
        /**
         * 冒泡排序
         *@param array 要排序的数组
         */
        public void sort(int[] array){
            for(int i = 0 ; i < array.length ; i++){
                //比较相邻两个元素,较大的数往后冒泡
                for(j = 0 ; j < array.length-i ; j++){
                    if(array[j] > array[j+1]){
                        int temp = array[j];                //把第一个元素值保存到临时变量中
                        array[j] = array[j+1];              //把第二个元素值保存到第一个元素单元中
                        array[j+1] = temp;                  //把临时变量(也就是第一个元素原值)保存到第二个元素中
                    }
            }
        }
        showArray(array);                                   //输出冒泡排序后的数组元素
        }
        /**
         * 显示数组中的所有元素
         *@param array 要显示的数组
         */
        public void showArray(int[] array){
            for(int i : arrray){                            //遍历数组
                System.out.print(">"+i);                    //输出每个数组元素值
            }
            System.out.println();
        }
    }
    
        运行结果为 :> 1 > 3 > 4 > 15 > 24 > 63 

        冒泡排序的主要思想是:把相邻两个元素进行比较,如满足一定条件则进行交换(如判断大小或日期前后等),每次循环都将最大(或最小)的元素排在最后,下一次循环是对数组中其他的元素进行类似操作。

        1.2  直接选择排序

        直接选择排序方法是属于选择排序的一种,它的排序速度要比冒泡排序快一些,也是常用的排序算法。

        ( 1 )基本思想

        直接选择排序的基本思想是将排序位置与其他数组元素分别对比,如果满足条件就交换元素值,注意这里区别冒泡排序,不是交换相邻元素,而是把满足条件的元素与指定的排序位置交换(如从最后一个元素开始排序),这样排序好的位置逐渐扩大,最后整个数组都成为已排序好的格式。

        与冒泡排序相比,直接选择排序的交换次数要少很多,所以速度更快些。

        ( 2 )算法示例

        每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序地放在已排好序的数列的最后,直到全部待排序的数据元素排完。

    初识数组资源 [ 63 4 24 1 3 15 ]
    第一趟排序后 [ 15 4 24 1 3 ] 63
    第二趟排序后 [ 15 4 3 1 ] 24 63
    第三趟排序后 [ 1 4 3 ] 15 24 63
    第四趟排序后 [ 1 3 ] 4 15 24 63
    第五趟排序后 [ 1 ] 3 4 15 24 63

        ( 3 )算法实现

        实现直接选择排序,正排序。

    /**
    * 直接选择排序算法实例
    */
    public class SelectSort{
        public static void main(String[] args){
            int[] array = { 63, 4, 24, 1, 3, 15 };             //创建一个数组
            SelectSort sorter = new SelectSort();              //创建直接选择排序类的对象
            sorter.sort(array);                                //调用排序对象的方法将数组排序
        }     
        /**
        * 直接选择排序法
        * @param array 要排序的数组
        */
        public void sort(int[] array){
            int index ;
            for(int i = 1 ; i < array.length ; i++){
                index = 0;
                for(int j = 1 ;j <= array.length-i ; j++){
                    if(array[j] > array[index]){
                        index = j ;
                    }
                }
            //在交换位置 array.length-i 和 index(最大值)上的两个数
            int temp = array[array.length-i];                  //把第一个元素值保存到临时变量中
            array[array.length-i] = array[index];              //把第二个元素值保存到第一个元素单元中
            array[index] = temp;                               //把临时变量也就是第一个元素原值保存到第二个元素中
            }
            showArray(array);                                  //输出直接选择排序后的数组值
        }
        /**
        * 显示数组中的所有元素
        * @param array 要显示的数组
        */
        public void showArray(int[] array){
            for(int i : array){                                //遍历数组
                System.out.print(">"+i);                       //输出每个数组元素值
            }
            System.out.println();
        }
    }
        运行结果为 : > 1 > 3 > 4 > 15 > 24 > 63

        1.3  反转排序

        反转排序就是以相反的顺序把原有数组的内容重新排序。反转排序算法在程序开发中也经常用到。

        ( 1 )基本思想

        就是把数组最后一个元素与第一个元素替换,倒数第二个与第二个元素替换,以此类推,直到所有数组元素反转替换。

        ( 2 )算法示例

        反转排序是对数组两边的元素进行替换,所以只需要循环数组长度的半数次,如数组长度为 7 ,那么 for 循环只需要循环 3 次 。

        eg :

    初始数组资源 [ 10 20 30 40 50 60 ]
    第一趟排序后 60 [ 20 30 40 50 ] 10
    第二趟排序后 60 50 [ 30 40 ] 20 10
    第三趟排序后 60 50 40 30 20 10

        ( 3 )算法实现

        实现反转排序。

    /**
    * 反转排序算法实例
    */
    public class ReverseSort{
        public static void main(String[] args){
            int[] array = {10 ,20 ,30 ,40, 50,60};             //创建一个数组
            ReverseSort sorter = new ReverseSort();            //创建反转排序类的对象
            sorter.sort(array);                                //调用排序对象的方法将数组反转
        }
        /**
        *直接选择排序法
        *@param array 要排序的数组
        */
        public void sort(int[] array){
            System.out.println("数组原有内容:");
            showArray(array);                                  //输出排序前的数组值
            int temp ;
            int len = array.length;
            for(int i = 0 ; i < len/2 ; i ++){
                temp = array[i];
                arrray[i] = array[len-1-i];
                array[len-1-i] = temp;
            }
            System.out.println("数组反转后的内容:");
            showArray(array);                                  //输出排序后的数组值
       }
        /**
         *显示数组中的所有元素
        *@param array 要显示的数组
        */
        public void showArray(int[] array){
            for(int i : array){                                //遍历数组
                System.out.printl("\t"+i);                     //输出每个数组元素值
            }  
        System.out.println();
        }
    }

        运行结果为 :

        数组原有内容 :         10  20  30  40  50  60

        数组反转后的内容 :   60  50  40  30  20  10



    展开全文
  • java数组冒泡法排序

    2012-09-24 10:23:21
    java冒泡法排序,是java学习中比较基础的一个程序,希望对大家有所帮助!
  • 数组排序其实很简单,但是小疯因为许久不用有些生疏,所以在这里重温一下,这里有两种简单的冒泡和选择。一、冒泡排序根据数组的长度循环遍历,并判断如果前一个值小于后一个值,那么就把“后一个值”排列到“当前前...

    数组排序其实很简单,但是小疯因为许久不用有些生疏,所以在这里重温一下,这里有两种简单的冒泡和选择。

    一、冒泡排序

    根据数组的长度循环遍历,并判断如果前一个值小于后一个值,那么就把“后一个值”排列到“当前前一个值”的前面。代码实现如下:

    // 定义一个无序的整形数组

    int arr[] = {25,29,13,10,12,14,41};

    // 进行排序

    for(int i = 0; i < arr.length; i++) {

    for(int j = 0; j < arr.length - 1; j++) {

    if(arr[j] > arr[j+1]) {

    // 替换临时变量

    int temp;

    // 把大的值放入中间变量

    temp = arr[j];

    // 把较小的值放入前一位

    arr[j] = arr[j+1];

    // 把较大的值放入后一位

    arr[j+1] = temp;

    }

    }

    }

    通过FOR循环取出最后的排序。代码实现如下:

    // 遍历数组,依次输出

    for(int i = 0; i < arr.length; i++) {

    System.out.println(arr[i]);

    }

    }

    在main函数中,通过实例化别名点方法名的方式调用并打印出结果。就是想要的从小到大的顺序

    二选择排序

    根据数组的长度循环遍历,并判断如果第一个值大于后边的值,就把小的值替换到前边,依次筛选第一小的、第二小的……代码实现如下:

    // 定义一个无序的整形数组

    int arr[] = {25,29,13,10,12,14,41};

    // 进行排序

    for(int i = 0; i < arr.length; i++) {

    for(int j = i+1; j < arr.length - 1; j++) {

    if(arr[i] > arr[j]) {

    // 替换临时变量

    int temp;

    // 把大的值放入中间变量

    temp = arr[i];

    // 把较小的值放入前一位

    arr[i] = arr[j];

    // 把较大的值放入后一位

    arr[j] = temp;

    }

    }

    }

    通过循环输出同冒泡一致!

    当然关于排序算法还有几种,有兴趣的可以关注后续!!

    关于冒泡排序,小疯的代码有问题,多做了多次无用循环,还好有一位朋友【qizhiyang】指点,在这里要感谢一下,现修改代码如下:

    int arr[] = {25,29,13,10,12,14,41};

    // 进行排序

    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;

    // 把大的值放入中间变量

    temp = arr[j];

    // 把较小的值放入前一位

    arr[j] = arr[j+1];

    // 把较大的值放入后一位

    arr[j+1] = temp;

    }

    }

    }

    各位有兴趣的可以比较一下看看其中的异同。

    在这里非常感谢大神【qizhiyang】的指点,希望能得到更多朋友的帮助

    展开全文
  • private static void sort(int[] arr) { // TODO Auto-generated method stub int i = 0, j = 0; int temp = 0; for (i = 0; i < arr.length - 1; i++) for (j = 0; j < arr.length - 1 - i;...if (arr[j...
  • Java数组排序-冒泡排序

    千次阅读 2017-07-28 15:18:27
    Java数组排序-冒泡排序
  • java数组排序练习——使用冒泡法排序int型的数组,使用选择排序排序Date型的数组 PracticeSort.java /* 练习, 使用冒泡法排序int型的数组 使用选择排序法排序Date型的数组 */ public class PracticeSort ...
  • java中在运用数组进行排序功能时,一般有四种方法:快速排序法、冒泡法、选择排序法、插入排序法(希尔排序(Shell Sort)是插入排序的一种),下面是一些示例,需要的朋友可以参考下
  • 冒泡排序(Bubble Sort)是常用的数组排序算法之一,它以简洁的思想与实现方法而备受青睐,也是广大学习者最先接触的一种排序算法。 冒泡排序的基本思想是:对比相邻的元素值,如果满足条件就交换元素值,把较小的...
  • //数组排序 int in[] = {1,6,5,8,9}; Arrays.sort(in); for(int i=0;i&lt;in.length;i++){ System.out.println(in[i]); } //数组中取最大值,最小值 int arr[] = {6,3,8,5,7,4,1}; int min2 = ar...
  • 在其他地方你可能经常会看到一些关于java数组排序,大多数写的都是同一种数据类型的数组排序,例如统一为整数的数组排序、统一为小数的数组排序,但是在实际开发中,这类排序是不能满足于我们的日常需求的。...
  • 冒泡排序 原理 数组中的元素,按顺序两两相比,数值大的元素往后挪,第一遍比较完,则最大值出现在数组的最后 代码 class ArrayTest{ public static void main (String[] args){ int[] arr = {20,13,11,9}; Array ...
  • java数组排序方法:冒泡排序与插入排序冒泡排序: 具体步骤: 冒泡排序的第三次排序与第一次原理一致,只不过第三次次排序不再关系数组倒数第二个位置元素,因为经过前一次排序后,数组倒数第二个...
  • 这段时间有些忙,今天空闲出来给大家分享下Java中常用的数组排序算,有冒泡排序、快速排序、选择排序、插入排序、希尔算法、并归排序算法、堆排序算法,以上排序算法中,前面几种相对后面的比较容易理解一些。...
  • 三种排序 冒泡排序 直接选择排序 调用Arrays工具类排序 package com.yrwan.java; import java.util.Arrays; public class TestArraySort { public static void main(String[] args) { System.out.println(&...
  • //定义数组 for(int y=0;y<4;y++){ for(int x=0;x<arr.length-1;x++){ 一共比较length-1次 if(arr[x]>arr[x+1]){ //如果前面的数大于后面的便互换 int temp = arr[x]; arr[x] = arr[x+1]; arr[x+1] = t
  • Java常用的数组排序

    2016-02-12 00:41:32
    从今天起就准备计算机二...1.冒泡排序法 public class Bubble { public static void main(String[] args) { // TODO Auto-generated method stub int [] array= {1,5,4,3}; //进行下称的轮数 比数组的个数少
  • public class BubbleDemo { public stataic void main(String[] args){ //定义数组 int[] arr = {32,1,5,3,12,11,65,... //打印排序前和排序后的数组作比较 System.out.println(&quot;排序前:&quot;); ...
  • 文章目录一、数组排序1. 冒泡排序2. 选择排序3. 二分查找4. 快速排序5. 插入排序6. 归并排序 一、数组排序 1. 冒泡排序 原理 从第一个元素开始,两两进行比较,将较大的数往后移,这样就将最大的数放在了最后。第...
  • public class ArrayTest03{ .../* Name:数组排序,冒泡法 Power by :Stuart Date:2015-4-23*/ public static void main(String args[]){ //定义一个integer数组 int array[]={0,1,4,8,5,4,10,9}; ...
  • Java数组排序冒泡排序算法

    千次阅读 2019-04-17 20:45:29
    其中冒泡排序是比较常用的数组排序算法之一,冒泡排序主要是排序数组的过程总是将小数往前放,大数往后放。冒泡排序其实就是对比相邻的值,如果满足条件就交换值。 冒泡排序示例: 首先创建一个数组,这数组里面的...
  • 今天主要来说下数组排序的问题,主要介绍的有冒泡排序,选择排序,快速排序,直接插入排序四种排序: 1.冒泡排序: 主要有原理图与代码解释; 原理图借鉴一位老师画的图,嘻嘻,老师画的图比较好看,就拿来借鉴下: ...
  • 冒泡排序算法的原理如下: 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。 针对所有...
  • 冒泡法排序 public static void main(String[] args) { int arr[]={1,5,3,2,9}; for(int i=0;i<arr.length-1;i++){ for(int j=i+1;j<arr.length;j++){ if (arr[j]<arr[i]){ int temp=arr[i]; ...
  • 今天在看《java从入门到精通的》的时候,看到了数组这一块,其中有道题让分别以冒泡排序和乱序排序的形式实现对数组排序,后来自己动手敲了下,话不多说,直接上代码: /* * @Author: * @Description: 乱序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,358
精华内容 8,143
关键字:

java冒泡法数组排序

java 订阅