Java之排序總結

public class SortTest {
 
       public int[] createArray() {
              Random random = new Random();
              int[] array = new int[10];
              for (int i = 0; i < 10; i++) {
                     array[i] = random.nextInt(100) - random.nextInt(100);//生成兩個隨機數相減，保證生成的數中有負數
              }
              System.out.println("==========原始序列==========");
              printArray(array);
              return array;
       }
 
       public void printArray(int[] data) {
              for (int i : data) {
                     System.out.print(i + " ");
              }
              System.out.println();
       }
 
       private void swap(int[] data, int x, int y) {
              int temp = data[x];
              data[x] = data[y];
              data[y] = temp;
       }

　　　　//冒泡排序，時間複雜度：O(n)~O(n2),空間複雜度：O(1),穩定性：穩定排序，適用性：數組基本有序時排序較快
       public void bubbleSort(int[] data, String sortType) {
              if (sortType.equals("asc")) { //正排序，從小排到大
                     //比較的輪數
                     for (int i = 1; i < data.length; i++) {
                            //將相鄰兩個數進行比較，較大的數往後冒泡
                            for (int j = 0; j < data.length - i; j++) {
                                   if (data[j] > data[j + 1]) {
                                          //交換相鄰兩個數
                                          swap(data, j, j + 1);
                                   }
                            }
                     }
              } else if (sortType.equals("desc")) { //倒排序，從大排到小
                     //比較的輪數
                     for (int i = 1; i < data.length; i++) {
                            //將相鄰兩個數進行比較，較大的數往後冒泡
                            for (int j = 0; j < data.length - i; j++) {
                                   if (data[j] < data[j + 1]) {
                                          //交換相鄰兩個數
                                          swap(data, j, j + 1);
                                   }
                            }
                     }
              } else {
                     System.out.println("您輸入的排序類型錯誤！");
              }
              printArray(data);//輸出冒泡排序後的數組值
       }

　　　　  //選擇排序，時間複雜度：O(n2),空間複雜度：O(1),不穩定。算法思想：每次從無序數組中選出一個最小的出來，放到已經排好的數組的前面(或後面)

       public void selectSort(int[] data, String sortType) {
 
              if (sortType.equals("asc")) { //正排序，從小排到大
                     int index;
                     for (int i = 1; i < data.length; i++) {
                            index = 0;
                            for (int j = 1; j <= data.length - i; j++) {
                                   if (data[j] > data[index]) {
                                          index = j;
 
                                   }
                            }
                            //交換在位置data.length-i和index(最大值)兩個數
                            swap(data, data.length - i, index);
                     }
              } else if (sortType.equals("desc")) { //倒排序，從大排到小
                     int index;
                     for (int i = 1; i < data.length; i++) {
                            index = 0;
                            for (int j = 1; j <= data.length - i; j++) {
                                   if (data[j] < data[index]) {
                                          index = j;
 
                                   }
                            }
                            //交換在位置data.length-i和index(最大值)兩個數
                            swap(data, data.length - i, index);
                     }
              } else {
                     System.out.println("您輸入的排序類型錯誤！");
              }
              printArray(data);//輸出直接選擇排序後的數組值
       }
 
       //插入排序，空間複雜度：O(n2),空間複雜度：O(1),穩定。算法思想：逐一取出元素，在已排好的元素序列中從後向前掃描，插入到適當的位置
       public void insertSort(int[] data, String sortType) {
              if (sortType.equals("asc")) { //正排序，從小排到大
                     //比較的輪數
                     for (int i = 1; i < data.length; i++) {
                            //保證前i+1個數排好序
                            for (int j = 0; j < i; j++) {
                                   if (data[j] > data[i]) {
                                          //交換在位置j和i兩個數
                                          swap(data, i, j);
                                   }
                            }
                     }
              } else if (sortType.equals("desc")) { //倒排序，從大排到小
                     //比較的輪數
                     for (int i = 1; i < data.length; i++) {
                            //保證前i+1個數排好序
                            for (int j = 0; j < i; j++) {
                                   if (data[j] < data[i]) {
                                          //交換在位置j和i兩個數
                                          swap(data, i, j);
                                   }
                            }
                     }
              } else {
                     System.out.println("您輸入的排序類型錯誤！");
              }
              printArray(data);//輸出插入排序後的數組值
       }
 
       
       public void reverse(int[] data) {
 
              int length = data.length;
              int temp = 0;//臨時變量
 
              for (int i = 0; i < length / 2; i++) {
                     temp = data[i];
                     data[i] = data[length - 1 - i];
                     data[length - 1 - i] = temp;
              }
              printArray(data);//輸出到轉後數組的值
       }
 
