java(4)--排序算法及二维数组

声明：由于学习使用环境为JDK1.8,所有有关java代码均在JDk1.8环境下测试通过，如果环境发生变化，可能会发生错误！

一、数组拷贝

 System类中有一个静态方法：
 public static native void arraycopy(Object src, int  srcPos,  Object  dest,  int  destPos,  int  length);

参数解释：
     src:  源数组
     srcPos:  源数组的起始位置
     dest:  目标数组
     destPos:目标数组的起始位置
     length:拷贝的数组元素个数

Example:

 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趟排序(可优化)，每一趟排序都会通过“两两交换”的方式对数据进行比较，每一趟排序后都会将本趟排序的最大值“冒”到后面。

Example:

package sort;

public class BubbleSort {

    public static void main(String[] args) {
        int[] a={11,22,55,66,88,99,33,22};
        bubbleSort(a);
    }
    public static void bubbleSort(int[] b){
        for(int i=1;i<=b.length-1;i++){   //趟数
            for(int j=0;j<b.length-i;j++){   //比较次数
                if(b[j]>b[j+1]){
                    int temp=b[j+1];
                    b[j+1]=b[j];
                    b[j]=temp;
                }
            }
        }
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i]+"  ");
        }
    }
}

2.插入排序

对一个有n个元素的数据序列，排序需要进行n-1趟插入操作(可优化)。
第一趟插入将第2个元素插入前面的有序子序列(此时前面只有一个元素)。
第二趟插入将第3个元素插入前面的有序子序列，前面两个元素是有序的。

第n-1趟插入将第n个元素插入前面的有序子序列，前面n-1个元素是有序的。

Example:

package sort;

public class InsertSort {

    public static void main(String[] args) {
       int[] a={11,44,55,33,66,88,99,22};
       insertSort(a);
      
    }
    public static void insertSort(int[] b){
        for (int i = 1; i <= b.length-1; i++) {
            int data=b[i];  //指示灯数据
            int j=i-1;     //指示灯数据的前一项
            while(j>=0 && data<b[j]){
                b[j+1]=b[j];
                j--;
            }
            b[j+1]=data;
            
        }
         for (int i = 0; i < b.length; i++) {
                System.out.print(b[i]+"  ");
            }
    }
}

3.快速排序

 从待排序的数据序列中任取一个数据(如第一个数据)作为分界值，所有比它小的数据元素放到左边，所有比它大的数据元素放到它的右边。

接下来，对左右两个子序列按照上述方法进行递归排序，直到排序完成。
Example：

package sort;

public class QuickSort {

    public static void main(String[] args) {
         int[] a={11,44,55,33,66,88,99,22};
         quickSort(a, 0, a.length-1);
         for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"  ");
        }
    }
    public static void quickSort(int[] a,int start,int end){
        if(start>end){
            return;
        }
        int data=a[start];     //分界值
        int i=start+1;         //"红军"向右移动，（寻找大于分界值的数）
        int j=end;             //"蓝军"向左移动，（寻找小于分界值的数）
        while(true){
            while(i<=end && a[i]<=data){
                i++;   //索引右移
            }
            while(j>=start+1 && a[j]>=data){
                j--;   //索引左移
            }
            //交换a[i]和a[j]的值
            if(j>i){
                int temp=a[j];
                a[j]=a[i];
                a[i]=temp;
            }else{
                break;
            }
        }
        //交换分界值（a[start]）和a[j]的值
        a[start]=a[j];
        a[j]=data;
        //递归
        quickSort(a, start,j-1);
        quickSort(a, j+1,end);
    }
}

三、二维数组

1.二维数组的声明与实例化：
    数据类型[][] 数组名称=new 数据类型[行的个数][列的个数];

   eg1: String[][] array=new String [4][3];

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

              二维数组的元素是一维数组

 2.二维数组访问具体元素的语法：  数组名称[行的索引][列的索引]
 3.二维数组的静态初始化
    数据类型[][] 数组名称={
                            {元素1,元素2,....},
                            {元素1,元素2,....},
                    ca         ...
                            };

eg2: String[][]={

  {"cat","dog","tiger"},{"table"},{"C","C++","PHP","JAVA"}

  };

Example1：

package sort;

public class ArrayTwo {

    public static void main(String[] args) {
    int[][] a2={
            {1,2,3},
            {1,2},
            {2,4,5,6,8}
    };
    for (int i = 0; i < a2.length; i++) {
        for(int j=0;j<a2[i].length;j++){
            System.out.print(a2[i][j]+"  ");
        }
        System.out.println();
    }
    }

}

Example2：

package sort;

public class ArrayTwo {

    public static void main(String[] args) {
    int[][] a1=new int[3][4];
    a1[0][0]=2;
    a1[0][1]=2;
    a1[1][0]=2;
    a1[1][3]=2;
    a1[2][1]=2;
    a1[2][3]=2;
        for (int i = 0; i < a1.length; i++) {
        for(int j=0;j<a1[i].length;j++){
            System.out.print(a1[i][j]+"  ");
        }
        System.out.println();
    
    }

}
}

比较Example1：与Example2：

Example1采用的方法是“用多少给多少”，使用了多少空间，系统就分配多少空间；

Example2所用的方法是内存直接分配3*4的空间，没有用的空间默认为0。