数据结构与算法----->数据结构----->数组

概述：

　　1.数组的大小要给定，并且一旦给定之后就不允许再有变化 

　　2.数组这种数据结构下数据的插入、查找、删除算法的复杂度

　　3. Java中与数组相关的语法知识

　　　　3.1一维数组相关java语法知识 

　　　　　　　　　　创建数组： 

　　　　　　　　　　数组长度： 

　　　　　　　　　　访问数组元素： 

　　　　　　　　　　在java中使用数组的一个简单例子：（P26） 

　　　　3.2二维数组相关java语法知识

　　4. Java设计出的用于操作数组元素的相关算法（自定义算法） 4

　　5. 特殊的数组（有序数组） 4

　　6. 有序数组和无序数组的比较 5

　　7. 复杂类型的数组(如以Student对象为基本元素的数组) 5

   　8. 为什么不用数组表示一切....................................................................................... 5

详细讲解：

　　1.数组的大小要给定，并且一旦给定之后就不允许再有变化

　　2.数组这种数据结构下数据的插入、查找、删除算法的复杂度

数据插入	允许元素重复的情况下		直接插入就可以，插入到数组尾部（一步完成）
	不允许元素重复的情况下		要先和数组中已有元素比较，然后再插入
数据查找	允许元素重复的情况下	查找出第一个该元素
		查找出所有该元素
	不允许元素重复的情况下
数据删除	不允许元素重复的情况下		查找到该元素------->后面的元素左移
	允许元素重复的情况下	删除第一个该元素
		删除所有该元素

　　　　　　　　

　　3.Java中与数组相关的语法知识

　　　3.1java语言中与一维数组相关的语法知识

• • 在java中，将数组看成类对象　　
  • 创建数组： 
    • 因为java中数组并不是基本数据类型，java将数组当做对象来看待，所以java中使 用数组一定要使用new来给数组分配内存空间
    • 在使用new给数组分配内存空间的时候，必须要指明数组大小
      • 

      • 

      • 

  • 数组元素的初始化：

    • • 不给数组元素赋值的情况下，数组元素为null.

      • 
      • 也可以使用如下方法对数组进行初始化：
      • 

         

  • 数组长度：
    • • 
  • 访问数组元素： 
    • • 

      • 　　　　

  • 在java中使用数组的一个简单例子：（P26） 4

　　 3.2 java语言中与二维数组相关的语法知识

