调整数组顺序使奇数位于偶数前面,两个递增链表的合并，树的子结构

题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
第一种

/**
 * 第一种是使用动态数组vector实现的
 */

``	/**
	 * 第一种是使用动态数组vector实现的
	 */
	public void reorderArray(int[] array) {
		Vector<Integer> odd = new Vector<Integer>();
		Vector<Integer> even = new Vector<Integer>();
		if (array.length > 0) {
			for (int i = 0; i < array.length; i++) {
				if ((array[i] & 0x1) == 0) {
					even.add(array[i]);
				} else {
					odd.add(array[i]);
				}
			}
		}
		odd.addAll(even);
		for (int i = 0; i < array.length; i++) {
			array[i] = odd.get(i);
		}
	}

第二种

	/**
	 * 用类似冒泡排序的方法来实现
	 */
	public void reorderArray1(int[] array) {
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length - i - 1; j++) {
				if ((array[j] & 0x1) == 0 && (array[j + 1] & 0x1) == 1) {
					int tmp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = tmp;
				}
			}
		}
	}

题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

public class ListNode {
	int data;
	ListNode next;

	public ListNode(int data) {
		this.data = data;
	}

}
public class Twentyfive {
	/**
	 * 递归
	 */
	public ListNode Merge(ListNode list1, ListNode list2) {
		if (list1 == null) {
			return list2;
		} else if (list2 == null) {
			return list1;
		}
		ListNode mergehead = null;
		if (list1.data <= list2.data) {
			mergehead = list1;
			list1 = list1.next;
		} else {
			mergehead = list2;
			list2 = list2.next;
		}
		ListNode cur = mergehead;
		while (list1 != null && list2 != null) {
			if (list1.data <= list2.data) {
				cur.next = list1;
				list1 = list1.next;
			} else {
				cur.next = list2;
				list2 = list2.next;
			}
			cur = cur.next;
		}
		if (list1 == null)
			cur.next = list2;
		else if (list2 == null)
			cur.next = list1;
		return mergehead;
	}

	/**
	 * 递归的方法
	 */
	public ListNode Merge1(ListNode list1, ListNode list2) {
		if (list1 == null) {
			return list2;
		} else if (list2 == null) {
			return list1;
		}
		ListNode mergehead = null;
		if (list1.data <= list2.data) {
			mergehead = list1;
			mergehead.next = Merge(list1.next, list2);
		} else {
			mergehead = list2;
			mergehead.next = Merge(list1, list2.next);
		}
		return mergehead;
	}

}

题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

解题思路
递归思想，如果根节点相同则递归调用IsSubtree()，如果根节点不相同，则判断root1的左子树和roo2是否相同，再判断右子树和root2是否相同;
注意节点为空的条件，HasSubTree中，只要有树为空就返回false; AhasB中，要先判断root2，如果root2为空，则说明第二棵树遍历完了，即匹配成功。

public class TwentySix {
	/**
	 * 使用递归思想
	 * @param root1
	 * @param root2
	 * @return
	 */
	public boolean HasSubTree(TreeNode root1, TreeNode root2) {
		if (root1 == null || root2 == null) {
			return false;
		}
		if (root1.data == root2.data) {
			return AhasB(root1, root2);
		}
		return HasSubTree(root1.left, root2) || HasSubTree(root1.right, root2);
	}

	private boolean AhasB(TreeNode root1, TreeNode root2) {
		if (root2 == null) {
			return false;
		}
		if (root1 == null) {
			return false;
		}
		if (root1.data == root2.data) {
			return AhasB(root1.left, root2.left) && AhasB(root1.right, root2.right);
		}
		return false;
	}
}