1.5.Java循环嵌套,数组,排序,Bubble Sort

循环 数组 排序 冒泡排序

1.三种循环结构的更加适用情况

1. while:”当…”
2. do…while:”直到”
3. for:固定次数循环

2.嵌套循环

1. 循环中套循环,一般多行多列时使用,外层控制行,内层控制列
2. 执行规则:外层循环走一次,内层循环走所有次
3. 建议:循环的层数越少越好,若必须超三层才能解决,说明设计有flaw
4. break只能跳出一层循环

3.程序运算

1. 算法:解决问题的流程/步骤(顺序,分支,循环)
2. 数据结构:讲数据按照某种特定的结构来保存.
3. 设计良好的数据结构会导致好的算法

4.数组

1. 相同数据类型元素的集合
2. 是一种数据类型(引用类型)
3. 数组的定义
   int[] arr = new int[4];
4. 数组的初始化
   int[] arr = new int[4];
   int[] arr = {1,4,6,8};
   int[] arr = new int[]{1,4,6,8};
   int[] arr;
   arr = {1,4,6,8};//编译错误
   arr = new int[]{1,4,6,8};//正确
5. 数组的访问
   
   1. 访问 arr.length 可以获取数组的长度
   2. 通过下表/索引来访问数组中的元素
      int[] arr = new int[3];
      arr[0] = 100;
      arr[1] = 200;
      arr[2] = 300;
      arr[3] = 400;//编译错误,数组下表越界

6. 数组的遍历
   java
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
arr[i] = 100;
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}

7. 数组的复制

   1. System.arraycopy(a,1,a1,0,4); // 原数组,原数组复制起始下标,复制数组,复制数组起始下标,长度
   2. int[] a1 = Arrays.copyOf(a,6);
      a = Arrays.copyOf(a,a.length+1); //扩容
8. 数组的排序
   
   1. Array,sort(arr);//升序,效率高 要引入 java.util.Arrays; 类
   2. 冒泡排序 Bubble Sort
      
      • 4个数冒3轮
        
        • 每一轮都是从第1个元素开始冒 每一次都是和它的下一个元素比
        • 冒出来了就不带它玩了

Bubble Sort

    public class BubbleSort {//冒泡排序

    public static void main(String[] args) {
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100) + 1;
            System.out.print(arr[i] + " ");
        }
        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 = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
      }
    }