剑指Offer学习笔记（3）——解决面试题的思路

最新推荐文章于 2022-02-25 23:41:44 发布
最新推荐文章于 2022-02-25 23:41:44 发布
阅读量681 收藏
点赞数
分类专栏： 在线刷题笔记 文章标签： 剑指offer 算法实现 数组 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangyifei521/article/details/50958758
版权
容易实现的算不上梦想,轻易放弃的算不上诺言。
要想成功得敢于挑战,有了梦想才有美好的明天！

前言：面试的时候我们经常遇到难题，画图、举例子和分解能够很好的帮助我们解决问题和细化问题。

 

一、画图使得抽象问题形象化

1. 二叉树镜像

操作给定的二叉树，将其变换为源二叉树的镜像。 
二叉树的镜像定义：源二叉树 

    	    8
    	   /  \
    	  6   10
    	 / \  / \
    	5  7 9 11
    	镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
public class TreeNode {
     int val = 0;
     TreeNode left = null;
     TreeNode right = null;
 
     public TreeNode(int val) {
         this.val = val;
 
     }
 
}
*/
public  class  Solution {
public  void  Mirror(TreeNode root) {
         //当树为空或者只有根节点的时候是不需要操作的
         if (root== null ||(root.left== null &&root.right== null )){
             return ;
         }
         
         TreeNode temp=root.left;
         root.left=root.right;
         root.right=temp;
         
         if (root.left!= null ){
             Mirror(root.left);
         }
         if (root.right!= null ){
             Mirror(root.right);
         }
 
     }
}
 

2. 顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import  java.util.ArrayList;
public  class  Solution {
    /**
      * print a matrix
      * @param matrix
      * @return
      */
     public  ArrayList<Integer> printMatrix( int [][] matrix) {
 
         if (matrix== null ){
             return  null ;
         }
         
         ArrayList<Integer> aList =  new  ArrayList<Integer>();
         int  rows=matrix.length;
         int  columns=matrix[ 0 ].length;
         int  start= 0 ;
         while (columns>start* 2 &&rows>start* 2 ){
             printMatrixCircle(matrix,rows,columns,start,aList);
             ++start;
         }
         
         return  aList;
     }
 
     /**
      * print the out circle of the matrix
      * @param matrix
      * @param rows
      * @param columns
      * @param start
      * @param aList
      */
     private  void  printMatrixCircle( int [][] matrix,  int  rows,  int  columns,
             int  start, ArrayList<Integer> aList) {
         int  endX=columns- 1 -start;
         int  endY=rows- 1 -start;
         
         //print from left to right
         for ( int  i=start;i<=endX;i++){
             int  num=matrix[start][i];
             System.out.print(num);
             aList.add(num);
         }
         
         //print from top to bottom
         if (start<endY){
             for ( int  j=start+ 1 ;j<=endY;j++){
                 int  num=matrix[j][endX];
                 System.out.print(num);
                 aList.add(num);
             }
         }
         
         //print from right to left
         if (start<endX&&start<endY){
             for ( int  i=endX- 1 ;i>=start;i--){
                 int  num=matrix[endY][i];
                 System.out.print(num);
                 aList.add(num);
             }
         }
         
         //from bottom to top       
         if (start<endX&&start<endY- 1 ){
             for ( int  i=endY- 1 ;i>=start+ 1 ;i--){
                 int  num=matrix[i][start];
                 System.out.print(num);
                 aList.add(num);
             }
         }
         
     }
}
 
 

二、举例让抽象具体化

 

1. 包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import  java.util.Stack;
 
public  class  Solution {
 
     
     Stack<Integer> data =  new  Stack<Integer>();
     Stack<Integer> min =  new  Stack<Integer>();
     Integer temp= null ;
 
     public  void  push( int  node) {
         if (min.size()== 0 ){
             data.push(node);
             min.push(node);
         } else {
             int  t = min.peek();
             if (t<node){
                  data.push(node);
                  min.push(t);
             } else {
                  data.push(node);
                  min.push(node);
             }
         }
             
         
     }
 
