算法--经典算法

1 匹配算法：
匹配开始，从长的字符串开始，匹配成功，长的和短的字符串均向后匹配，而匹配失败，则长的字符串从开始的位置向后一个字符，重新开始匹配，而短的字符串则完全从头开始。

	/**
	 * 匹配算法
	 * 
	 * @param str1
	 *            长匹配字符串
	 * @param str2
	 *            短的匹配字符串
	 * @return 匹配成功 返回短字符串在长字符串开始的位置，从1开始数， 匹配失败返回-1
	 */
	public static Integer bf(String[] str1, String[] str2) {
		// a为str1的索引，b为str2的索引
		Integer a = 0, b = 0;
		while ((str1[a] != null) && (str2[b] != null)) {
			if (str1[a] == str2[b]) {
				a++;// 匹配的位置相同，继续下一个字符进行匹配
				b++;
			} else {
				a = a - b + 1;// 匹配失败，长字符串从开始的位置后面一个位置开始
				b = 0;// 短字符串从头开始
			}
			if ((a >= str1.length) || (b >= str2.length)) {
				break;
			}
		}
		if (b == str2.length) {// 匹配到str2的最后一个字符时则为匹配成功，
			return a - b + 1;
		} else {
			// 在长字符串中找不到短的字符串
			return -1;
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] str1 = new String[] { "a", "b", "c", "d", "e", "f", "g" };
		String[] str2 = new String[] { "b", "c", "d", "e" };
		System.out.println(BF.bf(str1, str2));
	}

2 折半查找
2.1 折半查找的非递归写法：
说明：查找区间先从0到最后一个数，找到最中间的数与要比较的数就行比较，当小于要比较的数时，说明从0到中间这半部分的数普遍小于被比较数，查找区间为中间位置加1至末尾，继续之前类似的操作。当中间的数比要比较的数大则说明后半部分的数普遍大于被查找的数，查找区间缩小为0到中间的数的索引。继续之前类似的查找。递归写法类似。不再描述。

/**
	 * 折半查找
	 * 
	 * @param data
	 *            查找数组
	 * @param x
	 *            别查找数
	 * @return 查找成功返回索引，失败返回-1
	 */
	public static Integer binarySearch_01(Integer[] data, Integer x) {
		Integer front = 0;// 头索引
		Integer rear = data.length - 1;// 尾索引 0 和4
		Integer middle;// 中间位置索引
		while (front <= rear) {// 查找条件为头指针不能比尾指针大。
			middle = (front + rear) / 2;
			if (data[middle] > x) {
				rear = middle - 1;// 中间位置的数比查找的数大，从小的那半部分中继续查找
			} else if (data[middle] < x) {
				front = middle + 1;// 中间位置的数比查找的数小，从大的那半部分中继续查找
			} else {
				return middle;// 成功查找成功,返回索引
			}
		}
		return -1;// 查找失败
	}

2.2 折半查找的递归写法:

/**
	 * 折半查找
	 * 
	 * @param data
	 *            数据域
	 * @param front
	 *            查找的相对开始区间
	 * @param rear
	 *            查找的相对结束区间
	 * @param x
	 *            要查找的数
	 * @return 查找成功，返回索引，失败返回-1
	 */
	public static Integer binarySearch_02(Integer[] data, Integer front,
			Integer rear, Integer x) {
		if (front <= rear) {// 查找条件为头指针不能比尾指针大。
			Integer middle = (front + rear) / 2;// 中间位置索引
			if (data[middle] > x) {// 中间位置的数比查找的数大，从小的那半部分中继续查找
				rear = middle - 1;
			} else if (data[middle] < x) {
				front = middle + 1;// 中间位置的数比查找的数小，从大的那半部分中继续查找
			} else {
				return middle;// 成功查找成功,返回索引
			}
			return binarySearch_02(data, front, rear, x);// 下一个区间继续查找
		} else {
			return -1;// 查找失败
		}
	}

折半查找的实际利用-求开方值。

    @Test
    public void test02(){
        double sqert = sqert(3, 1, 2, 3);
        System.out.println(sqert);
    }

    /**
     * 求开方数
     * @param val 被开方数
     * @param begin 估值起始区间
     * @param end 估值结束区间
     * @param scale 精确位数
     * @return 开发值
     */
    public double sqert(int val, double begin, double end, int scale) {
        BigDecimal middle = BigDecimal.valueOf(begin).add(BigDecimal.valueOf(end))
                .divide(BigDecimal.valueOf(2), scale, BigDecimal.ROUND_HALF_UP);
        BigDecimal multiplyResult = middle.multiply(middle).setScale(scale,BigDecimal.ROUND_HALF_UP);
        BigDecimal result=multiplyResult.subtract(BigDecimal.valueOf(val)).setScale(scale, BigDecimal.ROUND_HALF_UP);
        if (result.doubleValue()>0) {
            return sqert(val, begin, middle.doubleValue(), scale);
        } else if (result.doubleValue()<0) {
            return sqert(val, middle.doubleValue(), end, scale);
        } else{
            return middle.doubleValue();
        }
    }

3 递归问题–斐波拉契数列

public static int fibonacci(int num) {
		if (num == 1 || num == 2) {
			return 1;
		} else {
			return fibonacci(num - 1) + fibonacci(num - 2);
		}
	}

斐波拉契求和：

public static void main(String[] args) {
		System.out.println(fibonacci(5));
		int sum=0;
		for(int i=1;i<=5;i++){
			sum+=fibonacci(i);
		}
		System.out.println(sum);
	}

	public static int fibonacci(int num) {
		if (num == 1 || num == 2) {
			return 1;
		} else {
			return fibonacci(num - 1) + fibonacci(num - 2);
		}
	}

未完待续。。。