常用算法

排序

冒泡排序法

冒泡排序法，利用兩層嵌套循環，相鄰數據進行比較，每次內層循環結束，把當前最大數交換到最後。

public class BubbleSort{
    public static void mian(String[] args) {
        int[] arr = {2, 3, 5, 6, 9, 1, 3, 5, 10, 12};
        sort(arr);
        for(int i=0; i< arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    
    public static void sort(int[] arr){
        int length = arr.length;//數組長度
        int temp;//用於交換
        for(int i = 0; i< length - 1; i++) {//外圈循環
            for(int j = 0; j < length - i -1; j++) {//每次循環後，會把最大值交換到最後，所以去除已經排序好的數據
                if(arr[j] > arr[j + 1]) {
                    //判斷前面數是否大於後面數，若是，則交換位置
                    temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
                }
            }
        }
    }
}

快速排序法

快速排序法利用到分治和遞歸的思想，基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

public class QuickSort{
	public static void main(String[] args) {
		int[] arr = {2, 3, 5, 6, 9, 1, 3, 5, 10, 12};
        
        int left = 0;	
        int right = arr.length-1;
        
        sort(arr, left, right);
        for(int i=0; i< arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
	}
    
    /**
	 * 快速排序
	 * @param arr 	數據源
	 * @param left	起始數據的位置
	 * @param end	結束數據的位置
	 */
    public static void sort(int[] arr, int left, int right){
        if(right > left) {
            int midst = findMidst(arr, left, right); //找到基準點
            sort(arr, left, midst);	//對左側排序
            sort(arr, midst + 1, right); //對右側排序
  	  }
    }
    
    public static int findMidst(int[] arr, int left, int right) {
        int midst = arr[left];
        while(right > left) {
            //從右向左循環，找到比基準數小的
            while(right > left && arr[right] >= midst) {
                right--;
            }
            arr[left] = arr[right];
            //從左向右循環，找到比基準數大的
            while(right > left && arr[left] <= midst) {
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = midst;
        return left;
    }
}

插入排序法

插入排序法，假設在要排序的一組數中，前n-1個數已經排好序，現在將第n個數插到前面的有序數列中，使得這n個數也是排好順序的。如此反覆循環，直到全部排好順序。

public class InsertSort {
	public static void main(String[] args) {
		int[] arr = { 4, 3, 5, 6, 9, 1, 3, 5, 10, 12, 9, 1 };

		sort(arr);

		for (int k = 0; k < arr.length; k++) {
			System.out.print(arr[k] + " ");
		}

	}

	public static void sort(int[] arr) {
		if (arr != null && arr.length > 1) {
			for (int i = 1; i < arr.length; i++) {
				int temp = arr[i]; //要插入的數據
				int j;
				for (j = i - 1; j >= 0; j--) {
					if (arr[j] > temp) { 
						arr[j + 1] = arr[j]; 
					} else {
						break;
					}
				}
				//此處注意 j會先-1，在判斷j是否符合條件，故需要+1
				arr[j + 1] = temp;

			}
		}
	}

}

選擇排序法

一組需要排序的數中，假設第一個數最小，遍歷數組和其比較，找出最小的數和它交換位置，如此反覆，即可全部排序。

public class SelectSort {
	public static void main(String[] args) {
		int[] arr = { 4, 3, 5, 6, 9, 1, 3, 5, 10, 12, 9, 1 };

		sort(arr);

		for (int k = 0; k < arr.length; k++) {
			System.out.print(arr[k] + " ");
		}
	}
	
	public static void sort(int[] arr) {
		int pos;
		int temp;
		for(int i = 0; i < arr.length; i++) {
			pos = i;
			for(int j = i+1; j < arr.length; j++) {
				if(arr[j] < arr[pos]) {
					pos = j;
				}
			}
			
			if(pos != i){
				temp = arr[pos];
				arr[pos] = arr[i];
				arr[i] = temp;
			}
		}
	}
}

希爾排序

在要排序的一組數中，根據某一增量分爲若干子序列，並對子序列分別進行插入排序，然後逐漸將增量減小,並重覆上述過程。直至增量爲1,此時數據序列基本有序,最後進行插入排序。

public class ShellSort {
	public static void main(String[] args) {
		int[] arr = { 4, 3, 5, 6, 9, 1, 3, 5, 10, 12, 9, 1 };

		sort(arr);

		for (int k = 0; k < arr.length; k++) {
			System.out.print(arr[k] + " ");
		}
	}

	public static void sort(int[] arr) {
		if (arr != null && arr.length > 2) {
			int index = arr.length / 2;
			while (true) {
				for (int i = 0; i < index; i++) {
					for (int j = i; j + index < arr.length; j += index) {
						if(arr[j] > arr[j+index]) {
							int temp = arr[j];
							arr[j] = arr[j + index];
							arr[j+ index] = temp;
						}
					}
				}
				
				if(index == 1) {
					break;
				}
				index--;
			}
		}
	}
}

查找

二分查找法

二分查找法，是對有序的序列進行折半查找，每次以序列的中間位置的數來與待查找的關鍵字進行比較，以確認下一查找區間的位置，直到匹配成功

public class BinarySearch {
	public static void main(String[] args) {
		int[] arr = { 55, 3, 5, 6, 9, 11, 34, 5, 10, 12, 9, 1 };
		
		int target = search(arr, 0, arr.length - 1, 26);
		System.out.println("target = " + target);
		
		target = search(arr, 99);
		System.out.println("target = " + target);
	}
	
	/**
	 * 遞歸實現
	 * @param arr
	 * @param start
	 * @param end
	 * @param target
	 * @return
	 */
	public static int search(int[] arr, int start, int end, int target) {
		int middle = (start + end) / 2;
		if(arr[end] < target || arr[start] > target || start > end) {
			return -1;
		}
		
		if (arr[middle] == target) {
			return middle;
		} else if (arr[middle] > target) {
			return search(arr, middle + 1, end, target);
		} else{
			return search(arr, 0, middle - 1, target);
		} 
	
	}
	
	/**
	 * 循環實現
	 * @param arr
	 * @param target
	 * @return
	 */
	public static int search(int[] arr, int target) {
		int start = 0;
		int end = arr.length - 1;
		while(start <= end) {
			int middle = (start + end) / 2;
			if(arr[middle] == target) {
				return middle;
			}else if(arr[middle] > target) {
				start = middle +1;
			}else {
				end = middle - 1;
			}
		}
		
		return -1;
	}
}