Java总结第四章

本章目标：
1数组拷贝
2.排序算法（重点分析）
3.二维数组
难点：快速排序算法的理解和逻辑

一.数组的拷贝

 System类中有一个静态方法：

 public static native void arraycopy(Objectsrc,int  srcPos,  Object dest, int  destPos,  int  length);

 参数解释：

  src: 源数组

  srcPos: 源数组的起始位置

  dest: 目标数组

  destPos:目标数组的起始位置

  length:拷贝的数组元素个数

例如：

package copy;

public class ArrayCopy {

      public static void main(String[] args) {

              int[] a={1,2,3,4,5,6,7,8,9};

              int[] b={11,22,33,44,55,66,77,88,99};

              System.arraycopy(a,1,b,4,3);

              System.out.println("复制后的数组：");

               for (int i = 0; i < b.length; i++) {

                  System.out.print(b[i]+"  ");

                }

      }

}

打印输出结果如下：

二.排序算法

1.冒泡排序

  原理：每一趟确定只能将一个数归位。如果有n个数进行排序，只需把n-1个数归位，即进行n-1趟操作。而每一趟都需要从第一位开始，进行相邻的两个数的比较，把较小的一个放在后面，比较完成后向后诺一位继续比较下面两个相邻数的大小，重复以上步骤，直到最后一个尚未归位的数归位。（已经归位的数不需要再比较）

举例：

package sort;

public class BubbleSort {

      public static void main(String[] args) {

       int[] a={22,55,11,66,88,77,44,99,33};

       bubbleSort(a);

       }

       public static void bubbleSort(int[] a){

      for (int i = 1; i <=a.length-1; i++) {   // 外层循环控制比较的“趟数”

         boolean flag=true;

      for(int j=0;j<a.length-i;j++){   // j变量是数组的索引(下标)，j也控制着当前趟的“两两比较”的次数

           if(a[j]>a[j+1]){

             int temp=a[j];

             a[j]=a[j+1];

             a[j+1]=temp;

             flag=false;

          }

      }

          if(flag){   // 如果当前“趟”已经排号序，则不必进行下一趟的排序，直接跳出外层循环

             break;

          }

      }

   }

}

2.插入排序

原理：构建有序序列，对没有排序的数据在已排序序列中从后向前扫描，并找到相应位置插入，使其有序排列

步骤：

1.从第一个元素开始排序，该元素可以被认为已经被排序

2.取出下一个元素，在已经排序的元素序列中以从前往后或从后往前的顺序扫描，按大小插入到有序序列中

3.重复第二个步骤，直到找到已经排序的元素小于等于新元素的位置，将新元素插入到下一位置中

4.重复2,3步骤，直到全部插入完为止

例如：

package sort;

public class InsertSort {

   public static void main(String[] args) {

        int[] a={22,55,11,66,88,77,44,99,33};

        insertSort(a);

        System.out.println("插入排序的结果：");

        for (int i = 0; i < a.length; i++) {

          System.out.print(a[i]+"  ");

         }

    }

     public static void insertSort(int[] a){

         for (int i = 1; i <=a.length-1; i++) {

           int data=a[i];  // 当前“指示灯数据”

           int j=i-1;   // 使用j变量记录“指示灯数据”的前一个数据的索引

              while(j>=0 && data<a[j]){

            a[j+1]=a[j];   // 后移“指示灯”数据前面的数据

              j--;

            }

          a[j+1]=data;

        }

     }

}

3.快速排序（三种排序方法中较快的）

步骤：

1.每次排序的时候在序列中取一个作为一个分界值，将小于等于分界值的放在左边，大于等于的放在右边

2.将分好的左右两侧的子序列做如上的同样操作，直到完成排序。

优点：跳跃式交换，速度快

例如：

package sort;

public class QuickSort {

      public static void main(String[] args) {

        int[] a={22,55,11,66,88,77,44,99,33};

       quickSort(a,0,a.length-1);

        for (int i = 0; i < a.length; i++) {

         System.out.print(a[i]+"  ");

        }

     }

     public static void quickSort(int[] array,int start,int end){

           if(start>=end){

           return;   // 结束方法

     }

      int data=array[start];   // 将起始索引执行的值作为“分界值”

      int i=start+1;  // 记录向右移动的位置（“红军”）

      int j=end;   // 记录向左移动的位置("蓝军")

        while(true){

          while(i<=end && array[i]<data){

             i++;   // 索引右移

         }

           while(j>=start+1 && array[j]>data){

              j--;   // 索引左移

          }

         if(j>i){

           int temp=array[i];

           array[i]=array[j];

           array[j]=temp;

         }

        else{

             break;

       }

    }

      // “蓝军”与“分界值”交换位置

       array[start]=array[j];

       array[j]=data;   

       quickSort(array,start,j-1);   // 递归调用完成“分界值”左边的排序

        quickSort(array,j+1,end);   // 递归调用完成“分界值”右边的排序

      }

}

三.二维数组

1.二维数组的声明与初始化（与一维数组相似）

* 二维数组声明与实例化结构：

数据类型[][] 数组名称=new 数据类型[行的个数][列的个数];

注意：二维数组的length属性就是它所包含的“行的个数”。

二维数组访问具体元素的语法：  数组名称[行的索引][列的索引]

*二维数组的定义

数据类型[][]    数组名称；

数组类型  数组名称[][]；

两种形式都可以。

*静态初始化

结构：

数据类型[][] 数组名称={

                            {元素1,元素2,....},

                            {元素1,元素2,....},

                             ...

                            };

例：int array[][]={{1,2},{1,2,3}}

注意：由于把二维数组看作是数组的数组，数组的空间不是连续分配的，所以不要求二维数组每一维大小相同。