ArrayDemo

public class ArrayDemo {

    public static void main(String[] args) {
        int[] x = new int[3] ;
        int[] y = new int[3] ;
        x[0] = 23 ;
        y[0] = 98 ;
        x = y ;
        y = null ;
        System.out.println("x=" +x[0]+ "\n"+"y=" +y); 
    }
}

public class ArrayDemo2 {

    public static void main(String[] args) {    
        int[] arr = new int[]{1,3,5,7,9} ;
        /*
         对数组操作最基本的动作就是存和取;
         核心思想:就是对角标(下标)的操作.
         */
        System.out.println("length="+arr.length);
        for(int x=0;x<arr.length;x++) {
            System.out.println("arr["+x+"]="+arr[x]+";");
        }

        for(int x=arr.length-1;x>=0;x--) {
            System.out.println("arr["+x+"]="+arr[x]+";");
        }
    }
}

public class ArrayDemo3 {

    public static void main(String[] args) {

        int[] arr = new int[] { -1, -3, -5, -7, -9 };
        int max = getMax(arr) ;
        System.out.println("max="+getMax(arr)); 
        System.out.println("max="+getMax2(arr)); 
    }
    /*
            获取数组中的最大值. 
            思路:1.需要进行比价,并定义变量. 
            2.对数组中的元素进行遍历取出,和变量中记录的元素进行比较.
                如果遍历到的元素大于变量中的元素,就用变量记录较大的值. 
            3.遍历结束,该变量记录的就是最大值.
     */
    public static int getMax(int[] arr) {
        //用变量记录较大的值
        int maxElement = arr[0] ;   //初始化为数组中的一个元素
        for(int x=1;x<arr.length;x++) {
            if(arr[x]>maxElement) {
                maxElement = arr[x] ;
            }
        }
        return maxElement;
    }
    public static int getMax2(int[] arr) {
        //用变量记录较大的值
        int maxIndex = 0 ;  //初始化为0
        for(int x=1;x<arr.length;x++) {
            if(arr[x]>arr[maxIndex]) {
                maxIndex = x ;
            }
        }
        return arr[maxIndex];
    }   
}

import java.util.*;

public class ArrayDemo4 {

    public static void main(String[] args) {
        int[] arr = { 23, 4, 52, 41, 34 };

        System.out.print("排序前:");
        printArray(arr);

//       selectionSort(arr) ;
//       bubbleSort(arr) ;
//       bubbleSort_2(arr);
         Arrays.sort(arr); // Java自带的排序方法
//       selectionSort_2(arr);

        System.out.print("排序后:");
        printArray(arr);

    }

    /**
     * 选择排序.
     */
    public static void selectionSort(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]) {
                    displace(arr, x, y);
                }
            }
        }
    }

    /**
     * 最少换位次数排序,性能最优.
     */
    public static void selectionSort_2(int[] arr) {
        for (int x = 0; x < arr.length - 1; x++) {
            int num = arr[x];
            int index = x;
            for (int y = x + 1; y < arr.length; y++) {
                if (num > arr[y]) {
                    num = arr[y];
                    index = y;
                }
            }
            if (index != x) {
                displace(arr, x, index);
            }
        }
    }

    /**
     * 相邻排序1(冒泡排序).
     */
    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++) {
                /*
                 * 内循环:-1:为了避免角标越界 
                 * -x:为了让外循环增加一次,内循环参与比较的元素递减.
                 */
                if (arr[y] > arr[y + 1]) {
                    displace(arr, y, y + 1);
                }
            }
        }
    }

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

                if (arr[y] > arr[y + 1]) {
                    displace(arr, y, y + 1);
                }
            }
        }
    }

    /**
     * 遍历数组的功能.
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x != arr.length - 1) {
                System.out.print(arr[x] + ", ");
            } else {
                System.out.println(arr[x] + "]");
            }
        }
    }

    /**
     * 置换功能.
     */
    public static void displace(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;

    }
}

import java.util.Arrays;

public class ArrayDemo5 {

    public static void main(String[] args) {
        // int[] arr = { 23, 54, 12, 56, 88, 20 };
        int[] arr = { 23, 45, 67, 75, 89, 98, 100, 106 };
        int index = halfSearch_2(arr, 100);
        System.out.println("index = " + index);

    }

    /**
     * 数组常用功能:查找.
     */
    public static int getIndex(int[] arr, int key) {
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] == key) {
                return x;
            }
        }
        return -1;
    }

    /**
     * 二分查找法.
     * 数组必须是有序的.
     */
    public static int halfSearch(int[] arr, int key) {
        int min, mid, max;
        min = 0;
        max = arr.length - 1;
        mid = (min + max) / 2;

        while (key != arr[mid]) {
            if (key > arr[mid]) {
                min = mid + 1;
            } else if (key < arr[mid]) {
                max = mid - 1;
            }
            if (max < min) {
                return -1;
            }
            mid = mid = (min + max) / 2;
        }
        return mid;
    }

    public static int halfSearch_2(int[] arr, int key) {
        int min, mid, max;
        min = 0;
        max = arr.length - 1;
        mid = (min + max) / 2;

        while (min <= max) {
            mid = (max + min) >> 1;
            if (key > arr[mid]) {
                min = mid + 1;
            } else if (key < arr[mid]) {
                max = mid - 1;
            } else {
                return mid;
            }
        }
        return -1;
    }
}