面试经典冒泡排序java版

版权声明:转载请注明出处http://write.blog.csdn.net/postlist https://blog.csdn.net/z_565282532/article/details/76216294
**冒泡排序:**

/**

   需求: 定义一个int类型的数组,并对数组当中的元素进行排序,最后遍历输出元素。
   技能: 排序算法----冒泡排序。
   版本普通版:

   1.冒泡排序
        数组当中比较小的数值向下沉,数值比较大的向上浮!
   2.定义一个数组
        int[] arr = {56,23,88,38,99,12,78,59,100,77};

   3.实现思路
       3.1 创建数组---静态创建方式,而且要遍历一次
       3.2 怎么让数组当中相邻的两个数进行比较呢?
           可以使用嵌套for循环
           问题1: 外层for循环控制循环次数
           问题2: 内层for循环控制相邻的两个元素进行比较
       3.3 在内层for循环中,再嵌套一个if判断语句---目的:如果前一个元素大于后一个元素,则进行换位操作
       3.4 在循环到某次的时候,可能已经达到数组元素是有序的了,后续的循环次数可以省略。


*/
import java.util.Arrays;
public  class  ArrayTest8{

    public static void main(String[] args){
        //1. 创建数组
             int[] arr = {56,23,88,38,99,12,78,59,100,77};
             //排序之前,遍历数组
             System.out.println("排序之前:"+Arrays.toString(arr));
       //2.嵌套for循环
             int temp = 0; // 作用: 充当第三方变量,为换位做准备
       //2.1 外层for循环控制循环次数
              for(int i=0;i<arr.length && flag;i++){
                  //2.2  内层for循环控制相邻的两个元素进行比较
                  for(int j=0;j<arr.length-1-i;j++){
                      //3.在内层for循环中,再嵌套一个if判断语句
                      if(arr[j]>arr[j+1]){
                          //如果条件满足,则进行换位操作
                          temp =arr[j+1];
                          arr[j+1]=arr[j];
                          arr[j]=temp;

                      }
                  }
                  //每一次循环,排序的结果
                  System.out.println("第"+(i+1)+"次循环排序的结果");
                  for(int k=0;k<arr.length;k++){
                      System.out.print(arr[k]+"\t");
                  }
              }
        //4.输出结果
             //排序之后,遍历数组
             System.out.println("排序之后:"+Arrays.toString(arr));

    }
}
**输出结果:**
排序之前:[56, 23, 88, 38, 99, 12, 78, 59, 100, 77]
第1次循环排序的结果
23  56  38  88  12  78  59  99  77  1002次循环排序的结果
23  38  56  12  78  59  88  77  99  1003次循环排序的结果
23  38  12  56  59  78  77  88  99  1004次循环排序的结果
23  12  38  56  59  77  78  88  99  1005次循环排序的结果
12  23  38  56  59  77  78  88  99  1006次循环排序的结果
12  23  38  56  59  77  78  88  99  1007次循环排序的结果
12  23  38  56  59  77  78  88  99  1008次循环排序的结果
12  23  38  56  59  77  78  88  99  1009次循环排序的结果
12  23  38  56  59  77  78  88  99  10010次循环排序的结果
12  23  38  56  59  77  78  88  99  100 
排序之后:[12, 23, 38, 56, 59, 77, 78, 88, 99, 100]


package javase.collection;

/**

   需求: 定义一个int类型的数组,并对数组当中的元素进行排序,最后遍历输出元素。
   技能: 排序算法----冒泡排序。

   版本:升级版
   1.冒泡排序
        数组当中比较小的数值向下沉,数值比较大的向上浮!
   2.定义一个数组
        int[] arr = {56,23,88,38,99,12,78,59,100,77};

   3.实现思路
       3.1 创建数组---静态创建方式,而且要遍历一次
       3.2 怎么让数组当中相邻的两个数进行比较呢?
           可以使用嵌套while循环,控制循环次数
           内层for循环控制相邻的两个元素进行比较
       3.3 在内层for循环中,再嵌套一个if判断语句---目的:如果前一个元素大于后一个元素,则进行换位操作
       3.4 在循环到某次的时候,可能已经达到数组元素是有序的了,后续的循环次数可以省略。


*/
import java.util.Arrays;

public class ArrayTest04 {

    public static void main(String[] args) {
        // 1. 创建数组
        int[] arr = { 56, 23, 88, 38, 99, 12, 78, 59, 100, 77 };
        // 排序之前,遍历数组
        System.out.println("排序之前:" + Arrays.toString(arr));
        // 2.嵌套for循环
        int temp = 0; // 作用: 充当第三方变量,为换位做准备
        boolean flag = true; // 为什么此变量的值变为false
        // 2.1 外层for循环控制循环次数
        int i = arr.length;
        while(flag) {

            flag = false;
            // 2.2 内层for循环控制相邻的两个元素进行比较
            for (int j = 0; j < i-1; j++) {
                // 3.在内层for循环中,再嵌套一个if判断语句
                flag = false;
                if (arr[j] > arr[j + 1]) {
                    // 如果条件满足,则进行换位操作
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                    flag = true;
                }

                // 每一次循环,排序的结果

            }
            System.out.println("第" + (arr.length-i+1) + "次循环排序的结果");
            for (int k = 0; k < arr.length; k++) {
                System.out.print(arr[k] + "\t");
            }
            System.out.println();
            i--;

}
        // 4.输出结果
        // 排序之后,遍历数组
        System.out.println("排序之后:" + Arrays.toString(arr));

    }
}
输出结果:
排序之前:[56, 23, 88, 38, 99, 12, 78, 59, 100, 77]
第1次循环排序的结果
23  56  38  88  12  78  59  99  77  100 
第2次循环排序的结果
23  38  56  12  78  59  88  77  99  100 
第3次循环排序的结果
23  38  12  56  59  78  77  88  99  100 
第4次循环排序的结果
23  12  38  56  59  77  78  88  99  100 
第5次循环排序的结果
12  23  38  56  59  77  78  88  99  100 
排序之后:[12, 23, 38, 56, 59, 77, 78, 88, 99, 100]
阅读更多

没有更多推荐了,返回首页