Java語言基礎(數組冒泡排序，選擇排序等，二分法）

數組排序

排序方法有許多，在這裏主要介紹冒泡排序，選擇排序，插入排序，快速排序。

1.冒泡排序

• 比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；
• 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；
• 針對所有的元素重複以上的步驟，除了最後一個；
  
  代碼實現：

public class MyTest {
    public static void main(String[] args) {
            int[] arr = {24, 69, 80, 57, 13, 20, -1, 0};
           for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

2.選擇排序

每次拿一個元素和後面所有得元素挨個比較，小得往前放，經過一輪比交換，最小得元素會出現在最前面，如此往復，整個數組就排好序了。

代碼實現：

public class MyTest2 {
    public static void main(String[] args) {
    int[] arr = {24, 69, 80, 57, 13,20,50,200,0,-1};
               for (int index = 0; index < arr.length-1; index++) {
            for (int i = 1 + index; i < arr.length; i++) {
                if (arr[index] > arr[i]) {
                     int t = arr[index];
                    arr[index] = arr[i];
                    arr[i] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

3.直接插入排序

直接插入排序：每次將後面一個元素，插入到之前得一個有序序列中，使之仍保持有序

代碼實現：

public class MyTest3 {
    public static void main(String[] args) 
//直接插入排序：每次將後面一個元素，插入到之前得一個有序序列中，使之仍保持有序
        int[] arr = {49，38，65，97，76，13，27};
         for (int i = 1; i < arr.length; i++) {
                    int j=i;
            while (j>0&&arr[j]<arr[j-1]){
                int t=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=t;
                j--;
            }
      System.out.println(Arrays.toString(arr));
    }

4.快速排序

• 從數列中挑出一個元素，稱爲 “基準”（pivot）；
• 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。
• 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

代碼實現：

public class QuickSort {
        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 class MyTest2 {
    public static void main(String[] args) {
        //查找思想：前提條件：數組元素必須有序，二分查找：每次查找一半
        int[] arr = {10, 20, 30, 50, 90, 100, 101, 300, 400};
        int index = getIndex(arr, 90);
        System.out.println("索引是" + index);
    }
   private static int getIndex(int[] arr, int ele) {
       int minIndex = 0;
        int maxIndex = arr.length - 1;
        int centerIndex = (minIndex + maxIndex) / 2;
        while (minIndex <= maxIndex) {
            if (ele == arr[centerIndex]) {
                return centerIndex;
            } else if (ele > arr[centerIndex]) {
                minIndex = centerIndex + 1;
            } else if (ele < arr[centerIndex]) {
                maxIndex = centerIndex - 1;
            }
         centerIndex = (minIndex + maxIndex) / 2;
        }
        return -1;
    }
}