leetcode刷题-part1

---

title: leetcode刷题-part1
date: 2018-09-21 17:32:47
updated: 2020-03-11 21:33:18
categories: 算法刷题
tags:
- 算法刷题
- leetcode

---

此leetcode刷题系列记录单独做的leetcode题目与答案，并非每道题都做，只记录做过的。每篇文档25道题，以官网题目序号为顺序。

一、题目总览

leetcode	题目
69	x的平方根
104	二叉树的最大深度
344	反转字符串
349	两个数组的交集
637	二叉树的层平均值
695	岛屿的最大面积
771	宝石与石头

二、题目及解答

No.69——x的平方根

题目

Compute and return the square root of x, where x is guaranteed to be a non-negative integer.

Since the return type is an integer, the decimal digits are truncated and only the integer part of the result is returned.

Example 1:

Input: 4
Output: 2

Example 2:

Input: 8
Output: 2
Explanation: The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.

思路

就是开根号，用二分法且用除法避免溢出

代码

class Solution {
public:
    int mySqrt(int x) {
        if(x==0)
            return 0;
        if(x<4){
            return 1;
        }
        int left = 1;
        int right = x/2+1; //这里注意
        int mid;
        while(left <= right){//while中的等号注意
            mid = left + (right-left)/2;
            if(x/mid == mid){
                return mid;
            }
            else if(x/mid > mid){
                left = mid + 1;
            }
            else if(x/mid < mid){
                right = mid - 1;
            }
        }
        return right;
    }
};

No.104——二叉树的最大深度

题目

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

For example:
Given binary tree [3,9,20,null,null,15,7],

	3
   / \
  9  20
    /  \
   15   7
	   

return its depth = 3.

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {//同样用了二叉树左子树右子树的递归思想
        if(!root)
            return 0;
        int ldeep = maxDepth(root->left);
        int rdeep = maxDepth(root->right);
        
        return ldeep>rdeep ? ldeep+1 : rdeep+1;
    }
};

No.344——反转字符串

题目

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

预备知识

# include 
/*
*	c语言键盘输入字符串char[]：scanf、gets区别
*	不同点：scanf不能接受空格、制表符tab、回车等； gets能接受空格、制表符tab、回车等
*	相同点：字符串接受结束后自动加'\0'
*	2016年6月14日16:51:51
*/
 
int main(void)
{
	char s1[100];		//c语言没有字符串，只有char[]
 
	scanf("%s", s1);
	printf("%s\n", s1);
 
	char s2[100];
	gets(s2);
	printf("%s\n", s2);
 
	return 0;
}

代码

# include 
# include 	//用于strlen(s)求字符数组长度
/*
*	Write a function that takes a string as input and returns the string reversed.
*	Example:
*	Given s = "hello", return "olleh". 
*	求字符串长度len = strlen(s)，需要头文件
*	
*	2016年6月14日18:02:25
*/
 
char* reverseString(char*);
 
int main(void)
{
	char s[100];
	gets(s);
 
	reverseString(s);	//!注意传的是s，而不是&s：因为s就是s[100]字符数组s[0]的地址！
	printf("%s\n", s);
 
	return 0;
}
 
 
char* reverseString(char* ps) 
{
    int i = 0;
    int r = strlen(ps) - 1;
	int p;
    while(i < r)
    {
		p = ps[i];		//注意这里s[i]前没有*
        ps[i] = ps[r];
        ps[r] = p;
        i++;
        r--;
    }
    return ps;
}

No.349——两个数组的交集

题目

给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]

说明:

• 输出结果中的每个元素一定是唯一的。
• 我们可以不考虑输出结果的顺序。

代码

# include 
# include 
# include 
 
