黑马程序员技术交流社区

标题: 冒泡排序 [打印本页]
作者: HeiMaZ    时间: 2016-5-19 22:26
标题: 冒泡排序
package com.heima.debug;

public class BubbleSort {

       
        public static void main(String[] args) {
                int[] arr = {24, -69, 80, 57, -13};
                int index=0;                                                                        //索引，记录较小值（较大）
                int temp;                                                                                //中间变量
                for (int i = 0; i < arr.length-1; i++) {                //比较次数为arr.length-1
                        temp = arr[i];                                                               
                        for (int j = i+1; j < arr.length; j++) {        //相邻两数比较
                                if (temp>arr[j]) {                                               
                                        temp=arr[j];                                                //如果temp>arr[j]，记录小的arr[j]                       
                                        index=j;                                                        //记录更小的索引
                                }
                        }
                        swap(arr,index,i);                                                        //外循环结束一次，就把最小的temp跟arr[i]交换
                }
                print(arr);
        }
        public static void swap(int[]arr,int a,int b){                //交换
                int temp=arr[b];
                        arr[b]=arr[a];
                        arr[a]=temp;
        }
        public static void print(int[]arr){                                        //输出新的数组
                for (int i = 0; i < arr.length; i++) {
                        System.out.print(arr[i]+"        ");
                }
        }

}
作者: 我是你岁哥❤环    时间: 2016-5-19 22:35
  1. class BubbleSort
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 System.out.println("********冒泡排序！********");

  7.                 //定义一个整数类型的数组，长度为10
  8.                 int arr[] = {12,3,45,23,56,7,56,11,20,30};
  9.                
  10.                 //排序之前的数组
  11.                 System.out.println("数组排序之前：");
  12.                 printArray(arr);
  13.                
  14.                 //调用排序的方法对数组进行排序
  15.                 bubbleSort(arr);

  17.                 //打印输出数组中的整数
  18.                 System.out.println("数组排序之后：");
  19.                 printArray(arr);
  20.         }

  22.         public static void bubbleSort(int arr[]){

  24.                 /*冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。
  25.                 * 即首先比较第1个和第2个数，将小数放前，大数放后。
  26.                 * 然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。
  27.                 * 重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再大于第2个数），
  28.                 * 将小数放前，大数放后，一直比较到最小数前的一对相邻数，将小数放前，大数放后，第二趟结束，
  29.                 * 在倒数第二个数中得到一个新的最小数。如此下去，直至最终完成排序。
  30.                 */
  31.                 for(int i=0; i<arr.length; i++){
  32.                         for(int j=0; j<arr.length-i-1; j++){
  33.                                 if(arr[j]>arr[j+1]){
  34.                                         swap(arr, j, j+1);
  35.                                 }
  36.                         }
  37.                 }
  38.         }

  40.         /*此方法用于相互交换数组中的两个数
  41.         * 定义一个临时变量temp用于存储其中一个数
  42.         */
  43.         public static void swap(int arr[], int a, int b){
  44.                 int temp = arr[a];
  45.                 arr[a] = arr[b];
  46.                 arr[b] = temp;
  47.         }

  49.         //循环出数组中的每一个元素
  50.         public static void printArray(int arr[]){
  51.                 for(int i=0; i<arr.length; i++){
  52.                         System.out.print(arr[i] + "\t");
  53.                 }
  54.         }

  56. }
复制代码






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