数组的常见操作

 遍历

 方式1: 

    public static void printArray(int[] arr) {
        for(int x=0; x<arr.length; x++) {       //arr.length获取数值长度
            System.out.println(arr[x]);
        }
    }

 方式2: 

    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) {
                System.out.println(arr[x] + "]");
            }
            else {
                System.out.println(arr[x] + ",");
            }
        }
    }

 最值 

最大值 

    public static int getMax(int[] arr) {
        int max = arr[0];

        for (int x=1; x<arr.length; x++) {
            if (arr[x] > max);
                max = arr[x];
        }
        return max;
    }

 最小值 

    public static int getMin(int[] arr) {
        int min = arr[0];

        for (int x=1; x<arr.length; x++) {
            if (arr[x] < min);
                min = arr[x];
        }
        return min;
    }

 逆序 

方式1: 

    public static int reverse (int[] arr) {
        for (int x=0; x<arr.length/2; x++) {
            int temp = arr[x];
            arr[x] = arr[arr.length-1-x];
            arr[arr.length-1-x] = temp;
        }
    }

 方式2: 

    public static int reverse(int[] arr) {
        for (int start=0,end=arr.length-1; start<=end; start++,end--) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }

 查表 

    public static String getString(String[] strArray,int index) {
        return strArray[index];
    }

 基本查找(数组无序) 

方式1: 

    public static int getIndex(int[], int value) {
        for (int x=0; x<arr.length; x++)
            if(arr[x] == value) {
                return x;
            }
        return -1;
    }

 方式2: 

    public static getIndex(int[] arr, int value) {
        int index = -1;

        for(int x=0; x<arr.length; x++)
            if(arr[x] = value) {
                index = x;
                break;
            }
        return index;
    }

 二分查找

前提：数组中的元素要有序

    public static int halfSeach_2(int[] arr,int key){
        int min,max,mid;
        min = 0;
        max = arr.length-1;
        mid = (max+min)>>1; //(max+min)/2;
        while(arr[mid]!=key){
            if(key>arr[mid]){
                min = mid + 1;
            }
            else if(key<arr[mid])
                max = mid - 1;
            if(max<min)
                return -1;
            mid = (max+min)>>1;    
        }
        return mid;
    }

排序 

冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。

    public static void bubbleSort(int[] arr) {
        for(int x=0; x<arr.length-1; x++) {
            for(int y=0; y<arr.length-1-x; y++) {
                if(arr[y] > arr[y+1]) {
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
    }

选择排序

把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。

    public static void selectSort(int[] arr) {
        for(int x=0; x<arr.length-1; x++) {
            for(int y=x+1; y<arr.length; y++) {
                if(arr[x] > arr[y]) {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }

快速排序

快速排序的思想是分治思想。主要原理是将数组分为A[p..q-1] 和A[q+1..r]，然后调整元素使得A[p..q-1]小于等于q，也小于等于A[q+1..r]。然后不断的递归，到最后就排序完成。

 

更多算法教程，请移步：

http://ahalei.blog.51cto.com/