算法_查找算法(线性查找、二分查找、插值查找、斐波那契查找)

线性查找

/**
 * 线性查找所有结果
 * @param arr
 * @param key
 * @return
 */
private static List<Integer> seqSearchAll(int[] arr, int key) {
	List<Integer> idxs = new ArrayList<Integer>();
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == key) {
			idxs.add(i);
		}
	}
	return idxs;
}

/**
 * 线性查找一个结果
 * @param arr
 * @param key
 * @return
 */
private static int seqSearch(int[] arr, int key) {
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == key) {
			return i;
		}
	}
	return -1;
}

二分查找

/**
 * 二分查找所有结果
 * @param arr
 * @param low
 * @param high
 * @param key
 * @return
 */
private static List<Integer> binarySearchAll(int[] arr, int low, int high, int key) {
	if (low > high) {
		return new ArrayList<Integer>();
	}
	int mid = (low + high) / 2;
	if (key < arr[mid]) {
		return binarySearchAll(arr, low, mid - 1, key);
	}
	if (key > arr[mid]) {
		return binarySearchAll(arr, mid + 1, high, key);
	}
	List<Integer> results = new ArrayList<Integer>();
	int temp = mid - 1;
	while (temp >= 0 && arr[temp] == key) {
		results.add(temp--);
	}
	results.add(mid);
	temp = mid + 1;
	while (temp <= arr.length - 1 && arr[temp] == key) {
		results.add(temp++);
	}
	return results;
}

/**
 * 二分查找单个结果
 * @param arr
 * @param low
 * @param high
 * @param key
 * @return
 */
private static int binarySearch(int[] arr, int low, int high, int key) {
	if (low > high) {
		return -1;
	}
	int mid = (low + high) / 2;
	if (key > arr[mid]) {
		return binarySearch(arr, mid + 1, high, key);
	} else if (key < arr[mid]) {
		return binarySearch(arr, low, mid - 1, key);
	} else {
		return mid;
	}
}

private static int binarySearch(int[] arr, int key) {
	int low = 0;
	int high = arr.length - 1;
	while (low <= high) {
		int mid = (low + high) / 2;
		if (key == arr[mid]) {
			return mid;
		}
		if (key < arr[mid]) {
			high = mid - 1;
		}
		if (key > arr[mid]) {
			low = mid + 1;
		}
	}
	return -1;
}

插值查找

• 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找, 速度较快
• 关键字分布不均匀的情况下，该方法不一定比折半查找要好

/**
 * 插值查找所有结果
 * @param arr
 * @param low
 * @param high
 * @param key
 * @return
 */
private static List<Integer> insertValueSearchAll(int[] arr, int low, int high, int key) {
	if (low > high || key < arr[0] || key > arr[arr.length - 1]) {
		return new ArrayList<Integer>();
	}
	int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]);
	if (key < arr[mid]) {
		return insertValueSearchAll(arr, low, mid - 1, key);
	}
	if (key > arr[mid]) {
		return insertValueSearchAll(arr, mid + 1, high, key);
	}
	List<Integer> results = new ArrayList<Integer>();
	results.add(mid);
	int temp = mid - 1;
	while (temp >= 0 && arr[temp] == key) {
		results.add(temp--);
	}
	temp = mid + 1;
	while (temp <= arr.length - 1 && arr[temp] == key) {
		results.add(temp++);
	}
	return results;

}

/**
 * 插值查找单一结果
 * @param arr
 * @param low
 * @param high
 * @param key
 * @return
 */
private static int insertValueSearch(int[] arr, int low, int high, int key) {
	if (low > high || key < arr[0] || key > arr[arr.length - 1]) {
		return -1;
	}
	int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]);
	if (key < arr[mid]) {
		return insertValueSearch(arr, low, mid - 1, key);
	}
	if (key > arr[mid]) {
		return insertValueSearch(arr, mid + 1, high, key);
	}
	return mid;
}

斐波那契查找

由斐波那契数列 F[k]=F[k-1]+F[k-2] 的性质，可以得到
（F[k]-1）=（F[k-1]-1）+（F[k-2]-1）+1
。该式说明：只要顺序表的长度为F[k]-1，则可以将该表分成长度为F[k-1]-1和F[k-2]-1的两段，即如上图所示。从而中间位置为mid=low+F(k-1)-1

/**
 * 斐波那契查找
 * @param arr
 * @param key
 * @return
 */
private static int fibnacciSearch(int[] arr, int key) {
	int low = 0;
	int high = arr.length - 1;
	int k = 1;
	while (high > fibonacci(k) - 1) {
		k++;
	}
	int[] temp = Arrays.copyOf(arr, fibonacci(k));
	for (int i = high + 1; i < temp.length; i++) {
		temp[i] = arr[high];
	}
	while (low <= high) {
		int mid = low + fibonacci(k - 1) - 1;
		if (key < temp[mid]) {
			high = mid - 1;
			k--;
		} else if (key > temp[mid]) {
			low = mid + 1;
			k -= 2;
		} else {
			return mid <= high ? mid : high;
		}
	}
	return -1;
}

/**
 * 获取第k个fibonacci数
 * @param k
 * @return
 */
private static int fibonacci(int k) {
	if (k <= 0) {
		throw new IndexOutOfBoundsException();
	}
	if (k == 1 || k == 2) {
		return 1;
	}
	return fibonacci(k - 1) + fibonacci(k - 2);
}