update

Author: yangrubing

swordForOffer/src/main/java/problem33/SortArrayForMinNumber.java

@@ -0,0 +1,62 @@
+package problem33;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
+ * 例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
+ * Created by bjyangrubing on 2016/8/22.
+ */
+public class SortArrayForMinNumber
+{
+
+	List<String> l = new ArrayList<String>();
+
+	public String PrintMinNumber(int[] numbers)
+	{
+		String result = "";
+		if (numbers == null || numbers.length <= 0)
+			return result;
+		List<Integer> list = new LinkedList<Integer>();
+		for (int i = 0; i < numbers.length; i++)
+		{
+			list.add(numbers[i]);
+		}
+
+		//对数组进行全排列，得到所有可能的结果，然后进行遍历
+		permation("", list);
+		result = l.get(0);
+		for (int i = 1; i < l.size(); i++)
+		{
+			if (l.get(i).compareTo(result) < 0)
+				result = l.get(i);
+		}
+		return result;
+	}
+
+	void permation(String prefix, List<Integer> list)
+	{
+		if (list.size() == 0)
+		{
+			l.add(prefix);
+		}
+		else
+		{
+			for (int i = 0; i < list.size(); i++)
+			{
+				List<Integer> temp = new LinkedList<Integer>(list.subList(0, i));
+				temp.addAll(list.subList(i + 1, list.size()));
+				permation(prefix + list.get(i), temp);
+			}
+		}
+	}
+
+	public static void main(String[] args)
+	{
+
+		System.out.println(new SortArrayForMinNumber().PrintMinNumber(new int[]
+		{ 3, 32, 321 }));
+	}
+}

swordForOffer/src/main/java/problem34/UglyNumber.java

@@ -0,0 +1,73 @@
+package problem34;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**把只包含因子2、3和5的数称作丑数（Ugly Number）。
+ * 例如6、8都是丑数，但14不是，因为它包含因子7。
+ * 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
+ * Created by bjyangrubing on 2016/8/23.
+ */
+public class UglyNumber
+{
+	public int GetUglyNumber_Solution(int index)
+	{
+		if (index <= 0)
+			return 0;
+		List<Integer> list = new ArrayList<Integer>();
+		list.add(1);
+
+		//分别表示这个乘以2后大于nowmax的最小值
+		int m2 = 0, m3 = 0, m5 = 0;
+		while (list.size() < index)
+		{
+			int nowMax = list.get(list.size() - 1);//由于是有序数组，当前的最大值nowMax为最后一个
+			for (int i = 0; i < list.size(); i++)
+			{
+				if (list.get(i) * 2 > nowMax)
+				{
+					m2 = list.get(i) * 2;
+					break;
+				}
+
+			}
+			for (int i = 0; i < list.size(); i++)
+			{
+				if (list.get(i) * 3 > nowMax)
+				{
+					m3 = list.get(i) * 3;
+					break;
+				}
+			}
+			for (int i = 0; i < list.size(); i++)
+			{
+				if (list.get(i) * 5 > nowMax)
+				{
+					m5 = list.get(i) * 5;
+					break;
+				}
+			}
+
+			int min = Math.min(m2, Math.min(m3, m5));
+			list.add(min);
+		}
+
+		return list.get(index - 1);
+	}
+
+	public boolean isUglyNumber(int number)
+	{
+		while (number % 2 == 0)
+			number /= 2;
+		while (number % 3 == 0)
+			number /= 3;
+		while (number % 5 == 0)
+			number /= 5;
+		return number == 1 ? true : false;
+	}
+
+	public static void main(String[] args)
+	{
+		System.out.println(new UglyNumber().GetUglyNumber_Solution(1500));
+	}
+}

swordForOffer/src/main/java/problem35/FindNotRepeatingChar.java