     public  void  pop() {
         int  num = data.pop();
         int  num2 = min.pop();
     }
 
     public  int  top() {
         return  data.peek();
     }
 
     public  int  min() {
     
         return  min.peek();
     }
}


  •  
 

2. 栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import  java.util.ArrayList;
import  java.util.Stack;
public  class  Solution {
    /**
      * 栈的压入和弹出序列的判断
      *
      * @param pushA
      * @param popA
      * @return
      */
     public  boolean  IsPopOrder( int [] pushA,  int [] popA) {
         if (pushA.length== 0 ||popA.length== 0 ){
             return  false ;
         }
         
         
         boolean  flag =  true ;
         Stack<Integer> s =  new  Stack<Integer>();
         s.push(- 1 ); //标记开始
         
         for  ( int  i =  0 ; i < popA.length; i++) {
             int  num = popA[i];
             int  index= 0 ;
             
             while  (num != s.peek()) {
                 if  (pushA[index] != - 1 ) {
                     s.push(index +  1 );
                     pushA[index] = - 1 ;
                 }
                 index++;
                 if (index>=pushA.length){
                     break ;
                 }
             }
             int  pop = s.pop();
             if (num!=pop){
                 flag= false ;
                 break ;
             }
 
         }
 
         return  flag;
     }
}
 

3. 从上往下打印二叉树

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import  java.util.ArrayList;
import  java.util.LinkedList;
import  java.util.Queue;
 
/**
public class TreeNode {
     int val = 0;
     TreeNode left = null;
     TreeNode right = null;
 
     public TreeNode(int val) {
         this.val = val;
 
     }
 
}
*/
public  class  Solution {
     /**
      * 按照层遍历二叉树算法的设计
      * @param root
      * @return
      */
     public  ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
         ArrayList<Integer> aList =  new  ArrayList<Integer>();
         if (root== null ){
             return  aList;
         }
         
         Queue<TreeNode> qt =  new  LinkedList<TreeNode>();
         qt.offer(root);
         while (qt.size()> 0 ){
             root=qt.poll();
             aList.add(root.val);
             if (root.left!= null ){
                 qt.offer(root.left);
             }
             if (root.right!= null ){
                 qt.offer(root.right);
             }          
         }
         
         return  aList;
     }
}
 

4. 二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public  class  Solution {
     public  boolean  VerifySquenceOfBST( int [] sequence) {
         boolean  flag =  true ;
         if  (sequence ==  null  || sequence.length <=  0 ) {
             return  false ;
         }
         return  VerifySquenceOfBSTRe(sequence, 0 ,sequence.length);
     }
 
     private  boolean  VerifySquenceOfBSTRe( int [] sequence,  int  begin,  int  length) {
         int  root=sequence[begin+length- 1 ];
         int  i=begin;
         for  (; i < length- 1 ; ++i) {
             if  (sequence[i] > root) {
                 break ;
             }
         }
 
         // In BST right subtree is smaller than root
 
         int  j = i;
         for  (; j < length- 1 ; ++j) {
             if  (sequence[j] < root) { //大于等于才是右子树
                 return  false ;
             }
         }
 
         boolean  left =  true ;
         if (i> 0 ){
             left=VerifySquenceOfBSTRe(sequence, 0 ,i);
         }
 
         
         boolean  right =  true ;
         if (i<length- 1 ){
             right=VerifySquenceOfBSTRe(sequence,i+ 1 ,length-i- 1 );
         }
 
         return  left&&right;
     }
}
 

5. 二叉树中和为某一值的路径

输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import  java.util.ArrayList;
import  java.util.Stack;
/**
public class TreeNode {
     int val = 0;
     TreeNode left = null;
     TreeNode right = null;
 
     public TreeNode(int val) {
         this.val = val;
 
     }
 
}
*/
public  class  Solution {
     public  ArrayList<ArrayList<Integer>> FindPath(TreeNode root,  int  target) {
         ArrayList<ArrayList<Integer>> pathList =  new  ArrayList<ArrayList<Integer>>();
         if  (root ==  null )
             return  pathList;
         Stack<Integer> stack =  new  Stack<Integer>();
         
         FindPath(root, target, stack, pathList);
         
         return  pathList;
 
     }
 
