xiren-wang

## binary_tree_level_order_traversal.cpp
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 * Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

## populate_next_right_pointer_2.cpp
/**
 * Definition for binary tree with next pointer.
 * struct TreeLinkNode {
 *  int val;
 *  TreeLinkNode *left, *right, *next;
 *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
 * };
 */
class Solution {
public:

## populate_next_right_pointer_in_each_node.cpp
/**
 * Definition for binary tree with next pointer.
 * struct TreeLinkNode {
 *  int val;
 *  TreeLinkNode *left, *right, *next;
 *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
 * };
 *  Given a binary tree

    struct TreeLinkNode {

## subsets.cpp
/*
Note:

    Elements in a subset must be in non-descending order.
    The solution set must not contain duplicate subsets.

For example,
If S = [1,2,3], a solution is:

[

## partition_list.cpp
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 * Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

## convert_sorted_array_to_BST.cpp
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {

## path_sum.cpp
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {

## sum_root_to_leaf_numbers.cpp
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 * Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number.

## sqrt_of_int.cpp
class Solution {
public:
    int sqrt(int x) {
      //binary search
      //Note: must pay attention to overflow, like (int) * (int) easily overflow
      //      to avoid dead loop, use (low + 1 < high), instead of lwo < high
        if (x < 0)
            return -1;
        if (x == 0)
            return 0;

## remove_duplicates_2.cpp
/**
 *  Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

For example,
Given 1->2->3->3->4->4->5, return 1->2->5.
Given 1->1->1->2->3, return 2->3.
 *
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
	/**
	* Definition for binary tree
	* struct TreeNode {
	* int val;
	* TreeNode *left;
	* TreeNode *right;
	* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
	* };
	* Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).
	/**
	* Definition for binary tree with next pointer.
	* struct TreeLinkNode {
	* int val;
	* TreeLinkNode left, right, *next;
	* TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
	* };
	*/
	class Solution {
	public:
	/*
	Note:

	Elements in a subset must be in non-descending order.
	The solution set must not contain duplicate subsets.

	For example,
	If S = [1,2,3], a solution is:

	[
	/**
	* Definition for singly-linked list.
	* struct ListNode {
	* int val;
	* ListNode *next;
	* ListNode(int x) : val(x), next(NULL) {}
	* };
	* Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

	You should preserve the original relative order of the nodes in each of the two partitions.
	class Solution {
	public:
	int sqrt(int x) {
	//binary search
	//Note: must pay attention to overflow, like (int) * (int) easily overflow
	// to avoid dead loop, use (low + 1 < high), instead of lwo < high
	if (x < 0)
	return -1;
	if (x == 0)
	return 0;
	/**
	* Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

	For example,
	Given 1->2->3->3->4->4->5, return 1->2->5.
	Given 1->1->1->2->3, return 2->3.
	*
	* Definition for singly-linked list.
	* struct ListNode {
	* int val;