java例题_28 冒泡排序

 1 /*28 【程序 28 排序算法】
 2 题目:对 10 个数进行排序
 3 程序分析:可以利用选择法,即从后 9 个比较过程中,选择一个最小的与第一个元素交换, 下次类推,
 4 即用第二个元素与后 8 个进行比较,并进行交换。
 5 */
 6 /*分析
 7  * 冒泡排序法:
 8  * 利用数组得到键盘上的一组数据并保存,再通过冒泡排序法得到新的数组
 9  * 使用两层for循环,外面一层判断排序排到哪儿了,里面一层用于遍历剩下需要排序的数
10  *
11  * */
12
13 package homework;
14
15 import java.util.Scanner;
16
17 public class _28 {
18
19     public static void main(String[] args) {
20         // 从键盘得到一个包含10个整数的数组
21         System.out.println("请输入一个包含10个整数的数组:");
22         Scanner sc = new Scanner(System.in);
23         int[] a = new int[10];
24         // 利用for循环将数字存入数组a[]中
25         for (int i = 0; i < a.length; i++) {
26             a[i] = sc.nextInt();
27         }
28 //        //测试数组的数据 12 123 11 2 4 1 54 65 23 10
29 //        for (int i = 0; i < a.length; i++) {
30 //            System.out.print(a[i]+" ");
31 //        }
32
33         int t; // 声明一个中间量,用于交换位置是临时储存
34         // 第一层,记录排序排到哪儿了
35         for (int i = 0; i < a.length; i++) {
36
37             // 第二层,遍历还需要排序的数
38             for (int j = 0; j < (a.length - 1); j++) { // a.length-1是因为判断大小时的需要(下面加1了)
39                 if (a[j] > a[j+1]) { // 有小到大排列,若是由大到小则是<
40                     // 交换位置
41                     t = a[j];
42                     a[j] = a[j+1];
43                     a[j+1] = t;
44                 }
45 //                System.out.println(i+" "+j);   //测试
46             }
47
48         }
49         for (int i = 0; i < a.length; i++) {
50             System.out.print(a[i] + " ");
51         }
52
53     }
54
55 }

原文地址:https://www.cnblogs.com/scwyqin/p/12313837.html

时间: 2024-10-15 00:43:22

java例题_28 冒泡排序的相关文章

java面向对象的冒泡排序,选择排序和插入排序的比较

这三种排序有俩个过程: 1.比较俩个数据. 2.交换俩个数据或复制其中一项. 这三种排序的时间级别 冒泡排序:比较 (N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2 交换  0——N2/2 = N2/4 总时间 3/4*N2 选择排序:比较 (N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2 交换  0——3*(N-1)=3*(N-1)/2=3/2*N 总时间 N2/2+3/2*N 插入排序:第一轮最多比较一次,第二轮最多比较俩次,最后一轮比较N-1

Java中的冒泡排序(减少比较次数)

package yzhou.sort; import java.util.Arrays; public class BubbleSort { public static void main(String[] args) { int[] arr = { 9, 1, 2, 5, 4 }; sort(arr); System.out.println(Arrays.toString(arr)); } // 减少每一趟的次数 public static void sort(int[] arr) { boo

常用算法Java实现之冒泡排序

冒泡排序是所有排序算法中最基本.最简单的一种.思想就是交换排序,通过比较和交换相邻的数据来达到排序的目的. 具体流程如下: 1.对要排序的数组中的数据,依次比较相邻的两个数据的大小. 2.如果前面的数据大于后面的数据,就把这两个数据进行交换.这样一轮比较和交换过后,就把最小的数据放在数组的最前面: 3.按照上述比较和交换的方法,把剩下的数据再进行相同操作,最后,便可按照从小到大的顺序对数组完成排序. 假如有初始数据:25  11  45  26  12  78. 1.第一轮排序,从数组的头部开始

java基础之冒泡排序

1.冒泡排序 冒泡排序是一种比较简单的排序算法.算法的原理是: 重复地走访过要排序的数列,一次比较相邻的两个元素,按照规定好的顺序进行比较,如果他们的顺序错误就把他们交换过来.走访数列的工作重复的进行直到没有再需要交换的元素,此时数列的排序已经完成. 核心代码: 1 private static void bubbleSortTest(int arr[]) { 2 int temp = 0; 3 for (int i = 0; i < arr.length-1; i++) { 4 for (in

使用C语言和Java分别实现冒泡排序和选择排序

经典排序算法--冒泡和选择排序法 Java实现冒泡排序 基本思想是,对相邻的元素进行两两比较,顺序相反则进行交换,这样,每一趟会将最小或最大的元素放到顶端,最终达到完全有序,首先看个动图: 我们要清楚一点,冒泡排序是相邻元素的两两比较,再看下图是否会清晰些: 输入的数据为:10 30 40 33 5 78 11 100 23 66 第一次排序,从第一个数10依次比较,若10比后者小,则进行交换,当比较到5时,10比5大,所以10就停在第四个位置,再用5去比较,后面的数都比5大,所以5就排到最后了

Java版双向冒泡排序算法

冒泡排序算法是一种较为简单的并且稳定的排序算法,该算法的时间复杂度最好为O(n),最差时为O(n^2),需要的空间复杂度为O(1). 这里的算法稳定性是指 经过排序后,各元素仍然能保持它们在排序之前的相对次序,就称该算法是稳定的,反之,则为不稳定的. 例如,一组数排序前是a1,a2,a3,a4,a5,其中a2=a4,经过某种排序后a1,a2,a4,a3,a5,则说明这种排序是稳定的,因为a2排序前后都在a4前面:若排序的结果是a1,a4,a2,a3,a5,则该排序就不是稳定的了.------摘自

java算法之冒泡排序法

N个数字要排序完成,总共进行N-1趟排序,每第 i 趟的排序次数为 (N-i) 次,所以 可以用双重循环语句,外层控制循环多少趟,内层控制每一趟的循环次数,即   for(inti=0;i<arr.length-1;i++){         for(intj=0;j<arr.length-1-i;j++){         } } 冒泡排序法 口诀: 外层循环 0到n-1 //控制比较轮数 n 表示元素的个数 内层循环 0到n-i-1 //控制每一轮比较次数 两两比较做交换   冒泡排序的优

java例题_15 有小到大排序

1 /*15 [程序 15 排序] 2 题目:输入三个整数 x,y,z,请把这三个数由小到大输出. 3 程序分析:我们想办法把最小的数放到 x 上,先将 x 与 y 进行比较,如果 x>y 则将 x 与 y 的值进行交换, 4 然后再用 x 与 z 进行比较,如果 x>z 则将 x 与 z 的值进行交换,这样能使 x 最小. 5 */ 6 7 /*分析 8 * 冒泡排序法 9 * */ 10 11 package homework; 12 13 import java.util.Scanner

java例题_34 用指正对三个数排序

1 /*34 [程序 34 三个数排序] 2 题目:输入 3 个数 a,b,c,按大小顺序输出. 3 程序分析:利用指针方法. 4 */ 5 6 /*分析 7 * 指针方法的本质是按地址传值,将a,b,c存入数组中,再引用数组中的值排列大小,即利用指针的方法排序 8 * */ 9 10 11 package homework; 12 13 import java.util.Scanner; 14 15 public class _34 { 16 17 public static void mai