算法练习LeetCode初级算法之树
二叉树的前序遍历
我的解法：利用递归，自底向下逐步添加到list，返回最终的前序遍历list
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list=new ArrayList<>();
if (root==null) {
return list;
}
list.add(root.val);
if (root.left!=null) {
list.addAll(preorderTraversal(root.left));
}
if (root.right!=null) {
list.addAll(preorderTraversal(root.right));
}
return list;
}
}
参考解法：利用递归，但只在外部建一个list，更好理解！
class Solution {
public List<Integer> list=new LinkedList<>();
public List<Integer> preorderTraversal(TreeNode root) {
if (root==null)
return list;
list.add(root.val);
preorderTraversal(root.left);
preorderTraversal(root.right);
return list;
}
}
中序遍历二叉树，同样有两种方法
第一种
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list=new ArrayList<>();
if (root==null) {
return list;
}
if (root.left!=null) {
list.addAll(inorderTraversal(root.left));
}
list.add(root.val);
if (root.right!=null) {
list.addAll(inorderTraversal(root.right));
}
return list;
}
}
第二种
class Solution {
List<Integer> list=new ArrayList<>();
public List<Integer> inorderTraversal(TreeNode root) {
if (root==null) {
return list;
}
inorderTraversal(root.left);
list.add(root.val);
inorderTraversal(root.right);
return list;
}
}
后序遍历二叉树：也有两种方法，和前面的差不多，所以只写简洁的
class Solution {
List<Integer> list=new ArrayList<>();
public List<Integer> postorderTraversal(TreeNode root) {
if (root==null) {
return list;
}
postorderTraversal(root.left);
postorderTraversal(root.right);
list.add(root.val);
return list;
}
}
层次遍历二叉树
队列解法：
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res=new ArrayList<>();
if (root==null) {
return res;
}
Queue<TreeNode> queue=new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
int count=queue.size();
List<Integer> list=new LinkedList<>();
while (count>0) {
TreeNode node=queue.poll();
list.add(node.val);
if (node.left!=null) {
queue.add(node.left);
}
if (node.right!=null) {
queue.add(node.right);
}
count--;
}
res.add(list);
}
return res;
}
}
递归解法：参考大神的代码！！！
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res=new ArrayList<>();
if (root==null) {
return res;
}
addList(res, 0, root);
return res;
}
private void addList(List<List<Integer>> res,int level,TreeNode head) {
if (head==null) {
return;
}
if (res.size()<=level) { //这里有个问题，如果不是等于的话
res.add(new ArrayList<>());
}
res.get(level).add(head.val);//这里的将会越界，因为level=res.size()取不到
addList(res, level+1, head.left);
addList(res, level+1, head.right);
}
}
二叉树的最大深度
递归
class Solution {
public int maxDepth(TreeNode root) {
if (root==null) {
return 0;
}
int leftH=maxDepth(root.left);
int rightH=maxDepth(root.right);
return Math.max(leftH, rightH)+1;
}
}
迭代
这个方法太难了，不优先考虑！！
class Solution {
public int maxDepth(TreeNode root) {
Queue<Pair<TreeNode,Integer>> queue=new LinkedList<>();
if (root!=null) {
queue.add(new Pair<TreeNode, Integer>(root, 1));
}
int depth=0;
while (!queue.isEmpty()) {
Pair<TreeNode,Integer> pair=queue.poll();
root=pair.getKey();
int pair_depth=pair.getValue();
if (root!=null) {
depth=Math.max(depth, pair_depth);
queue.add(new Pair<TreeNode, Integer>(root.left, pair_depth+1));
queue.add(new Pair<TreeNode, Integer>(root.right, pair_depth+1));
}
}
return depth;
}
}
对称二叉树
递归
class Solution {
public boolean isSymmetric(TreeNode root) {
return isMirror(root, root);
}
private boolean isMirror(TreeNode t1,TreeNode t2) {
if (t1==null&&t2==null) {
return true;
}
if (t1==null||t2==null) {
return false;
}
return (t1.val==t2.val)&&isMirror(t1.left, t2.right)
&&isMirror(t1.right,t2.left);
}
}
迭代
class Solution {
public boolean isSymmetric(TreeNode root) {
Queue<TreeNode> queue=new LinkedList<>();
if (root==null||(root.left==null&&root.right==null)) {
return true;
}
queue.add(root.left);
queue.add(root.right);
while (!queue.isEmpty()) {
TreeNode t1=queue.poll();
TreeNode t2=queue.poll();
if (t1==null&&t2==null) continue;
if(t1==null||t2==null) return false;
if(t1.val!=t2.val) return false;
queue.add(t1.left);
queue.add(t2.right);
queue.add(t1.right);
queue.add(t2.left);
}
return true;
}
}
路径总和：递归很简洁
class Solution {
public boolean hasPathSum(TreeNode root, int sum) {
if (root==null) {
return false;
}
if (root.left==null&&root.right==null) {
return sum-root.val==0;
}
return hasPathSum(root.right, sum-root.val)||
hasPathSum(root.left, sum-root.val);
}
}
验证二叉搜索树
利用中序遍历法：简单易懂
class Solution {
public boolean isValidBST(TreeNode root) {
if (root==null) {
return true;
}
List<Integer> list=new ArrayList<>();
inOrder(root, list);
for (int i = 0; i < list.size()-1; i++) {
if (list.get(i+1)<=list.get(i)) {
return false;
}
}
return true;
}
private void inOrder(TreeNode node,List<Integer> list) {
if (node==null) {
return;
}
inOrder(node.left, list);
list.add(node.val);
inOrder(node.right, list);
}
}
大神递归法：
class Solution {
double last=-Double.MAX_VALUE;
public boolean isValidBST(TreeNode root) {
if (root==null) {
return true;
}
if (isValidBST(root.left)) {
if (last<root.val) {
last=root.val;
return isValidBST(root.right);
}
}
return false;
}
}
堆桟法
public boolean isValidBST(TreeNode root) {
Stack<TreeNode> stack = new Stack();
TreeNode p = root;
Integer preVal = null ;
while( p != null || !stack.isEmpty() ){
if(p != null){
stack.push(p);
p = p.left;
}else{
p = stack.pop();
int val = p.val;
if(preVal == null){
preVal = val;
}else{
if(val <= preVal){
return false;
}
preVal = val;
}
p = p.right;
}
}
return true;
}
将有序数组转换为二叉搜索树
解法一
class Solution {
public TreeNode sortedArrayToBST(int[] nums) {
return buildBST(nums, 0, nums.length-1);
}
private TreeNode buildBST(int[] nums,int l,int r) {
if (l>r) {
return null;
}
if (l==r) {
return new TreeNode(nums[l]);
}
int mid=(r+l)/2;
TreeNode root=new TreeNode(nums[mid]);
root.left=buildBST(nums, l, mid-1);
root.right=buildBST(nums, mid+1, r);
return root;
}
}
总结：递归是万能的，但递归真的很恶心！！！
算法练习LeetCode初级算法之树的更多相关文章
- 【LeetCode算法】LeetCode初级算法——字符串
在LeetCode初级算法的字符串专题中,共给出了九道题目,分别为:反转字符串,整数反转,字符串中的第一个唯一字符,有效的字母异位词,验证回文字符串,字符串转换整数,实现strStr(),报数,最 ...
- 算法练习LeetCode初级算法之链表
删除链表中的节点 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode ne ...
- 算法练习LeetCode初级算法之字符串
反转字符串 我的解法比较low,利用集合的工具类Collections.reverse反转,用时过长 class Solution { public void reverseString(char[] ...
- 算法练习LeetCode初级算法之数组
删除数组中的重复项 官方解答: 旋转数组 存在重复元素 只出现一次的数 官方解答: 同一个字符进行两次异或运算就会回到原来的值 两个数组的交集 II import java.util.Arr ...
- 算法练习LeetCode初级算法之其他
位1的个数 解法一: class Solution { // you need to treat n as an unsigned value public int hammingWeight(int ...
- 算法练习LeetCode初级算法之数学
Fizz Buzz class Solution { public List<String> fizzBuzz(int n) { List<String> list=new L ...
- 算法练习LeetCode初级算法之设计问题
打乱数组 不断的让第一个与后面随机选择的数交换 class Solution { private int[] nums; private int[] initnums; public Solution ...
- 算法练习LeetCode初级算法之动态规划
爬楼梯:斐波那契数列 假设你正在爬楼梯.需要 n 阶你才能到达楼顶. 每次你可以爬 1 或 2 个台阶.你有多少种不同的方法可以爬到楼顶呢? 注意:给定 n 是一个正整数. 非递归解法 class S ...
- 算法练习LeetCode初级算法之排序和搜索
合并两个有序数组 class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { System.arrayco ...
随机推荐
- 2019西湖论剑网络安全技能大赛（大学生组）部分WriteUp
这次比赛是我参加以来成绩最好的一次,这离不开我们的小团队中任何一个人的努力,熬了一整天才答完题,差点饿死在工作室(门卫大爷出去散步,把大门锁了出不去,还好学弟提了几个盒饭用网线从窗户钓上来才吃到了午饭 ...
- php输出数据到csv文件
function export() { $fileName = date('Y-m-d').uniqid().'.csv'; set_time_limit(0); ini_set('memory_li ...
- 记账本NABCD分析
学生记账本NABCD分析 N(Need,需求) 随着我们进入大学开始逐步的扩大自己的消费水平,而我们每天无法准确的记住一笔一笔的消费记录.常常,每一个月末时我们在宿舍楼道听到不少学生抱怨这个月怎么花钱 ...
- Linux内核原理第八次作业
Linux内核如何装载和启动一个可执行程序 一.ELF可执行文件格式 ELF格式分类: 可重定位文件:用来和其他object文件一起创建可执行文件和共享文件 可执行文件:指出应该从哪里开始执行 共享文 ...
- 知识点：spring 完全手册
什么是spring spring是一个开源框架,为简化企业级开发而生,使用spring可以使简单的java bean 实现以前只有EJG才能实现的功能. Spring是一个轻量级的控制反转(IoC)和 ...
- HTTPS如何保证数据传输的安全性 -- 结合加密
什么是HTTPS: HTTP就是我们平时浏览网页时候使用的一种协议 HTTP协议传输的数据都是未加密的,也就是明文的,因此使用HTTP协议传输隐私信息非常不安全.为了保证这些隐私数据能加密传输,于是网 ...
- @SuppressLint("HandlerLeak")，或Handler使用有警告；
随手写个Handler,然后飘黄,看着挺难受(黄色警告的大概意思:Handler可能会内存泄漏,推荐你用静态内部类+实例化弱引用): This Handler class should be stat ...
- day37协程与线程套接字通讯
协程与线程套接字通讯基于多线程实现套接字服务端支持并发,服务端 from socket import * from threading import Thread def comunicate(con ...
- MySQL视图-(视图创建，修改，删除，查看，更新数据)
视图是一种虚拟存在的表,对于使用视图的用户来说基本上是透明的.视图并不在数据库中实际存在,行和列数据来自定义视图的查询总使用的表,并且是在使用视图时动态生成的. 视图相对于普通表的优势: 简单:使用视 ...
- Android 开发 AlarmManager 定时器
介绍 AlarmManager是Android中常用的一种系统级别的提示服务,在特定的时刻为我们广播一个指定的Intent.简单的说就是我们设定一个时间,然后在该时间到来时,AlarmManager为 ...