数组及基本排序算法

数组

数组定义

一维数组

dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, …, valuek};

二维数组

type[][] typeName = new type[typeLength1][typeLength2];

Arrays类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

asList

public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
}

• 返回固定大小列表，返回的ArrayList是内部类，不是经常使用的集合类。只能进行查看或者修改，不能进行添加或者删除；
• 引用类型数据&基本类型数组

String[] str = {"a","b","c"};
List<String> listStr = Arrays.asList(str);
System.out.println(listStr.size());//3

int[] i = {1,2,3};
List<int[]> listI = Arrays.asList(i);//注意这里List参数为 int[] ，而不是 int
System.out.println(listI.size());//1

Integer[] in = {1,2,3};
List<Integer> listIn = Arrays.asList(in);//这里参数为int的包装类Integer，所以集合长度为3
System.out.println(listIn.size());//3

• 返回的列表ArrayList里面的元素是引用，不是独立出来的对象

String[] str = {"a","b","c"};
List<String> listStr = Arrays.asList(str);
//执行更新操作前
System.out.println(Arrays.toString(str));//[a, b, c]
listStr.set(0, "d");//将第一个元素a改为d
//执行更新操作后
System.out.println(Arrays.toString(str));//[d, b, c]

• 获取可增删改查的List

String[] str = {"a","b","c"};
List<String> listStr = new ArrayList<>(Arrays.asList(str));
listStr.add("d");

sort

该方法是用于数组排序，在 Arrays 类中有该方法的一系列重载方法，能对7种基本数据类型，包括byte,char,double,float,int,long,short 等都能进行排序，还有 Object 类型（实现了Comparable接口），以及比较器Comparator 。

• 基本类型
  Arrays.sort(int[] num);默认升序排序，如果进行降序排序，有以下方式：
  • 利用Collections的reverseOrder方法
    Arrays.sort(arr,Collections.reverseOrder());//不能使用基本类型
  • 利用Comparator接口复写compare方法

Comparator cmp=new MyComparator();
		Arrays.sort(arr,cmp);

public class MyComparator implements Comparator<Integer> {

	@Override
	public int compare(Integer arg0, Integer arg1) {
		// TODO 自动生成的方法存根
		return arg0 > arg1 ? -1 : 1;
	}

}

• 对象类型数组
  可以实现 Comparable 接口，重写 compareTo 方法进行排序

• 没有实现Comparable接口的，可以通过Comparator实现排序

Arrays.sort(p,new Comparator<Person>() {
      @Override
     public int compare(Person o1, Person o2) {
         if(o1 == null || o2 == null){
             return 0;
         }
         return o1.getPage()-o2.getPage();
      }
 });    

binarySearch

二分法查找数组中某个元素，Arrays.binarySearch(int[] num, 2)
详细参考：
https://blog.csdn.net/qpzkobe/article/details/78897762

copyOf

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

equals和deepEquals

equals:比较两个数组中对应位置的每个元素是否相等
deepEquals：可以闭阿娇多维数组

fill

给数组复制，并能指定某个范围赋值

toString和deepToString

toString：打印以为数组的元素
deepToString：用来打印多层嵌套的数组元素

排序算法

简单选择排序

public static void selectSort(int[] nums){
        for(int i = 0; i < nums.length; i++){
            int min = i;
            for(int j = i+1; j < nums.length; j++){
                if(nums[j] < nums[min]){
                    min = j;
                }
            }
            if(nums[min] < nums[i]) {
                int tmp = nums[i];
                nums[i] = nums[min];
                nums[min] = tmp;
            }
        }
    }

堆排序

public static void heapSort(int[] nums){
        int len = nums.length;
        for(int i = len/2-1; i >= 0; i--){
            heapAdjust(nums,i,len);//第一个非叶子结点 arr.length/2-1
        }
        for(int i = nums.length-1; i > 0; i--) {
            int tmp = nums[i];
            nums[i] = nums[0];
            nums[0] = tmp;
            heapAdjust(nums, 0,i);
        }
    }

    private static void heapAdjust(int[] nums, int i, int len) {
        for(int j = 2*i+1; j < len; j = 2*j+1){
            j = j+1 >= len || nums[j] > nums[j+1]  ? j : j+1;
            if(nums[i] < nums[j]){
                int tmp = nums[i];
                nums[i] = nums[j];
                nums[j] = tmp;
            }
            i = j;
        }
    }

冒泡排序

public static void bubbleSort(int[] nums){
        boolean mark = false;
        for(int i = nums.length; i > 0; i--){
            for(int j = 0; j < i; j++){
                if(j+1 < i && nums[j] > nums[j+1]){
                    int tmp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = tmp;
                    mark = true;
                }
            }
            //一次没有元素交换，说明已经有序
            if(!mark){
                break;
            }
        }
    }

归并排序

public class MergeSort {
    private static int[] tmp;
    public static void mergeSort(int[] nums){
        tmp = new int[nums.length];
        mergeSort(nums,0,nums.length-1);
    }

    private static void mergeSort(int[] nums, int startIndex, int endIndex) {
        if(startIndex < endIndex){
            int mid = (startIndex + endIndex) / 2;
            mergeSort(nums,startIndex,mid);
            mergeSort(nums,mid+1,endIndex);
            merge(nums,tmp,startIndex,mid,endIndex);
        }
    }

    private static void merge(int[] nums, int[] tmp, int startIndex, int mid, int endIndex) {
        int i = startIndex;
        int j = mid+1;
        int k = startIndex;
        while(i <= mid && j <= endIndex){
            if(nums[i] <= nums[j]){
                tmp[k++] = nums[i++];
            }else {
                tmp[k++] = nums[j++];
            }
        }
        while(i <= mid){
            tmp[k++] = nums[i++];
        }
        while (j <= endIndex){
            tmp[k++] = nums[j++];
        }
        for(int m = startIndex; m <= endIndex; m++){
            nums[m] = tmp[m];
        }
    }

    public static void main(String[] args) {
        int[] nums = {3,1,3,5,7,8,5,4};
        mergeSort(nums);
        System.out.println(Arrays.toString(nums));
        System.out.println(Arrays.toString(tmp));
    }
}

基数排序

快速排序