7.19笔记

数组: 
    在java中的作用?
      用来存储多个数据的  容器;
     数组的特点: 数组的长度一旦确定不能改变
                 数组必须通过 索引 来获取元素，(从0开始，到数组长度-1结束) 
                 数组只允许存储相同元素的数据
                 数组只允许促成农户相同数据类型的数据
  java中提供了几种定义数组的格式: 
     一维数组: 
       1.动态初始化: 
                 数据类型[] 变量名= new 数据类型[长度];
                 
                 变量名.length;  获取数组长度
            
            例如: int[] arr = new int[3];
                  arr[0] = 1;
                  arr[1] = 5;
                  arr[2] = 8;
                  arr[3] = 9;
                  
                  Exception 异常 
                  ArrayIndexOutOfBoundsException
            
            1.直接输出 (System.out.println(arr[0]))
            2.遍历数组 (循环输出)
            
       2.静态初始化:
               数据类型[] 变量名 = {2,5,6,1,3}; 
  
   两个关键字: 
     break ,  continue; 
     
     break : 终止"当前"循环  ,注意 嵌套情况下
     continue: 终止本次循环，进行下一次循环，
============================================================           
多维数组:    二维数组                   
   语法: 
    动态初始化:
     数据类型[][] 变量名 = new 数据类型[3][2];  
    
    第一个[] 代表 一个二维数组中 有几个 一维数组;
    行
    
    第二个[] 代表一个一维数组中 有个 元素  
    列  
    
     静态初始化:   
       数据类型[][] 变量名 = { {元素 } , {元素 }};
     
  
 
//静态初始化
int[] newArr = new int[]{4,5,6,3};
//静态初始化
int[][] haha = new int[][]{{3,5,1} , {2,3} };
=============================================================
排序算法:  内存排序
   {4,2,35,12,35,3}
   我让你 按顺序输出  ， 从小到大 ， 从大到小 进行 输出
  1.冒泡排序: 烧热水   
          原理: 相邻的两个数比较，大数向右移动， 放到整个数组的末尾
              这算 一轮排序 结束，进行第二次 比较，
              
         int[] arr = {3,41,7,12,1,8};   
                        3,7,41,12,1,8
                        3,7,12,41,1,8
                        3,7,12,1,41,8
                        3,7,12,1,8,41
                        
                        3,7,12,1,8
                        
                        3,7,1,12,8
                        3,7,1,8,12
                        
                        3,7,1,8
                                                
                        
            //控制的比较次数
            for(int i = 0;i < arr.length-1 ;i++){ 模板代码
                 //获取元素， 和 索引
                 for( int j = 0 ;j < arr.length-1-i  ;  j++){
                     if(arr[j] > arr[ j + 1]){
                          int temp = arr[j];  
                          arr[j] = arr[j+1]; //替换
                          arr[j+1] = temp;
                     }
                 }
            }
           
           
            for(int i = 0 ;i < arr.length ;i++){
                Sytem.out.println(arr[i]);
            }
=======================================================  
  2.选择排序:    
         原理: 找到整个数组中， 元素最小值的下标
              然后拿着 整个 元素 ，跟 第一个有序序列比较
              如果小 就交换位置，不小，就继续比较
              int[] arr = {5,4,23,4,23,13,1,9};
              
              for(int i = 0; i < arr.length ;i++){
                    int min = i; //记录最小的下表
                 for(int j = i+1 ; j < ? ; j++){
                      if(arr[min] > arr[j]){
                          min = j;
                      }
                 }
                  int temp = arr[i]; // 1 
                  arr[i] = arr[min];
                  arr[min] = temp;    
              }
=====================================================================                    
  3.插入排序:
     
      int[] arr = {3,2,1,6,3,8};
                   2,3,1,6,3,8    
                               
                                           
      假设第一个元素 就是有序的 .我们 要从第二个元素开始做比较
       for(int i = 1; i < arr.length ;i++){
           //将第二个元素 临时的存储下来;
           int temp = arr[i];
        
        int j = i;
         while(j > 0 && temp < arr[j-1]){
              arr[j-1] = temp;
              j--;
         } 
         
               arr[j] = arr[j-1];
       }
                  
    

}