       /*快速排序，時間複雜度：O(nlogn)，空間複雜度：O(logn)，不穩定。基本思想：第一趟把待排序數據分成獨立的兩部分，其中一部分所有數據都比另外一部分小，然後再對這兩部分分別進行快速排序，整個過程遞歸，已達到整個數據變成有序數據*/
       public void quickSort(int[] data, String sortType) {
              if (sortType.equals("asc")) { //正排序，從小排到大
                     qsort_asc(data, 0, data.length - 1);
              } else if (sortType.equals("desc")) { //倒排序，從大排到小
                     qsort_desc(data, 0, data.length - 1);
              } else {
                     System.out.println("您輸入的排序類型錯誤！");
              }
       }
 
       private void qsort_asc(int data[], int low, int high) {
              int i, j, x;
              if (low < high) { //這個條件用來結束遞歸
                     i = low;
                     j = high;
                     x = data[i];
                     while (i < j) {
                            while (i < j && data[j] > x) { j--; }  //從右向左找第一個小於x的數
                            if (i < j) { data[i] = data[j]; i++;}
                            while (i < j && data[i] < x) { i++; }  //從左向右找第一個大於x的數
                            if (i < j) { data[j] = data[i]; j--;}
                     }
                     data[i] = x;
                     qsort_asc(data, low, i - 1);
                     qsort_asc(data, i + 1, high);
              }
       }
        
       private void qsort_desc(int data[], int low, int high) {
              int i, j, x;
              if (low < high) { //這個條件用來結束遞歸
                     i = low;
                     j = high;
                     x = data[i];
                     while (i < j) {
                            while (i < j && data[j] < x) { j--; }  //從右向左找第一個小於x的數
                            if (i < j) { data[i] = data[j]; i++;}
                            while (i < j && data[i] > x) { i++; }  //從左向右找第一個大於x的數
                            if (i < j) { data[j] = data[i]; j--;}
                     }
                     data[i] = x;
                     qsort_desc(data, low, i - 1);
                     qsort_desc(data, i + 1, high);
              }
       }
 
       //二分法查找算法一，時間複雜度O(logn)
       public int binarySearch(int[] dataset, int data, int beginIndex, int endIndex) {
              int midIndex = (beginIndex + endIndex) / 2; 
              if (data < dataset[beginIndex] || data > dataset[endIndex] || beginIndex > endIndex)
                     return -1;
              if (data < dataset[midIndex]) {
                     return binarySearch(dataset, data, beginIndex, midIndex - 1);
              } else if (data > dataset[midIndex]) {
                     return binarySearch(dataset, data, midIndex + 1, endIndex);
              } else {
                     return midIndex;
              }
       }
 
       //二分法查找算法二，時間複雜度O(logn)
       public int binarySearch(int[] dataset, int data) {
              int beginIndex = 0;
              int endIndex = dataset.length - 1;
              int midIndex = -1;
              if (data < dataset[beginIndex] || data > dataset[endIndex] || beginIndex > endIndex)
                     return -1;
              while (beginIndex <= endIndex) {
                     midIndex = (beginIndex + endIndex) / 2; //相當於midIndex = (beginIndex + endIndex) / 2，但是效率會高些
                     if (data < dataset[midIndex]) {
                            endIndex = midIndex - 1;
                     } else if (data > dataset[midIndex]) {
                            beginIndex = midIndex + 1;
                     } else {
                            return midIndex;
                     }
              }
              return -1;
       }
 
       public static void main(String[] args) {
              SortTest sortTest = new SortTest();
 
              int[] array = sortTest.createArray();
 
              System.out.println("==========冒泡排序後(正序)==========");
              sortTest.bubbleSort(array, "asc");
              System.out.println("==========冒泡排序後(倒序)==========");
              sortTest.bubbleSort(array, "desc");
 
              array = sortTest.createArray();
 
              System.out.println("==========倒轉數組後==========");
              sortTest.reverse(array);
 
              array = sortTest.createArray();
 
              System.out.println("==========選擇排序後(正序)==========");
              sortTest.selectSort(array, "asc");
              System.out.println("==========選擇排序後(倒序)==========");
              sortTest.selectSort(array, "desc");
 
              array = sortTest.createArray();
 
              System.out.println("==========插入排序後(正序)==========");
              sortTest.insertSort(array, "asc");
              System.out.println("==========插入排序後(倒序)==========");
              sortTest.insertSort(array, "desc");
 
              array = sortTest.createArray();
              System.out.println("==========快速排序後(正序)==========");
              sortTest.quickSort(array, "asc");
              sortTest.printArray(array);
              System.out.println("==========快速排序後(倒序)==========");
              sortTest.quickSort(array, "desc");
              sortTest.printArray(array);
 
              System.out.println("==========數組二分查找==========");
              System.out.println("您要找的數在第" + sortTest.binarySearch(array, 74) + "個位子。（下標從0計算）");
       }
}