算法-二分法

1、二分法查找

元素必须是有序的，如果是无序的则要先进行排序操作。

原理：也称为是折半查找，属于有序查找算法。用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。

复杂度：最坏情况下，关键词比较次数为log2(n+1)，且期望时间复杂度为O(log2n)；

注意折半查找的前提条件是需要有序表顺序存储，对于静态查找表，一次排序后不再变化，折半查找能得到不错的效率。但对于需要频繁执行插入或删除操作的数据集来说，维护有序的排序会带来不小的工作量，那就不建议使用。

2、二分法实现

 
public class BasicBinarySearch {
	public static void main(String[] args) {
		int[] num = {1,4,7,9,10,14,16,20,56,89};
		System.out.println(new BasicBinarySearch().getIndex(num, 5));
	}
	public int getIndex(int[] num, int target) {
		if (num == null || num.length == 0) {
			return -1;
		}
		int start = 0;
		int end = num.length - 1;
		int mid;
		while (start + 1 < end) {
			mid = start + (end - start) / 2;
			if (num[mid] == target) {
				return mid;
			} else if(num[mid] > target) {
				end = mid;
			} else {
				start = mid;
			}
		}
		if (num[start] == target) {
			return start;
		}
		if (num[end] == target) {
			return end;
		}
		return -1;
	}
}

3、旋转有序数组搜索

class Solution {
    public int search(int[] num, int target) {
		if (num == null || num.length == 0) {
            return -1;
        }
        int start = 0;
        int end = num.length - 1;
        int mid;
        while (start + 1 < end) {
            mid = start + (end - start) / 2;
            if (num[mid] == target) {
                return mid;
            }
            if (num[mid] > num[start]) {
                if (target <= num[mid] && num[start] <= target) {
                    end = mid;
                } else {
                    start = mid;
                }
            } else {
                if (target >= num[mid] && target <= num[end]) {
                    start = mid;
                } else {
                    end = mid;
                }
            }
        }
        if (num[start] == target) {
            return start;
        }
        if (num[end] == target) {
            return end;
        }
        return -1;
	}
}

4、旋转有序数组搜索最小值

class Solution {
   public int findMin(int[] nums) {
		if (nums == null || nums.length == 0) {
            return 0;
        }
        int start = 0;
        int end = nums.length - 1;
        int mid;
       while (start + 1 < end ) {
           mid = start + (end - start) / 2;
           if (nums[mid] >= nums[start]) {
               if (nums[end] <= nums[mid]) {
                   start = mid;
               } else {
                   end = mid;
               }
           } else {
                end = mid; 
           }
       }
       return Math.min(nums[start], nums[end]);
	}
}

5、找峰值元素

class Solution {
    public int findPeakElement(int[] nums) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        int start = 0;
        int end = nums.length - 1;
        int mid;
        while(start + 1 < end) {
            mid = start + (end - start) / 2;
            if (nums[mid] < nums[mid - 1]) {
                end = mid;
            } else if (nums[mid] < nums[mid + 1]) {
                start = mid;
            } else {
                return mid;
            }
        }
        return nums[start] > nums[end] ? start : end;
    }
}

6、切木头问题

 
public class WoodCut {
	public static void main(String[] args) {
		int[] L = {232,124,456};
		System.out.println(new WoodCut().woodCut(L, 7));
	}
	public int woodCut(int[] L, int k) {
		if (L == null || L.length == 0) {
			return 0;
		}
		int start = 1;
		int end = getMax(L);
		int mid;
		while (start + 1 < end) {
			mid = start + (end - start) / 2;
			int pieces = getPieces(L, mid);
			if (pieces >= k) {
				start = mid;
			} else  {
				end = mid;
			}
		}
		if (getPieces(L, end) >= k) {
			return end;
		}
		if (getPieces(L, start) >= k) {
			return start;
		}
		return 0;
	}
	
	public int getMax(int[] L) {
		int max = L[0];
		for (int i = 1; i < L.length; i++) {
			if (max < L[i]) {
				max = L[i];
			}
		}
		return max;
	}
	
	public int getPieces(int[] L, int woodLength) {
		int pieces = 0;
		for (int wood: L) {
			pieces += wood/woodLength;
		}
		return pieces;
	}
}