     private  void  FindPath(TreeNode root,  int  target, Stack<Integer> path,
             ArrayList<ArrayList<Integer>> pathList) {
         
         if  (root ==  null )
             return ;
         //如果左右子树都为空 也就是到达叶子结点
         if  (root.left ==  null  && root.right ==  null ) {
             if  (root.val == target) {
                 ArrayList<Integer> list =  new  ArrayList<Integer>();
                 for  ( int  i : path) { //stack有iterator接口实现
                     list.add( new  Integer(i));
                 }
                 list.add( new  Integer(root.val));
                 pathList.add(list);
             }
         }  else  {
             //如果不到叶子结点 递归的调用求的
             path.push( new  Integer(root.val));
             FindPath(root.left, target - root.val, path, pathList);
             FindPath(root.right, target - root.val, path, pathList);
             path.pop();
         }
 
     }
 
}
 
 

三、分解让复杂问题简单

 
 

1. 复杂链表的复制

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/*
public class RandomListNode {
     int label;
     RandomListNode next = null;
     RandomListNode random = null;
 
     RandomListNode(int label) {
         this.label = label;
     }
}
*/
public class Solution {
     /**
      * 复杂链表的复制
      * @param pHead
      * @return
      */
     public RandomListNode Clone(RandomListNode pHead)    {
         
         //每一个传入的结点都是pHead
         cloneNodes(pHead);
         connectRandomNodes(pHead);
         return reConnectNode(pHead);
         
     }
 
     /**
      * 分离重建两个链表
      * @param pHead
      * @return
      */
     private RandomListNode reConnectNode(RandomListNode pHead) {
         RandomListNode pNode=pHead;
         RandomListNode pClonedHead=null;//复制链表的头结点的设置
         RandomListNode pClonedNode=null;
         
         //
         if(pNode!=null){
             pClonedHead=pClonedNode=pNode.next;
             pNode.next=pClonedNode.next;
             pNode=pNode.next;//向后遍历
         }
         //后续链表的分离复制
         while(pNode!=null){
             pClonedNode.next=pNode.next;
             pClonedNode=pClonedNode.next;
             pNode. next=pClonedNode.next;
             pNode=pNode.next;
             
         }
         
         return pClonedHead;
     }
 
     /**
      * 链接Random
      * @param pHead
      */
     private void connectRandomNodes(RandomListNode pHead) {
         RandomListNode pNode = pHead;
         while(pNode!=null){
             RandomListNode pCloned = pNode.next;
             if(pNode.random!=null){
                 pCloned.random=pNode.random.next;//比着葫芦画瓢
             }
             
             pNode=pCloned.next;
         }
         
     }
 
     /**
      * 结点复制 在同一个链表中
      * @param pHead
      */
     private  void  cloneNodes(RandomListNode pHead) {
         
         RandomListNode pNode=pHead;
         while (pNode!= null ){
             RandomListNode pCloned =  new  RandomListNode(pNode.label);
             pCloned.next=pNode.next;
             pCloned.random= null ;
             
             pNode.next=pCloned; //复制结点
             
             pNode=pCloned.next;
         }
         
     }
}

2. 二叉搜索树与双向链表

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/**
public class TreeNode {
     int val = 0;
     TreeNode left = null;
     TreeNode right = null;
 
     public TreeNode(int val) {
         this.val = val;
 
     }
 
}
*/
public  class  Solution {
    /**
      * 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向
      *
      * 思路：中序遍历可以输出有序
      * @param pRootOfTree
      * @return
      */
     
     public  TreeNode Convert(TreeNode pRootOfTree) {
         TreeNode  tnLastNodeInList= null ;
         //转换
         tnLastNodeInList=convertNode(pRootOfTree,tnLastNodeInList);
         
         TreeNode tnFirstNodeInList=tnLastNodeInList;
         
         while (tnFirstNodeInList!= null &&tnFirstNodeInList.left!= null ){
             tnFirstNodeInList=tnFirstNodeInList.left;
         }
         
         return  tnFirstNodeInList;
     }
 
