<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[less_cold的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/less_cold</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; less_cold]]></copyright><item><title><![CDATA[《leetcode-go》 分割回文串]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120684508</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120684508</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 11:50:10 +0800</pubDate><description><![CDATA[给出一个字符串s，分割s使得分割出的每一个子串都是回文串

计算将字符串s分割成回文分割结果的最小切割数

例如:给定字符串s="aab",

返回1，因为回文分割结果["aa","b"]是切割一次生成的。


package main

/**
  * 
  * @param s string字符串 
  * @return int整型
*/
func minCut( s string ) int {
    // write code here
    cnt := make(map[int]int)
]]></description><category></category></item><item><title><![CDATA[《leetcode-go》二叉树根节点到叶子节点的所有路径和]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120684294</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120684294</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 11:36:16 +0800</pubDate><description><![CDATA[给定一个仅包含数字0-9的二叉树，每一条从根节点到叶子节点的路径都可以用一个数字表示。
例如根节点到叶子节点的一条路径是,那么这条路径就用来代替。
找出根节点到叶子节点的所有路径表示的数字之和


package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
  * 
  * @param root Tree..]]></description><category></category></item><item><title><![CDATA[《leetcode-go》最长的连续元素序列长度]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120684183</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120684183</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 11:33:52 +0800</pubDate><description><![CDATA[给定一个无序的整数类型数组，求最长的连续元素序列的长度。

例如：

给出的数组为[1000, 4, 2000, 1, 3, 2],

最长的连续元素序列为[1, 2, 3, 4].返回这个序列的长度：4

你需要给出时间复杂度在O（n）之内的算法

思路：用一个map存储数据，并且记录最小值和最大值，再遍历判断即可


package main

/**
  * 
  * @param num int整型一维数组 
  * @return int整型
*/
func longestConsecutive.]]></description><category></category></item><item><title><![CDATA[《leetcode-go》判断回文串]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120683772</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120683772</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 10:55:53 +0800</pubDate><description><![CDATA[判断题目给出的字符串是不是回文，仅考虑字符串中的字母字符和数字字符，并且忽略大小写

例如："nowcoder Is Best tsebsi: redoc won"是回文

"race a car"不是回文

注意：

你有没有考虑过字符串可能为空？这是面试时应该提出的一个好问题。

针对这个问题，我们定义空字符串是回文

思路：遍历字符串判断首位对应位置是否相等即可，注意空字符串


package main
import "strings"
/**
  * 
  * @param s string字符串]]></description><category></category></item><item><title><![CDATA[《leetcode-go》二叉树的最大路径和]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120683670</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120683670</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 10:49:11 +0800</pubDate><description><![CDATA[给定一个二叉树，请计算节点值之和最大的路径的节点值之和是多少。
这个路径的开始节点和结束节点可以是二叉树中的任意节点

思路：递归处理每个节点作为开始的最大路径和，如果&gt;0，则下面保留，如果&lt;0,则最大就是这个节点自己。


package main
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
  * 
  * @param root TreeNo]]></description><category></category></item><item><title><![CDATA[《leetcode-go》不同的子序列]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120683496</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120683496</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 10:44:21 +0800</pubDate><description><![CDATA[给定两个字符串S和T，返回S子序列等于T的不同子序列个数有多少个？

字符串的子序列是由原来的字符串删除一些字符（也可以不删除）在不改变相对位置的情况下的剩余字符（例如，"ACE"is a subsequence of"ABCDE"但是"AEC"不是）
例如：

S="nowcccoder", T = "nowccoder"

返回3

思路：动态规划，记录S的0-第i个字符串可以构成T的0到第j个字符串的个数，如果S第i个字符==T的第j个字符，那么A[i][j]=A[i-1][j-1]+A[i-1][j]]></description><category></category></item><item><title><![CDATA[《leetcode-go》二叉树中是否存在从根节点到叶子结点节点和为指定值的路径]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120683461</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120683461</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 10:34:32 +0800</pubDate><description><![CDATA[给定一个二叉树和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径

思路：深度遍历，存下路径下来的和就可以了，到叶子节点判断是否相等


package main
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
  * 
  * @param root TreeNode类 
  * @param sum int整型 
  * @ret]]></description><category></category></item><item><title><![CDATA[《leetcode-go》二叉树根节点到叶子节点和为指定值的路径]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120683387</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120683387</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 10:32:10 +0800</pubDate><description><![CDATA[给定一个节点数为 n 的二叉树和一个值 sum ，请找出所有的根节点到叶子节点的节点值之和等于的路径，如果没有则返回空。

思路：递归获取路径和即可，用一个栈来存储路径上的节点即可，后进先出。


package main
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
  * 
  * @param root TreeNode类 
  * @param sum ]]></description><category></category></item><item><title><![CDATA[《leetcode-go》判断二叉树是否为平衡二叉树]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120683342</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120683342</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 10:27:54 +0800</pubDate><description><![CDATA[判断给定的二叉树是否是平衡二叉树

平衡二叉树的性质为:要么是一棵空树，要么任何一个节点的左右子树高度差的绝对值不超过 1。

一颗树的高度指的是树的根节点到所有节点的距离中的最大值。

思路：判断每个节点的深度，左右节点进行比较，深度遍历来实现


package main
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
  * 
  * @param roo.]]></description><category></category></item><item><title><![CDATA[《leetcode-go》有序链表变成二叉搜索树]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120683302</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120683302</guid><author>less_cold</author><pubDate>Sun, 10 Oct 2021 10:23:07 +0800</pubDate><description><![CDATA[给定一个单链表，其中的元素按升序排序，请将它转化成平衡二叉搜索树（BST）


package main
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */
/*
 * type ListNode struct{
 *   Val int
 *   Next *ListNode
 * }
 */

/**
  * 
  * @param head ListNode类 
  * ]]></description><category></category></item><item><title><![CDATA[《leetcode-go》将升序数组转化为平衡二叉搜索树]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120120192</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120120192</guid><author>less_cold</author><pubDate>Mon, 06 Sep 2021 10:28:22 +0800</pubDate><description><![CDATA[给出一个升序排序的数组，将其转化为平衡二叉搜索树（BST）.

思路：无非就是取中间作为根节点，然后左右两边递归调用即可


package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
  * 
  * @param num int整型一维数组 
  * @return TreeNode类
*/
func so]]></description><category></category></item><item><title><![CDATA[《leetcode-go》二叉树层序遍历 ii]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120120120</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120120120</guid><author>less_cold</author><pubDate>Sun, 05 Sep 2021 19:57:23 +0800</pubDate><description><![CDATA[给定一个二叉树，返回该二叉树由底层到顶层的层序遍历，（从左向右，从叶子节点到根节点，一层一层的遍历）

例如：

给定的二叉树是{3,9,20,#,#,15,7},


3
 / \
 9 20
  / \
 15 7


该二叉树由底层到顶层层序遍历的结果是


[[15,7],[9,20],[3]]

思路：正向遍历然后加了个一个逆转的结果。


package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *...]]></description><category></category></item><item><title><![CDATA[《leetcode-go》从前序和中序遍历构造二叉树]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120119940</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120119940</guid><author>less_cold</author><pubDate>Sun, 05 Sep 2021 19:44:49 +0800</pubDate><description><![CDATA[给出一棵树的前序遍历和中序遍历，请构造这颗二叉树

注意：

可以假设树中不存在重复的节点

思路：前序遍历的第一个值是根节点，根据前序遍历的根节点分割中序遍历的左右两部分，然后遍历即可。


package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
  * 
  * @param preorder int整]]></description><category></category></item><item><title><![CDATA[《leetcode-go》从中序和后序遍历构造二叉树]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120119650</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120119650</guid><author>less_cold</author><pubDate>Sun, 05 Sep 2021 19:26:22 +0800</pubDate><description><![CDATA[给出一棵树的中序遍历和后序遍历，请构造这颗二叉树

注意：

保证给出的树中不存在重复的节点

思路：可以根据后序遍历获取跟节点，然后根据根节点把中序遍历分割为左右两部分，然后根据中序遍历的左右两部分，来分割后序的左右两部分，然后递归处理即可。


package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
 ]]></description><category></category></item><item><title><![CDATA[《leetcode-go》二叉树的最大深度]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120119497</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120119497</guid><author>less_cold</author><pubDate>Sun, 05 Sep 2021 19:13:59 +0800</pubDate><description><![CDATA[求给定二叉树的最大深度，

最大深度是指树的根结点到最远叶子结点的最长路径上结点的数量。

思路：递归调用，获取左右节点的深度，取最大值+1作为当前节点的深度.


package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
  * 
  * @param root TreeNode类 
  * @return]]></description><category></category></item><item><title><![CDATA[《leetcode-go》求二叉树的层序遍历]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120118410</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120118410</guid><author>less_cold</author><pubDate>Sun, 05 Sep 2021 18:00:41 +0800</pubDate><description><![CDATA[给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历）
例如：
给定的二叉树是{3,9,20,#,#,15,7},






该二叉树层序遍历的结果是
[
[3],
[9,20],
[15,7]
]

思路：用一个树节点栈来存储每一层的节点，下一层的节点就是这些节点出栈把他们的子节点再写入这个切片，根据每一层的数量来控制层次的节点分割


package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *   Val int
]]></description><category></category></item><item><title><![CDATA[《leetcode-go》判断二叉树是否对称]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120118183</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120118183</guid><author>less_cold</author><pubDate>Sun, 05 Sep 2021 17:43:48 +0800</pubDate><description><![CDATA[给定一棵二叉树，判断其是否是自身的镜像（即：是否对称）
例如：下面这棵二叉树是对称的
1
/ \
2  2
/ \  / \
3 4 4 3
下面这棵二叉树不对称。
1
/ \
2 2
\  \
3  3
备注：
希望你可以用递归和迭代两种方法解决这个问题

思路：左分支的左节点和右分支的右节点比较，左分支的右节点和右分支的左节点比较


package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *   Val i...]]></description><category></category></item><item><title><![CDATA[《leetcode-go》判断二叉树是否相等]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120117956</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120117956</guid><author>less_cold</author><pubDate>Sun, 05 Sep 2021 17:21:17 +0800</pubDate><description><![CDATA[给出两个二叉树，请写出一个判断两个二叉树是否相等的函数。

判断两个二叉树相等的条件是：两个二叉树的结构相同，并且相同的节点上具有相同的值。

思路：遍历两个树，判断值是否相等


package main
import . "nc_tools"
/*
 * type TreeNode struct {
 *   Val int
 *   Left *TreeNode
 *   Right *TreeNode
 * }
 */

/**
  * 
  * @param p TreeNode类 
  * @p]]></description><category></category></item><item><title><![CDATA[《leetcode-go》判断二叉搜索树]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120117787</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120117787</guid><author>less_cold</author><pubDate>Sun, 05 Sep 2021 17:15:39 +0800</pubDate><description><![CDATA[判断给出的二叉树是否是一个二叉搜索树（BST）

二叉搜索树的定义如下

一个节点的左子树上节点的值都小于自身的节点值
	一个节点的右子树上节点的值都大于自身的节点值
	所有节点的左右子树都必须是二叉搜索树
如果你不清楚“{1,#,2,3}"的含义的话，请继续阅读

我们用如下方法将二叉树序列化：

二叉树的序列化遵循层序遍历的原则，”#“代表该位置是一条路径的终结，下面不再存在结点。

例如：


  1
 / \
 2 3
  /
  4
  \
   5


上述的...]]></description><category></category></item><item><title><![CDATA[《leetcode-go》数字字符串转化成IP地址]]></title><link>https://blog.youkuaiyun.com/less_cold/article/details/120117340</link><guid>https://blog.youkuaiyun.com/less_cold/article/details/120117340</guid><author>less_cold</author><pubDate>Sun, 05 Sep 2021 16:52:50 +0800</pubDate><description><![CDATA[现在有一个只包含数字的字符串，将该字符串转化成IP地址的形式，返回所有可能的情况。

例如：

给出的字符串为"25525522135",

返回["255.255.22.135", "255.255.221.35"]. (顺序没有关系)

思路：需要判断是否每一位是否&lt;255，大于的直接跳过，指定第一位i是从0到2，然后指定第二位j是从i+1到i+3,然后指定第三位k是j+1到j+3，最后判断第四位就确定下来了，每一位都可以先判断是不是超过了255，超过了就不是想要的结果


package mai]]></description><category></category></item></channel></rss>