Java_Array_基础

(1)Arrays.fill(int a[],int value); 将value值赋给数组a的每一个元素
(2)Arrays.fill(int a[],int fromIndex,int toIndex,int value);//{包括fromIndex,但不包括toIndex}
(3)Arrays.sort(Object obj);//根据comparable的接口实现比较
Java中的String数组类型的排序是根据字典的编排顺序排序的,所以数字在字母之前。大写字母在小写字母之前。
(4)Arrays.copyOf(T[] arr,int newLength);//数组的复制,newLength代表返回的数组的长度,当新数组的长度大于原来数组的长度,多余的部分则用0初始化(int 为0,char用null);
(5)Arrays.copyOfRange(T[] arr,int fromIndex,int toIndex);//(包括fromIndex但不包括toIndex)
(6)Arrays,binarySearch(Object[] obj,Object key);//二分法查找,
(7)Arrays.binarySearch(Object[] obj,int fromIndex,int toIndex,Object key);//使用此方法之前要先对数组进行排序，来获得准确的索引值，如果搜索的元素key在指定的范围内，则返回索引的值，否则返回-1或者-(fromIndex+1)
(8)数组排序:冒泡排序:
            冒泡排序——排序数组元素的过程：将小数往前放，将大数往后放。类似水中的气泡往上冒。0x01 基本思想
    冒泡排序就是对比相邻的元素值，如果满足条件就交换元素值。把较小的元素移到数组的前面，把大的元素移动到数组的后面。这样小的元素就像气泡一样移到了元素的顶部。0x02 算法示例
    冒泡算法由双层循环实现，外层循环用于控制排序轮数(轮数一般是要排序的元素的长度减一)，而内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置。对比和交换次数随排序轮数而减少。

    第一轮:第一个元素63和后面的一个元素4比较,63比4大,则63与4交换。交换后，63成为第二个元素，第二个元素和第三个元素比较，63比24大，则继续交换。继续比较下去，直至最后一个元素。
    第二轮，第一个元素开始，与后面的比较，相同的操作直到倒数第二个元素。
    ……继续操作直到排序任务完成。 0x03 算法实现

public static void sort(int[] arr)
    {
        for(int i=1;i<arr.length;i++)
        {
            //比较两个相邻的元素,较大的则往后冒泡
            for(int j=0;j<arr.length-i;j++)
            {
                if(arr[j]>arr[j+1])
                {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }

        }
    }

直接选择排序0x01 基本思想
  直接选择排序的基本思想是将指定排序位置与其他元素分别对比，如果满足条件就交换元素值。与冒泡排序相比，直接排序交换的次数更加的少，所以其速度也会更加的快。0x02 算法示例
  每一次从待排序列中选择一个最小的数，将其排列在已经排好序列的最后。

0x03 算法实现

public void chooseSort(int[] arr)
    {
        int index;
        for(int i=0;i<arr.length;i++)
        {
            index=i;
            for(int j=i+1;j<arr.length;j++)
            {
                if(arr[j]<arr[index])
                {
                    index=j;
                }
            }
            int temp=arr[i];
            arr[i]=arr[index];
            arr[index]=temp;
        }
    }

快速排序0x01 基本思想
    快速排序是一种既不浪费空间并且计算速度还很快的排序算法。采用分治法,找出一个基准数，然后将以这个基准数，分为比基准数小的左侧序列和比基准数大的右侧序列。递归执行直到无法再找出基准数。排序完成0x02 算法示例
    假设用户输入了如下数组：

下标	0	1	2	3	4	5
数据	6	2	7	3	8	9

创建变量i=0(指向第一个数据), j=5(指向最后一个数据), k=6(赋值为第一个数据的值)。
我们要把所有比k小的数移动到k的左面，所以我们可以开始寻找比6小的数，从j开始，从右往左找，不断递减变量j的值，我们找到第一个下标3的数据比6小，于是把数据3移到下标0的位置，把下标0的数据6移到下标3，完成第一次比较：

下标	0	1	2	3	4	5
数据	3	2	7	6	8	9

i=0 j=3 k=6
接着，开始第二次比较，这次要变成找比k大的了，而且要从前往后找了。递加变量i，发现下标2的数据是第一个比k大的，于是用下标2的数据7和j指向的下标3的数据的6做交换，数据状态变成下表：

下标	0	1	2	3	4	5
数据	3	2	6	7	8	9

i=2 j=3 k=6
称上面两次比较为一个循环。
接着，再递减变量j，不断重复进行上面的循环比较。
在本例中，我们进行一次循环，就发现i和j“碰头”了：他们都指向了下标2。于是，第一遍比较结束。得到结果如下，凡是k(=6)左边的数都比它小，凡是k右边的数都比它大：

下标	0	1	2	3	4	5
数据	3	2	7	6	8	9

如果i和j没有碰头的话，就递加i找大的，还没有，就再递减j找小的，如此反复，不断循环。注意判断和寻找是同时进行的。

然后，对k两边的数据，再分组分别进行上述的过程，直到不能再分组为止。

注意：第一遍快速排序不会直接得到最终结果，只会把比k大和比k小的数分到k的两边。为了得到最后结果，需要再次对下标2两边的数组分别执行此步骤，然后再分解数组，直到数组不能再分解为止(只有一个数据)，才能得到正确结果。
下面，我们用一个动图

原文链接：https://blog.csdn.net/qq_36186690/article/details/824704510x03 算法实现

/**
 * 快速排序
 * @param array
 */
public static void quickSort(int[] array) {
    int len;
    if(array == null
            || (len = array.length) == 0
            || len == 1) {
        return ;
    }
    sort(array, 0, len - 1);
}

/**
 * 快排核心算法，递归实现
 * @param array
 * @param left
 * @param right
 */
public static void sort(int[] array, int left, int right) {
    if(left > right) {
        return;
    }
    // base中存放基准数
    int base = array[left];
    int i = left, j = right;
    while(i != j) {
        // 顺序很重要，先从右边开始往左找，直到找到比base值小的数
        while(array[j] >= base && i < j) {
            j--;
        }

        // 再从左往右边找，直到找到比base值大的数
        while(array[i] <= base && i < j) {
            i++;
        }

        // 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
        if(i < j) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
        }
    }

    // 将基准数放到中间的位置(基准数归位)
    array[left] = array[i];
    array[i] = base;

    // 递归，继续向基准的左右两边执行和上面同样的操作
    // i的索引处为上面已确定好的基准值的位置，无需再处理
    sort(array, left, i - 1);
    sort(array, i + 1, right);
}