     private  TreeNode convertNode(TreeNode pRootOfTree, TreeNode tnLastNodeInList) {
         
         if (pRootOfTree== null ){
             return  tnLastNodeInList;
         }
         
         TreeNode tnCur = pRootOfTree;
         
         //左侧
         if (tnCur.left!= null ){
             tnLastNodeInList=convertNode(tnCur.left, tnLastNodeInList);
         }
         //中间  当前的根结点的前一个（PRE）结点就是链表尾
         tnCur.left=tnLastNodeInList;
         
         if (tnLastNodeInList!= null ){ //只要是当前的链表尾不是空的那么就可以设置当前链表的下一个（POST）结点
             tnLastNodeInList.right=tnCur;
         }
         //链表尾部结点向后移动
         tnLastNodeInList=tnCur;
         //右边重复上边的操作
         if (tnCur.right!= null ){
             tnLastNodeInList=convertNode(tnCur.right, tnLastNodeInList);
         }
         return  tnLastNodeInList;
     }
 
}

3. 字符串的排列

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。 结果请按字母顺序输出。 
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import  java.util.*;
public  class  Solution {
     public  ArrayList<String> Permutation(String str) {
         ArrayList<String> strList =  new  ArrayList<String>();
         if  (str ==  null  || str.equals( "" )) {
             return  strList;
         }
         strList = arrangeStr(str.toCharArray(),  0 , strList);
         Collections.sort(strList);
 
         return  strList;
     }
 
     /**
      * 采用递归策略实现字符串的全排列: 我们将字符序列看作是两部分，一部分是第一个字符，第二部分是后面的所有字符。
      * Step1:首先求出所有可能出现在第一个位置的字符，也就是将第一个字符同后面所有的字符进行交换
      * Step2：固定第一个字符，求后面所有字符的排列序列。 后面的字符我们仍然分为两个部分，第一个字符和第一个字符后面的字符。
      *
      * @param strCharArray
      * @param begin
      * @param strList
      * @return
      */
     private  ArrayList<String> arrangeStr( char [] strCharArray,  int  begin,
             ArrayList<String> strList) {
         // 一直安排到最后一个字符就终止
         if  (begin == strCharArray.length -  1 ) {
             strList.add(String.valueOf(strCharArray));
         }  else  {
             // 对第一个字符进行设置交换 从不交换开始
             for  ( int  i = begin; i < strCharArray.length; ++i) {
                 if  (strNothas(strCharArray, i, begin)) {
                     char  temp = strCharArray[begin];
                     strCharArray[begin] = strCharArray[i];
                     strCharArray[i] = temp;
 
                     arrangeStr(strCharArray, begin +  1 , strList);
 
                     temp = strCharArray[begin];
                     strCharArray[begin] = strCharArray[i];
                     strCharArray[i] = temp;
                 }
 
             }
         }
 
         return  strList;
     }
 
