常用的算法思想主要包含以下幾個方面：

1.分治法：

分治法的主要思想就是將一個復(fù)雜的問題分解成規(guī)模較小的相同問題，最終分割成的小問題可以很方便的求解，原問題的解就是每個小問題的合并。

• 分治法思想解決的經(jīng)典問題：

  • 二分查找

    
    
    binarySearch.png
    
    

    二分查找也稱之為折半算法，是在一個有序的數(shù)組中查找某一特定的元素的算法，并且每一次查找都可以將搜索范圍縮小一般。

            // 二分搜索法，查找有序數(shù)組中某個數(shù)的下標(biāo)。
            public static int binarySearch(int[] searchArray, int searchData) {
                int start = 0;
                int end = searchArray.length - 1;
                int mid;
                while (start <= end) {
                    mid = (start + end) / 2;
                    if (searchData < searchArray[mid]) {
                        end = mid - 1;
                    } else if (searchData > searchArray[mid]) {
                        start = mid + 1;
                    } else {
                        return mid;
                    }
                }
                return -1;
            }   
    
    

  • 快速排序
    1.基本思想： 從無序數(shù)列（R[low...high]）中選取一個基準(zhǔn)數(shù)（pivot，一般選擇low），從右側(cè)開始掃描如果找到比pivot小的數(shù)，就將R[start] = R[end]（將此高位的數(shù)據(jù)保存低位）并且將start++,然后從左側(cè)掃描如果找到比pivot大的數(shù)，就將R[end] = R[start],并且將end--；如此反復(fù)執(zhí)行，當(dāng)start= end時，結(jié)束掃描，并且將R[start] = pivot。

    2.基本思想圖解：
    

    quickSort_1.png
    
    ①、初始化時，選取基準(zhǔn)數(shù) int pivot = R[0]=72,start= 0,end= 9。
    從右側(cè)開始掃描，當(dāng)end= 8時，R[8] < pivot，然后將R[start] = R[8]，start++，再從左側(cè)start處進(jìn)行掃描，當(dāng)start = 3是，R[3] > pivot,然后將R[end] = R[3]，end--。得到的結(jié)果如圖｛quickSort_2.png｝。
    
    quickSort_2.png
    
    ②、此時，start = 3,end = 7,pivot = 72，再重復(fù)上面的掃描步驟，先從右側(cè)掃描，再從左側(cè)掃描。當(dāng)end = 5時，R[5] < pivot，然后將R[start] = R[5],start++，之后掃描左側(cè)并不會發(fā)現(xiàn)比pivot大的數(shù)值了。
    
    quickSort_3.png
    
    ③、最終掃描得到：start = end = 5，因此掃描結(jié)束了，再將R[start] = pivot。
    經(jīng)過上述一輪掃描之后發(fā)現(xiàn)，pivot所處的位置的左邊都是比pivot小的數(shù)值，右邊都是它大的數(shù)值；如此就相當(dāng)于分化了兩個相似的子問題，只需要遞歸執(zhí)行左右兩邊的遍歷，即可將整個問題解決。
    代碼實現(xiàn)：

          public static void quickSort(int[] array, int start, int end) {
                   if (start < end) {
                        int pivot = array[start];
                        while (start < end) {
                              // 1.從左側(cè)進(jìn)行掃描
                              while (start < end && array[end] >= pivot) end--;
                              // 掃描到比pivot小的數(shù)值
                              if (start < end) {
                                      array[start] = array[end];
                                      start++;
                              }
    
                              // 2.從右側(cè)進(jìn)行掃描
                              while (start < end && array[start] <= pivot) start++;
                              // 掃描到比pivot大的數(shù)值
                               if (start < end) {
                                      array[end] = array[start];
                                      end--;
                               }
                    }
                   // 3.一輪掃描結(jié)束，將pivot歸位
                   array[start] = pivot;
    
                  // 4.遞歸調(diào)用
                 quickSort(array, 0, start - 1);// 左側(cè)遞歸
                 quickSort(array, start + 1, end);// 右側(cè)遞歸
               }
         }
    
    

2.窮舉法

• 基本思想:窮舉法就是針對問題窮舉出每一種可能的結(jié)果，并且對每一個結(jié)果進(jìn)行判斷，從而得出正確的答案。

• 窮舉法的使用場景：

  • 找出[1,100]中之間的素數(shù)？

    首先，我們會將[1,100]的數(shù)全部都一一列舉出來，然后再將這個列舉出來的數(shù)進(jìn)行判斷。

      // 判斷是否為素數(shù)
      private boolean isPrime(int num){
          boolean isPrime = true;
          for(int i = 2;i < num;i++){
              if(0 == num % i){
                  isPrime = false;
              }
          }
          return isPrime;
      }
    
      // 列出某個區(qū)間內(nèi)所有的素數(shù)
      public void listPrime(int start,int end){
          for(int i = start;i <= end;i++){
              if(isPrime(i)){
                  Log.d("TAG",i+" ");
              }
          }
      }