JAVA基礎學習總結（算法篇）

 

一、排序算法

關於排序算法我就不一一贅述了，建議看下這篇博客，講的很詳細。http://blog.csdn.net/hguisu/article/details/7776068

經常使用的排序通常是冒泡排序和快速排序。

冒泡排序的基本思想：對於一組數據，從前日後（或者從後往前）對相鄰的兩個數據進行比較，若是前面數字比後面數字大，則交換兩個數的位置，以此類推直到最後。時間複雜度爲O(n^2)。

代碼實現：

   /**
     * description : 冒泡排序
     * @param pData
     * @return
     */
    static void bubbleSort(int[] n){
     for (int i = 0; i < n.length-1; i++) {
       for (int j = i+1; j < n.length; j++) {
          int temp=0;
          if (n[i]>n[j]) {
            temp=n[j];
           n[j]=n[i];
           n[i]=temp;
      }
    }
  }
}

快速排序基本思想：將一組數據分割成兩部分，其中一部分的全部數據都要比另一部分全部數據要小，而後分別對兩部分數據進行快速排序，整個過程用遞歸進行，直到全部數據是有序的。時間複雜度爲O(nlogn)，當n比較大時推薦使用快速排序。

代碼實現：

   /**
     * description : 快速排序
     * @param pData
     * @param left
     * @param right
     * @return
     */
    static void quicksort(int n[], int left, int right) {
        int dp;
        if (left < right) {
            dp = partition(n, left, right);
            quicksort(n, left, dp - 1);
            quicksort(n, dp + 1, right);
        }
    }
 
    static int partition(int n[], int left, int right) {
        int pivot = n[left];
        while (left < right) {
            while (left < right && n[right] >= pivot)
                right--;
            if (left < right)
                n[left++] = n[right];
            while (left < right && n[left] <= pivot)
                left++;
            if (left < right)
                n[right--] = n[left];
        }
        n[left] = pivot;
        return left;
    }
 public static void main(String[] args) {
  int[] n={13,15,11,25,35,431,55,231,9,1};
  quicksort(n, 0, n.length-1);
  for (int i = 0; i < n.length; i++) {
   System.out.println(n[i]);
  }  
 }

二、遞歸算法

遞歸的基本思想：把一個複雜的問題分解成若干個雷同的子問題，直到子問題能直接求解，遞歸下去從而解決原問題。

經常使用的遞歸思想：

一、求一個數的階乘

 public static int fact(int n)
    {
        int ans;
        if(n==0||n==1)
        {
            ans=1;
        }
        else
        {
            ans=n*fact(n-1);
        }
        return(ans);
    }

例如n=5 則執行else條件

ans=5*fact(4)

fact(4)=4*fact(3)

fact(3)=3*fact(2)

fact(2)=2*fact(1)

fact(1)=1

以此類推ans=5*4*3*2*1=120

二、斐波那契數列  1，1，2，3，5，8，13……

  public static int fibon(int n)
    {
        int ans;
        if(n==0||n==1)
        {
            ans=1;
        }
        else
        {
            ans=fibon(n-1)+fibon(n-2);
        }
        return(ans);
    }

三、數組和鏈表區別

1）數組是長度是固定的，並且數組內的元素是連續存放的，訪問數組元素能夠直接經過下標訪問，可是插入和刪除元素都須要移動後面的元素，效率較低，增長數組元素則超出了數組長度，減小則會形成內存浪費；鏈表不是固定長度的，它的內部元素不是順序存儲的，而是經過指針關聯，所以便於插入和刪除元素。

2）數組在棧中分配空間，有程序員分配內存但自由度小；鏈表從堆中分配空間，自由度大，但申請管理比較麻煩。

四、堆和棧的區別

首先來說堆和棧是兩種數據結構。

棧是一種先進後出的數據結構，也就是最早進去的最後出來，就像往箱子裏面放東西同樣，要想拿出底下的東西，須要先把上面的東西拿出來。

堆是一種通過排序的樹形數據結構，他的存取是隨意的，就行書架上的書，隨時能夠取出或者放進去，不影響其餘書。

結合上面說的數組和鏈表，數組是棧結構，便於查找，可是不便於插入和刪減。鏈表是堆結構，便於插入和刪減。

上面說的是數據結構中的堆和棧，要區分的還有堆區和棧區，下面來看一張圖：

 

內存中的棧區處於相對較高的地址以地址的增加方向爲上的話，棧地址是向下增加的。

棧中分配局部變量空間，堆區是向上增加的用於分配程序員申請的內存空間。另外還有靜態區是分配靜態變量，全局變量空間的；只讀區是分配常量和程序代碼空間的；以及其餘一些分區。

 

棧是由程序自動分配自動釋放，當可用內存小於所需內存時就會報錯棧溢出，因此自由度較小。

堆是由程序員本身申請本身釋放，若是沒有及時釋放，容易形成內存泄漏，自由度較大，但很差管理。

五、二分查找

使用二分查找的前提是數據的順序是有序的，二分查找的最壞的時間複雜度是O（logn）。也就是說查找的數據在整個數據的開頭或者是結尾，最好狀況是O（1），也就是正好是中間的值。下面來看下具體實現代碼：

/**
		 * 二分查找
		 * @param n
		 * @param l
		 * @param r
		 * @param query
		 * @return
		 */
		public static int twof(int[] n,int l,int r,int query){
			int mid=l+(r-l)/2;
			if (query==n[mid]) {
				return mid;	
			}else if(n[mid]>query){
				return twof(n,l,mid-1,query);
			}else if(n[mid]<query){
				
				return twof(n,mid+1,r,query);
			}else {
				return -1;
			}
			
		}

除了二分查找還有順序查找O（n），分塊查找，二叉樹查找等。