java面试之数组常见操作

写在前面的话

出去面试笔试部分少不了有一道数组题，常见有让你编程找出数组的最大值，数组排序，二分查找等，这些都是面试高频的一个部分，掌握了这个能给我们面试多增加一个胜算。

手写找出数组最大值

public class FindMax {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3,66,23};
        System.out.println(FindMax.getMax(arr));
    }

    public static int getMax(int[] arr) {
        if (arr != null && arr.length > 0) {
            int max = arr[0];
            for (int i = 0; i < arr.length; i++) {
                if (max < arr[i]) {
                    max = arr[i];
                }
            }
            return max;
        }
        return -1;
    }
}

冒泡排序

  /**
     * 原始冒泡排序算法
     * N个数字要排序完成，总共进行N-1趟排序，
     * 每i趟的排序次数为(N-i)次，所以可以用双重循环语句，
     * 外层控制循环多少趟，内层控制每一趟的循环次数
     * 冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。
     * 如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，
     * 第二趟排序的时候，只需要比较除了最后一个数以外的其他的数
     * 同样也能找出一个最大的数排在参与第二趟比较的数后面，
     * 第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，
     * 没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。
     *
     * @param arr
     */
    public static void bubbleSort(int[] arr) {
        // 定义交换变量
        int temp = 0;
        // 外层for循环表示(n-1)趟排序
        for (int i = 0; i < arr.length - 1; i++) {
            // 内循环表示一趟排序需要排序的次数，因最后一个是最大数值无需比较，所以这里-i
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

选择排序

    public static int[] selectSort(int[] arr) {
        if (arr != null && arr.length > 0) {
            int temp = 0;
            for (int i = 0; i < arr.length - 1; i++) {
                for (int j = i + 1; j < arr.length; j++) {
                    if(arr[i]>arr[j]) {
                        temp=arr[i];
                        arr[i]=arr[j];
                        arr[j]=temp;
                    }
                }

            }
        }
        return arr;
    }

快速排序

 public static int getPivotIndex(int[] arr, int start, int end) {
        int pivot = arr[start];
        int left = start;
        int right = end;
        int index = start;
        while (right >= left) {
            if (arr[right] < pivot) {
                arr[left] = arr[right];
                index = right;
                left++;
                break;
            }
            right--;
        }

        while (right >= left) {
            if (arr[left] > pivot) {
                arr[right] = arr[left];
                index = left;
                right--;
                break;
            }
            left++;
        }

        arr[index] = pivot;
        return index;

    }


    public static void quickSort(int[] arr, int start, int end) {
    	// 递归结束条件
        if (start >= end) {
            return;
        }
        int pivot = getPivotIndex(arr, start, end);
        quickSort(arr, start, pivot - 1);
        quickSort(arr, pivot + 1, end);
    }