@@ -0,0 +1,40 @@
+package problem35;
+
+import java.util.LinkedHashMap;
+
+/**找出字符串中第一个只出现一次的字符
+ * Created by bjyangrubing on 2016/8/23.
+ */
+public class FindNotRepeatingChar
+{
+
+	public int FirstNotRepeatingChar(String str)
+	{
+		int result = -1;
+		if (str == null || str.length() <= 0)
+			return result;
+		char[] arr = str.toCharArray();
+		LinkedHashMap<Character, Integer> map = new LinkedHashMap<Character, Integer>();
+		for (int i = 0; i < arr.length; i++)
+		{
+
+			if (!map.containsKey(arr[i]))
+			{
+				map.put(arr[i], 1);
+			}
+			else
+			{
+				Integer count = map.get(arr[i]);
+				map.put(arr[i], count + 1);
+			}
+		}
+
+		for (int i = 0; i < arr.length; i++)
+		{
+			if (map.get(arr[i]) == 1)
+				return i;
+		}
+		return result;
+	}
+
+}

swordForOffer/src/main/java/problem36/InversePairs.java

@@ -0,0 +1,65 @@
+package problem36;
+
+/**
+ * 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P
+ * Created by bjyangrubing on 2016/8/23.
+ */
+public class InversePairs
+{
+	public int InversePairs(int[] array)
+	{
+		if (array == null || array.length <= 0)
+			return 0;
+
+		//构造一个辅助数组
+		int[] copy = new int[array.length];
+		for (int i = 0; i < array.length; i++)
+		{
+			copy[i] = array[i];
+		}
+
+		int count = inverseParisCore(array, copy, 0, array.length - 1);
+
+		return count;
+	}
+
+	private int inverseParisCore(int[] array, int[] copy, int start, int end)
+	{
+		//递归终止条件
+		if (start == end)
+		{
+			copy[start] = array[start];
+			return 0;
+		}
+
+		int middle = (start + end) / 2;
+		int leftCount = inverseParisCore(copy, array, start, middle);
+		int rightCount = inverseParisCore(copy, array, middle + 1, end);
+
+		int i = middle;
+		int j = end;
+		int indexCopy = end;
+		int count = 0;
+		while (i >= start && j >= middle + 1)
+		{
+			if (array[i] > array[j])
+			{
+				copy[indexCopy--] = array[i--];
+				count += j - middle;
+			}
+			else
+			{
+				copy[indexCopy--] = array[j--];
+			}
+		}
+
+		for (; i >= start; --i)
+			copy[indexCopy--] = array[i];
+
+		for (; j >= middle + 1; --j)
+			copy[indexCopy--] = array[j];
+
+		return (leftCount + rightCount + count);
+	}
+
+}

swordForOffer/src/main/java/problem37/FirstCommonNodesInLists.java

@@ -0,0 +1,75 @@
+package problem37;
+
+import utils.ListNode;
+
+/**输入两个链表，找出它们的第一个公共结点。
+ * Created by bjyangrubing on 2016/8/23.
+ */
+public class FirstCommonNodesInLists
+{
+	/**
+	 * 思路：先找出两个链表的长度差值k，让长的链表先走k步
+	 * 然后让两个链表一起走，一直遇到相同的节点则返回
+	 * @param pHead1
+	 * @param pHead2
+	 * @return
+	 */
+	public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2)
+	{
+		if (pHead1 == null || pHead2 == null)
+			return null;
+		int length1 = getListLength(pHead1);
+		int length2 = getListLength(pHead2);
+		//两个链表的长度差值
+		int diff = (length1 - length2);
+		int i = 0;
+		//链表1比链表2长
+		if (diff > 0)
+		{
+			while (i < diff)
+			{
+				pHead1 = pHead1.next;
+				i++;
+			}
+		}
+		else
+		{
+			while (diff < i)
+			{
+				pHead2 = pHead2.next;
+				diff++;
+			}
+		}
+
+		ListNode rtNode = new ListNode();
+
+		while (pHead1 != null && pHead2 != null)
+		{
+			if (pHead1.value == pHead2.value)
+			{
+				rtNode = pHead1;
+				break;
+			}
+			else
+			{
+				pHead1 = pHead1.next;
+				pHead2 = pHead2.next;
+			}
+
+		}
+
+		return rtNode;
+	}
+
+	private int getListLength(ListNode phead)
+	{
+		int count = 0;
+		while (phead != null)
+		{
+			count++;
+			phead = phead.next;
+		}
+
+		return count;
+	}
+}