黑马程序员技术交流社区

标题: 数组排序之冒泡排序 [打印本页]
作者: 大牛1    时间: 2016-6-1 20:25
标题: 数组排序之冒泡排序
数组排序之冒泡排序
  1. package cn.itcast_01;

  3. /*
  4. * 数组排序之冒泡排序：
  5. *                 相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
  6. */
  7. public class ArrayDemo {
  8.         public static void main(String[] args) {
  9.                 // 定义一个数组
  10.                 int[] arr = { 24, 69, 80, 57, 13 };
  11.                 System.out.println("排序前：");
  12.                 printArray(arr);

  14.                 /*
  15.                 // 第一次比较
  16.                 // arr.length - 1是为了防止数据越界
  17.                 // arr.length - 1 - 0是为了减少比较的次数
  18.                 for (int x = 0; x < arr.length - 1 - 0; x++) {
  19.                         if (arr[x] > arr[x + 1]) {
  20.                                 int temp = arr[x];
  21.                                 arr[x] = arr[x + 1];
  22.                                 arr[x + 1] = temp;
  23.                         }
  24.                 }
  25.                 System.out.println("第一次比较后：");
  26.                 printArray(arr);

  28.                 // 第二次比较
  29.                 // arr.length - 1是为了防止数据越界
  30.                 // arr.length - 1 - 1是为了减少比较的次数
  31.                 for (int x = 0; x < arr.length - 1 - 1; x++) {
  32.                         if (arr[x] > arr[x + 1]) {
  33.                                 int temp = arr[x];
  34.                                 arr[x] = arr[x + 1];
  35.                                 arr[x + 1] = temp;
  36.                         }
  37.                 }
  38.                 System.out.println("第二次比较后：");
  39.                 printArray(arr);

  41.                 // 第三次比较
  42.                 // arr.length - 1是为了防止数据越界
  43.                 // arr.length - 1 - 2是为了减少比较的次数
  44.                 for (int x = 0; x < arr.length - 1 - 2; x++) {
  45.                         if (arr[x] > arr[x + 1]) {
  46.                                 int temp = arr[x];
  47.                                 arr[x] = arr[x + 1];
  48.                                 arr[x + 1] = temp;
  49.                         }
  50.                 }
  51.                 System.out.println("第三次比较后：");
  52.                 printArray(arr);

  54.                 // 第四次比较
  55.                 // arr.length - 1是为了防止数据越界
  56.                 // arr.length - 1 - 3是为了减少比较的次数
  57.                 for (int x = 0; x < arr.length - 1 - 3; x++) {
  58.                         if (arr[x] > arr[x + 1]) {
  59.                                 int temp = arr[x];
  60.                                 arr[x] = arr[x + 1];
  61.                                 arr[x + 1] = temp;
  62.                         }
  63.                 }
  64.                 System.out.println("第四次比较后：");
  65.                 printArray(arr);
  66.                 */

  68.                 // 既然听懂了，那么上面的代码就是排序代码
  69.                 // 而上面的代码重复度太高了，所以用循环改进
  70.                 // for (int y = 0; y < 4; y++) {
  71.                 // for (int x = 0; x < arr.length - 1 - y; x++) {
  72.                 // if (arr[x] > arr[x + 1]) {
  73.                 // int temp = arr[x];
  74.                 // arr[x] = arr[x + 1];
  75.                 // arr[x + 1] = temp;
  76.                 // }
  77.                 // }
  78.                 // }

  80.                 /*
  81.                 // 由于我们知道比较的次数是数组长度-1次，所以改进最终版程序
  82.                 for (int x = 0; x < arr.length - 1; x++) {
  83.                         for (int y = 0; y < arr.length - 1 - x; y++) {
  84.                                 if (arr[y] > arr[y + 1]) {
  85.                                         int temp = arr[y];
  86.                                         arr[y] = arr[y + 1];
  87.                                         arr[y + 1] = temp;
  88.                                 }
  89.                         }
  90.                 }
  91.                 System.out.println("排序后：");
  92.                 printArray(arr);
  93.                 */
  94.                
  95.                 //由于我可能有多个数组要排序，所以我要写成方法
  96.                 bubbleSort(arr);
  97.                 System.out.println("排序后：");
  98.                 printArray(arr);
  99.         }
  100.        
  101.         //冒泡排序代码
  102.         public static void bubbleSort(int[] arr){
  103.                 for (int x = 0; x < arr.length - 1; x++) {
  104.                         for (int y = 0; y < arr.length - 1 - x; y++) {
  105.                                 if (arr[y] > arr[y + 1]) {
  106.                                         int temp = arr[y];
  107.                                         arr[y] = arr[y + 1];
  108.                                         arr[y + 1] = temp;
  109.                                 }
  110.                         }
  111.                 }
  112.         }

  114.         // 遍历功能
  115.         public static void printArray(int[] arr) {
  116.                 System.out.print("[");
  117.                 for (int x = 0; x < arr.length; x++) {
  118.                         if (x == arr.length - 1) {
  119.                                 System.out.print(arr[x]);
  120.                         } else {
  121.                                 System.out.print(arr[x] + ", ");
  122.                         }
  123.                 }
  124.                 System.out.println("]");
  125.         }
  126. }
复制代码







欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2