浅析算法

最近闲来无事，温习了一下算法，还是别有风情。

1、逆波兰式

    问题描述：

       Evaluate the value of an arithmetic expression in Reverse Polish Notation.

       Valid operators are +, -, *, /. Each operand may be an integer or another expression.

       Some examples:

       ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9

       ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6

    思路：

        从运算表达式来看，最好用一个栈来存放这些字符串，这样取出后，判断运算符，从而将栈中的两数字进行运算。

    实现代码：

        public int rp(String[] strs) {
		Stack<String> stack = new Stack<String>();
		String operators = "+-*/";
		for (String str : strs) {
			if (!operators.contains(str)) {
				stack.push(str);
			} else {
				Integer a = Integer.valueOf(stack.pop());
				Integer b = Integer.valueOf(stack.pop());
				int index = operators.indexOf(str);
				switch (index) {
				case 0:
					stack.push(String.valueOf(a + b));
					break;
				case 1:
					stack.push(String.valueOf(b - a));
					break;
				case 2:
					stack.push(String.valueOf(a * b));
					break;
				case 3:
					stack.push(String.valueOf(b / a));
					break;
				}
			}
		}
		return Integer.valueOf(stack.pop());
	}

2、字梯

   问题描述：

    Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from         start to end, such that:

        Only one letter can be changed at a time

Each intermediate word must exist in the dictionary

For example,

Given:

start = "hit"

end = "cog"

dict = ["hot","dot","dog","lot","log"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",

return its length 5.

Note:

Return 0 if there is no such transformation sequence.

All words have the same length.

All words contain only lowercase alphabetic characters.

    思路：

        对初给的字符串，逐字符的替换后，进行比较。

     实现代码：

        public int getLength(String start, String end, Set<String> dict) {
		if (dict.size() == 0) {
			return 0;
		}
		LinkedList<String> wordQueue = new LinkedList<String>(); // 存放单词
		LinkedList<Integer> distanceQueue = new LinkedList<Integer>();// 存放距离
		wordQueue.add(start);
		distanceQueue.add(1);

		while (!wordQueue.isEmpty()) {
			String currWord = wordQueue.pop();
			int distance = distanceQueue.pop();

			if (currWord.equals(end)) {
				return distance;
			}
			for (int i = 0; i < currWord.length(); i++) {
				char[] chs = currWord.toCharArray();

				// 从a~z 逐个替换 看是否符合
				for (char ch = 'a'; ch <= 'z'; ch++) {
					chs[i] = ch;
					String newWord = String.valueOf(chs);
					// 新组成的单词是否和end相等
					if (newWord.equals(end)) {
						return distance + 1;
					}
					// 否则，接字
					if (dict.contains(newWord)) {
						wordQueue.push(newWord);
						distanceQueue.push(distance + 1);
						// 移除比较过的，否则会重复计算
						dict.remove(newWord);
					}
				}
			}
		}
		return 0;
	}

3、最长回文串

     问题描述：

        输入一个字符串，返回最长回文串。比如，输入‘adasffsff'，输出'ffsff'。

     直接上代码：

        // 得到最长回文
	public String findLongestPalindrome(String str) {

		if (str.isEmpty()) {
			return null;
		}
		if (str.length() == 1) {
			return str;
		}
		int longest = 0;
		String longeststr = "";
		for (int i = 0; i < str.length(); i++) {
			String substr = getSubstr(str, i, i); // 这种得到的是类似于这种情况：_aba_
			if (substr.length() > longest) {
				longest = substr.length();
				longeststr = substr;
			}
			substr = getSubstr(str, i, i + 1); // 这种得到的是类似于这种情况：_sffs_
			if (substr.length() > longest) {
				longest = substr.length();
				longeststr = substr;
			}
		}
		return longeststr;
	}

	// 回文子串
	public String getSubstr(String str, int start, int end) {
		while (start >= 0 && end < str.length()
				&& str.charAt(start) == str.charAt(end)) {
			// 扩大比较范围
			start--;
			end++;
		}
		return str.substring(++start, end);
	}

   路漫漫其修远兮，吾将上下而求索。

   待续...

转载于:https://my.oschina.net/u/1177710/blog/222201