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;
    }
}