Java之数组排序

1.冒泡排序

冒泡排序思想：相邻元素两两进行比较，将小数放在前面，大数放在后面。即在第一趟比较中第一个与第二个相比较；第二个与第三个比较…一次比较直至本次比较结束；再重复这个过程；
图解：
代码实现：

    public static void main(String[] args) {
            int [] arr={8,2,8,3,5};
            for (int i=0;i<arr.length-1;i++){
                for (int j=0;j<arr.length-i-1;j++){
                    if(arr[j]>=arr[j+1]){
                        int t=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=t;
                    }
                }
            }
            for (int i=0;i<arr.length;i++){
                System.out.print(arr[i]+",");
            }
        }
}

2.选择排序

选择排序思想：把数组中第一个元素依次与后面的元素进行比较，将小的放在前面，大的放在后面。在一趟完成后，数组中最小的即在第一位，然后拿第二个与后面的进行比较…，重复该过程；
图解：
代码实现：

    public static void main(String[] args) {
        int [] arr={2,5,6,1,9,7};
        for (int i=0;i<arr.length-1;i++){
            for (int j=i+1;j<arr.length;j++){
                if(arr[i]>=arr[j]){
                    int t=arr[i];
                    arr[i]=arr[j];
                    arr[j]=t;
                }
            }
        }
        for (int  i=0;i<arr.length;i++){
            System.out.print(arr[i]+",");
        }
    }
}

3.快速排序

快速排序思想：快速排序采用的是分而治之的思想，先比大小再分区从数组中取出一个数作为基数，分区、将比这个数大或等于的数全放到他的右边，小于他的数全放到他的左边，再对左右区间重复第二步，直到各区间只有一个数；
图解：
代码实现：

    public static class QuickSort {
        //start 默认是0
        //end 是数组长度-1
        public void quickSort(int[] arr, int start, int end) {
            if (start < end) {
                int index = getIndex(arr, start, end);
                quickSort(arr, start, index - 1);
                quickSort(arr, index + 1, end);
            }
        }
        private int getIndex(int[] arr, int start, int end) {
            int i = start;
            int j = end;
            int x = arr[i];
            while (i < j) {
                while (i < j && arr[j] >= x) {
                    j--;
                }
                if (i < j) {                  
                    arr[i] = arr[j];
                    //让 i++;
                    i++;

                }            
                while (i < j && arr[i] < x) {
                    i++;
                }                
                if (i < j) {
                    arr[j] = arr[i];
                    j--;
                }
            }
            arr[i] = x; 
            return i; 
        }

    }

    public static void main(String[] args) {
        QuickSort quickSort = new QuickSort();
        int [] arr={1,9,3,87,84,45,};
        quickSort.quickSort(arr,0,5);
        for (int i=0;i<arr.length-1;i++){
            System.out.print(arr[i]+",");
        }
    }
}

4.二分查找

二分查找思想：在数组中定义3个标志 最小、中间、最大，将要查找的值与中间值相比较，如果刚刚好相等则输出索引位置，如果小于改变最大值=中间值-1；如果大于改变最小值=中间值+1；然后改变中间值=（最大+最小）/2；继续进行比较；
图解：
代码实现：

    public static void main(String[] args) {
        int arr[]={10,20,30,40,50,60,70,80,90};
        int index = getindex(arr , 70);
        System.out.println(index);
    }

    private static int  getindex(int [] arr,int ele) {
        int minindex=0;
        int maxindex=arr.length-1;
        int midindex=(minindex+maxindex)/2;
        while(minindex<=maxindex){
            if (arr[midindex] == ele) {
                return midindex;
            }else if (arr[midindex] > ele){
                maxindex=midindex-1;
            }else if(arr[midindex] < ele){
                minindex=midindex+1;
            }
            midindex=(minindex+maxindex)/2;
        }
        return -1;
    }
}