     private  boolean  strNothas( char [] strCharArray,  int  i,  int  begin) {
         if  (i == begin) {
             return  true ;
         }  else  {
             for  ( int  j = begin; j < i; j++) {
                 if  (strCharArray[i] == strCharArray[j]) {
                     // 如果在begin到i之间存在一个重复的就不要进行交换
                     return  false ;
                 }
             }
         }
         return  true ;
     }
 
}
 
 
 
 
 
 
雪狐晨光
关注
专栏目录
【Leetcode】《剑指offer-面试题43》n个骰子的点数
Microstrong
06-09 1438
题目链接 https://leetcode-cn.com/problems/nge-tou-zi-de-dian-shu-lcof/ 题目描述 解题思路 （1）递归解法 import math from typing import List class Solution: # 定义骰子最大点数 g_maxValue = 6 # 方法一：基于递归求骰子点数，时间效率不够高 def twoSum(self, n: int) -> List[float]
牛客网在线编程专题《剑指offer-面试题25》二叉树中和为某一值的路径
Microstrong
08-30 324
我的个人微信公众号：Microstrong 微信公众号ID：MicrostrongAI 公众号介绍：Microstrong(小强)同学主要研究机器学习、深度学习、计算机视觉、智能对话系统相关内容，分享在学习过程中的读书笔记！期待您的关注，欢迎一起学习交流进步！ 知乎专栏：https://zhuanlan.zhihu.com/Microstrong Github：https://githu...
【LeetCode题解】二叉树的遍历
weixin_33696822的博客
01-25 231
我准备开始一个新系列【LeetCode题解】，用来记录刷题，顺便复习一下数据结构与算法。 1. 二叉树 二叉树（binary tree）是一种极为普遍的数据结构，树的每一个节点最多只有两个节点——左孩子结点与右孩子结点。C实现的二叉树： struct TreeNode { int val; struct TreeNode *left; // left child struc...
《剑指offer》刷题笔记（举例让抽象具体化）：二叉搜索树的后序遍历序列
WordZzzz
11-06 1376
《剑指offer》刷题笔记（举例让抽象具体化）：二叉搜索树的后序遍历序列 转载请注明作者和出处：http://blog.csdn.net/u011475210 代码地址：https://github.com/WordZzzz/Note/tree/master/AtOffer 刷题平台：https://www.nowcoder.com/ 题  库：剑指offer 编  者：WordZzzz
判断二叉树是否是平衡二叉树
qq_32534441的博客
03-23 359
二叉树的节点定义为 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 二叉树的深度：根节点到叶节点的最长路径长度 平衡二叉树：二叉树中任一节点的左右子树的深度相差不超过1 递归的方法代码如下： public bool...
leetcode刷题之二叉树
qq_44309620的博客
11-11 4228
递归算法的关键 **首先：明确函数定义，相信这个定义，不要**跳进递归。 **其次：**搞明白root节点自己要做什么，然后根据题目要求选择前中后序递归框架。 **最后：**思考出每个节点需要做什么，刷题。 习题1：翻转二叉树 首先，明确函数定义 即，交换根节点的左右节点位置，返回翻转后的节点。 其次，明确root自己做什么 他要交换它的两个子节点，故选择前序遍历 再者，明确子节点都要做什么 让每个子节点都去翻转他们的左右子节点。 最后，明确边界条件 当root == null时，证明执行到了叶子节点，终
二叉树中if(root==null)的返回值怎么处理？
weixin_43484977的博客
03-14 822
二叉树的算法题，如果出错，往往是没有写if(rootnull)的条件 if(rootnull)的返回值该如何处理呢？ 核心：看整个函数的返回值 如果函数返回的是一个TreeNode,那么就return null 如果函数返回的是一个 LinkedList ,那就return new LinkedList<>() 如果是void，那就return ； ...
Leetcode、剑指Offer——名企面试官精讲典型编程题.zip
02-04
《LeetCode与剑指Offer——名企面试官精讲典型编程题》是一个针对程序员面试准备的重要资源包。它包含了来自LeetCode平台以及《剑指Offer》书籍中的经典编程题目，这些题目广泛应用于各大知名企业的面试过程中，是...
《剑指Offer：数据结构与算法名企面试题精讲》.zip
最新发布
06-16
《剑指Offer：数据结构与算法名企面试题精讲》是针对计算机科学与技术领域，尤其是准备进入IT行业的大学生和求职者的一份宝贵资源。这份压缩包包含了C/C++/JAVA/Python四种编程语言相关的数据结构学习笔记和资料，...
竞赛算法+剑指offer面试+Mysql数据库+整理的学习资料.zip
02-23
接着，"剑指offer面试"是指《剑指Offer——名企面试官精讲典型编程题》这本书，它是中国程序员面试领域的一本经典教材。书中涵盖了大量面试中常见的编程题目，包括数组、链表、栈、队列、二叉树等数据结构的运用，...
《剑指offer》刷题笔记（举例让抽象具体化）：二叉树中和为某一值的路径
WordZzzz
11-07 1239
《剑指offer》刷题笔记（举例让抽象具体化）：二叉树中和为某一值的路径 转载请注明作者和出处：http://blog.csdn.net/u011475210 代码地址：https://github.com/WordZzzz/Note/tree/master/AtOffer 刷题平台：https://www.nowcoder.com/ 题  库：剑指offer 编  者：WordZzzz
二叉树的遍历方法
FISHBALL1的博客
08-01 1844
二叉树的各类遍历方法 二叉树的遍历主要有三种，前序、中序、后序； 前序遍历：先访问根节点，再访问左子树，最后访问右子树 中序遍历：先访问左子树，再访问根节点，最后访问右子树 后序遍历：先访问左子树，再访问右子树，最后访问根节点 前序遍历：ABDFGHIEC 中序遍历：FDHGIBEAC 后序遍历：FHIGDEBCA 递归实现：
二叉树树的算法题目
maoloveyu_ecstc的博客
07-12 459
一、二叉树中用递归实现的各种题目总结 1.将一棵二叉树转化成双向链表     二叉树转化成双向链表的过程，就是中序遍历的过程。问题的关键是如何将在遍历二叉树的同时，修改指针指向，满足双向要求。   public TreeNode Convert(TreeNode root) { if(root==null)return null; if(root.left==
剑指offer题23
xingchenhy的博客
07-20 213
package jianzhioffer; import java.util.ArrayList; import java.util.Scanner; /** * 输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。 * 路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。 * */ /**节点类 public class TreeNode {
数据结构与算法 -二叉树和递归算法leetcode 刷题011
hufanglei007的博客
03-16 259
今天的刷题内容是二叉树和递归的应用：二叉树中的很多题目都可以通过递归的方法进行调用，比如简单的前序遍历，中序遍历，后续遍历等算法的实现，递归调用主要是两个内容，一个是递归的终止条件，另一个是递归循环体；废话不多说直接使用leetcode中的题来练手leetcode104,求一个二叉树的最大深度，class Solution { public: int maxDepth(TreeNode* ...
算法设计与分析——并查集（Union-find Disjoint Sets）
热门推荐
冯·诺依曼
02-25 1万+
一些应用涉及将nnn个不同的元素分成一组不相交的集合。这些应用经常需要进行两种特别的操作： 寻找包含给定元素的唯一集合 合并两个集合 一个不相交集合数据结构维护了一个不相交动态集的集合S={S1,S2,⋯ ,Sk}\mathbb{S}=\{S_1, S_2, \cdots, S_k\}S={S1​,S2​,⋯,Sk​}。我们用一个代表来标识每个集合，它是这个集合的某个成员。在一些应用中，我们不关心哪个成员被用来作为代表，仅仅关心的是2次查询动态集合的代表中，如果这些查询没有修改动态集合，则这两次查询应该
十分钟轻松掌握索引的数据结构
haust_允谦的博客
02-23 1282
快速掌握索引的数据结构
磁盘存储链式的 B 树与 B+树
qq_46118239的博客
02-25 1128
推荐一个零声学院免费公开课程，个人觉得老师讲得不错，分享给大家：Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等技术内容，立即学习 磁盘存储链式的 B 树与 B+树B树的介绍B树的组成B树的实现 B树的介绍 在讲B树之前我们先讨论一下内存与磁盘有什么区别? 对于这个问题很多朋友或多或少可以说点出来 可能很多朋友答的第一点就是 1.内存快磁盘慢 2.断电以后数据消失,磁盘持久存储
二叉树的基本概念
weixin_64181464的博客
02-24 1070
二叉树的基本概念一、树概念及结构1.1树的概念1.2 树的相关概念二、二叉树概念及结构2.1概念2.2 特殊的二叉树2.3 二叉树的性质 一、树概念及结构 1.1树的概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合 Ti(1<= i
二叉树深度计算与剑指Offer面试题解
在《剑指Offer》这本经典的Java面试题集里，第39题涉及的是求解二叉树的深度问题。这个问题的主要目标是给定一棵二叉树，计算从根节点到最远叶子节点的最长路径长度，也就是树的深度。深度定义为从根节点到最远叶子...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值