int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize);
//以上函数返回的是相同元素的整个数组，而那个returnSize是这个相同数组的大小，并且是个指针变量可以修改！
void show(int* s, int size);
void sort(int* s, int size, int* sizenow);
int main(void)
{
	int s1[7] = {1,2,2,1,11,23,4};
	int s2[6] = {2,2,43,11,3,4};
	show(s1, 7);
	show(s2, 6);
 
 
	int* returnSize = (int *)malloc(sizeof(int));//相同数组的大小,因为是指针变量，所以可以后面被修改
 
	int* count = (int*)malloc(sizeof(int)*100);
	count = intersection(s1, 7, s2, 6, returnSize);
	show(count, *returnSize);
	
	system("pause");
	return 0;
}
 
void show(int* s, int size)
{
	int i;
	for(i=0; i s[j+1])
			{
				temp = s[j];
				s[j] = s[j+1];
				s[j+1] = temp;
			}
		}
	}
	int p=1, q=0;
	for(; pnums2[q]) && (q nums2Size) )
	{
		if((nums1[p]nums2[q]))
				q++;
			else 
			{
				if((nums1[p] == nums2[q]))
				{
					count[c] = nums2[q];
					c++;
					p++;
					q++;	
				}
			}
		}
	}
 
	*returnSize = c;
 
	return count;
}

No.637——二叉树的层平均值

题目

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.

示例 1:

输入:
    3
   / \
  9  20
    /  \
   15   7
输出：[3, 14.5, 11]
解释：第0层的平均值是 3,  第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].

注意：节点值的范围在32位有符号整数范围内。

思路

队列实现层次遍历的核心思路：

根节点为空返回NULL，根节点入队，while队列不为空则pop()一个元素，访问该元素后，将其左子树、右子树分别入队

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) { 
        //层次遍历并且要知道每一层的节点都是哪几个；
        //用队列实现层次遍历：根节点为空返回NULL，根节点入队，while队列不为空则pop（）一个元素，访问该元素后，将其左子树、右子树分别入队
        vector<double> res;
        if(!root)
            return res;
        
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty())
        {
            int len = que.size();
            int cnt = len;
            double sum = 0;
            while(cnt != 0)
            {
                TreeNode* tmp = que.front();
                sum += tmp->val;
                que.pop();
                if(tmp->left)
                    que.push(tmp->left);
                if(tmp->right)
                    que.push(tmp->right);
                
                cnt--;
            }
            
            
            res.push_back(sum/len);
        }
        
        return res;
    }
};

No.695——岛屿的最大面积

题目

给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)

示例 1:

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]

对于上面这个给定矩阵应返回 6。注意答案不应该是11，因为岛屿只能包含水平或垂直的四个方向的‘1’。

示例 2:

[[0,0,0,0,0,0,0,0]]

对于上面这个给定的矩阵, 返回 0。

注意: 给定的矩阵grid 的长度和宽度都不超过 50。

思路

DFS思想：一直往深处走，直到找到解或者走不下去为止。

实现：采用递归，使用栈保存未被检测的结点，结点按照深度优先的次序被访问并依次被压入栈中，并以相反的次序出栈进行新的检测。

详见 DFS模板

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {//同样用了二叉树左子树右子树的递归思想
        if(!root)
            return 0;
        int ldeep = maxDepth(root->left);
        int rdeep = maxDepth(root->right);
        
        return ldeep>rdeep ? ldeep+1 : rdeep+1;
    }
};
	

No.771——宝石与石头

题目

给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。

J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。

示例 1:

输入: J = "aA", S = "aAAbbbb"
输出: 3

示例 2:

输入: J = "z", S = "ZZ"
输出: 0

注意：S 和 J 最多含有50个字母。 J 中的字符不重复。

代码

class Solution {
	public:
	    int numJewelsInStones(string J, string S) {
	        //将J存成hash_map，便于S查询计数
	        map<char, int> hash_map;
	        for(int i=0; i<J.length(); i++)
	        {
	            hash_map.insert(pair<char, int>(J[i], 1));
	        }
	        
	        int res = 0;
	        for(char c: S)
	        {
	            if(hash_map.count(c) != 0) //map.count()返回0或1； map.find()返回迭代器
	                res += 1;
	        }
	        return res;
	    }
};