• • • 上面一小节讲的都是一维数组相关的语法知识，包括一维数组的声明、分配内存空间、初始化、索引等等，下面来讲述二维数组相关的语法知识。
    • 其实二维数组和一维数组是基本上是相同的
    • 二维数组的声明：
      • • 

        • int arrayName[][];
          int[][] arrayName;

          
          　　　　
    • 为二维数组分配内存空间：
      • • 因为java中是将数组看作类对象，所以也要使用new关键字来为数组分配内存空间
        • 为二维数组分配内存空间有两种方法：
          • • 方法一，直接为每一维数组分配内存空间
              • 
                　　
            • 方法二，分别为每一维数组分配内存空间　
              • 

                 

                　　　　　　　　
    • 二维数组的初始化：

      • • int array2[][]={{1,2},{1,2},{1,1}};//方法二
          arrayName[0][0]=1;//方法三

          　　　　
    • 访问二维数组中的元素（即索引）：
      
      • • 二维数组中行下标是从0开始的， 列下标也是从0开始的
        • 行数=arrayName.length　　　
        • 列数=arrayName[i].length
    • 实际使用实例：

      • • /**
           * @author chen
           * @date 20170305
           * @description 本程序讲述java语言中二维数组相关的语法知识
           *1） 二维数组的声明
           *2） 为二维数组分配内存空间
           *3） 二维数组的初始化
           *4） 访问二维数组中的元素
           * */
          package array;
          
          public class TwoDimentionArray {
              public static void main(String[] args){
                  /**1)二维数组的声明
                   * 
                   */
                  int array1[][];
                  int[][] array2;
                  
                  /**2)为二维数组分配内存空间(共有两种方法)
                   *         方法一，直接为每一维都分配相同长度的内存空间
                   *         方法二，分别为每一维分配内存空间（各维长度可以不同）
                   */
                  //方法一，直接为每一维都分配相同长度的内存空间
                  array1=new int[2][2];
                  //方法二，分别为每一维分配内存空间（各维长度可以不同）
                  array2=new int[2][];
                  array2[0]=new int[3];
                  array2[1]=new int[6];
                  
                  /**
                   * 可以在数组的声明过程中直接为数组分配内存空间*/
                  int[][] array3=new int[2][3];
                  
                  /**3)二维数组的初始化(共有三种方法)
                   *         方法一，
                   *         方法三，使用for循环分别为数组的每个元素赋值
                   * */
                  //方法一，
                  int array5[][]={{1,2,2},{3,1,2}};
                  /*方法三，使用for循环分别为数组的每个元素赋值
                   *         *可以为二维数组的各行分配不同列数
                   *         *二维数组的行数=arrayName.length
                   *         *二维数组第i行的列数=arrayName[i].length,其中i=0,1...
                   */
                  int arrayName[][]=new int[3][];//并不指定列数，为的是下面可以分别为每一行分配列长度
                  for(int i=0;i<arrayName.length;i++){//arrayName.length返回值是二维数组的行数
                      arrayName[i]=new int[i+1];//为二维数组的第i行分配长度为i+1的内存空间
                      for(int j=0;j<arrayName[i].length;j++){//arrayName[i].length返回值是该二维数组的第i行的长度
                          arrayName[i][j]=(i+1)*(j+1);
                          System.out.print(arrayName[i][j]+" ");
                      }
                      System.out.println("");
                  }
              }
          
          }

          结果：

          1 
          2 4 
          3 6 9 

    •  

      二维数组的遍历

      • • /**5)遍历二维数组
                   *        方法一，使用双层for循环来遍历一个二维数组
                   *        方法二，使用for each来遍历一个二维数组
                   * */
                  System.out.println("\n二维数组的遍历");
                  //方法一，使用双层for循环来遍历一个二维数组
                  System.out.println("方法一，使用双层for循环来遍历一个二维数组");
                  int arrayName2[][]={{1,2,3},{1,1,0,6},{1,1}};//现在只是指定了行数并不指定列数，为的是下面可以分别为每一行分配列长度
                  for(int i=0;i<arrayName2.length;i++){//arrayName.length返回值是二维数组的行数
                      for(int j=0;j<arrayName2[i].length;j++){//arrayName[i].length返回值是该二维数组的第i行的长度
                          System.out.print(arrayName2[i][j]+" ");
                      }
                      System.out.println("");
                  }//end for
                  //方法二，使用for each来遍历一个二维数组
                  System.out.println("方法二，使用for each来遍历一个二维数组");
                  int arrayName3[][]={{1,2,3},{1,1,0,6},{1,1}};
                  for(int tmp[]:arrayName3){//使用tmp:int[]存储二维数组中的一行
                      for(int element:tmp){//使用element:int存储tmp:int[]中的一个元素
                          if(element==tmp.length){//判断元素是不是该行的最后一个元素
                              System.out.print(element);
                          }else{
                              System.out.print(element+"、");
                          }
                      }
                      System.out.println("");//换行
                  }

          运行结果：

          二维数组的遍历
          方法一，使用双层for循环来遍历一个二维数组
          1 2 3 
          1 1 0 6 
          1 1 
          方法二，使用for each来遍历一个二维数组
          1、2、3
          1、1、0、6、
          1、1、

           

          　　　　　　　　

　　4.Java设计出的用于操作数组元素的相关算法（自定义算法）

　　　　P28----LowArray.java

　　　　P31----HighArray.java

　　5.特殊的数组（有序数组）

• • 

    有序数组实现数据插入、查找、删除的算法：

    OrdArray.java     P40

　　5.有序数组和无序数组的比较

	有序数组	无序数组
定义	数组元素按照从小到大的顺序排列（不允许重复）	数组元素无序存放
插入	查找到元素，后面的元素依次后移	直接插入（一步即可完成）
查找特定元素	二分法查找	线性查找（特别对于元素非常多的情况下，时间复杂度远大于有序数组中的查找）
删除元素	二分法查找，后面的元素前移	线性查找，后面的元素前移

　　　　　　由于元素移动的时间复杂度比线性查找的时间复杂度大得多，所以有序、无序数组删除元素的算法运行的都相对很慢。

　　6.复杂类型的数组(如以Student对象为基本元素的数组)

　　　　　　P45-P49

　　　　Person.java

　　　　ClassDataArray.java

　　　　ClassDataApp.java（main函数，测试上述数组相关算法编写得是否正确）  

　　5.为什么不用数组表示一切

　　　　1)数组的插入、查找、删除操作的时间复杂度高

 　　　　　　　　

　　　　2）数组的大小需要在开始时就指定，使用起来非常不方便

 　　　　　　　　

　　　　　　　　

小结：

　　　　

 

　　　　算法中：

　　　　　　数组插入元素后，num++

　　　　　　数组删除元素后，num- - 不要忘记哦