leetcode刷题(一)

1.判断两颗二叉树是否相等

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };


//判断二叉树是否相等的函数
bool isEqual(TreeNode *T1, TreeNode *T2)
{
	if (T1 == NULL && T2 == NULL)
		return true;

	if (!T1 || !T2)
		return false;

	if (T1->val == T2->val) 
		return isEqual(T1->left, T2->left) && isEqual(T1->right, T2->right);
	else
		return false;
}

2.给定一棵二叉树，返回所有重复的子树。对于同一类的重复子树，你只需要返回其中任意一棵的根结点即可。

两棵树重复是指它们具有相同的结构以及相同的结点值。

#include<map>
#include<string>
#include<string.h>

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

std::vector<TreeNode*> res;
std::map<std::string, std::vector<TreeNode*>> m;

std::string tree(TreeNode* node)
{
	if (node == nullptr)
		return "";
	std::string left = tree(node->left);
	std::string right = tree(node->right);
	std::string s = std::to_string(node->val) + left + right;
	m[s].push_back(node);
	return s;
}

std::vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
	tree(root);
	for (auto p : m)
		if (p.second.size() > 1)
			res.push_back(p.second.front());
	return res;
}

 3.有序数序列中查找是否存在两数之和等于给定整数。

#include<vector>

bool findStart(std::vector<int> &list, int k)
{
    int left = 0;
    int right = list.size() - 1;
    
    int sum = 0;
    while(left < right){
        sum = list[left] + list[right];

        if(sum == k)    return true;

        if(sum > k) right--;
        else
            left++;
    }
    return false;
}

 

4.给定一个二叉搜索树和一个目标结果，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 true。  

//二叉搜索树在中序遍历情况下有序

#include<vector>

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

std::vector<int> orderList;

void ordering(TreeNode* node)
{
	if (node == NULL)
		return;

	ordering(node->left);
	orderList.push_back(node->val);
	ordering(node->right);
}

bool findStart(std::vector<int> &list, int k)
{
	int left = 0;
	int right = list.size() - 1;

	int sum = 0;
	while (left < right) {
		sum = list[left] + list[right];

		if (sum == k)    return true;

		if (sum > k) right--;
		else
			left++;
	}
	return false;
}

bool findTarget(TreeNode* root, int k)
{
	ordering(root);
	return findStart(orderList, k);
}

5.给定一个排序好的数组，两个整数 k 和 x，从数组中找到最靠近 x（两数之差最小）的 k 个数。返回的结果必须要是按升序排好的。如果有两个数与 x 的差值一样，优先选择数值较小的那个数。

    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
        int left = 0;
        int right = arr.size() - k;
        while(left < right)
        {
            int mid = (left + right) / 2;
            if(x - arr[mid] > arr[mid + k] - x)
            {
                left = mid + 1;
            }
            else
            {
                right = mid;
            }
        }
        return vector<int>(arr.begin() + left, arr.begin() + k + left);
    }