Algorithms on Jalen's blog

Greedy Algorithms II: Applying a Practical Problem-Solving Approach—Maximizing the Number of Conference Room Presentations

Sat, 04 Nov 2023 11:22:47 +0800

In the previous post, we used a relatively basic algorithm problem to discuss a practical approach to solving greedy algorithm problems. In short, solving greedy problems is largely about accumulating experience. It is difficult to rigorously prove the correctness of the greedy strategy for each problem, and such proofs are not generally applicable. In practice, we do not need to prove it; instead, we can verify it directly through experiments.

The previous article introduced verification using a testing harness. A testing harness is highly effective for validating the correctness of an algorithm. At the same time, writing the reference implementation used by the harness—solving the problem by brute force, which has high complexity but is easy to implement—as well as sample data generators and test cases can significantly improve our coding skills.

In this article, we will use this approach to explore a greedy algorithm problem in depth.

Problem: Maximize the Number of Conference Room Presentations

Problem Description

Suppose you have only one conference room, and several projects need to use it for presentations. The conference room cannot accommodate two project presentations at the same time. Given the start and end times of each project, arrange the presentation schedule so that the maximum number of presentations can be held, and return that maximum number. One project must finish before the next can begin, meaning that the start time of the next project must be greater than or equal to the end time of the previous project.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// Program represents a conference presentation project.
type Program struct {
 Start int // Start time
 End int // End time
}

// BestArrange returns the maximum number of presentations that can be scheduled.
func BestArrange(programs []Program) int {
 //...
}

The start and end times can be understood as points on a timeline, without considering how many time units there are in a day. For example, a project might be represented as {1,100}, starting at time point 1 and ending at time point 100. Here, Start and End are positive integers with no upper limit.

Problem Analysis

Suppose the input is [{1,2},{4,5},{2,15},{16,18},{3,4},{7,17}]

Clearly, we should choose {1,2} -> {3,4} -> {4,5} -> {7,17} or {1,2} -> {3,4} -> {4,5} -> {16,18}

Either way, the final result is 4

Greedy Strategy 1: Always Choose the Earliest Start Time

Suppose we are planning the meetings. Whenever the previous meeting ends, we select from the remaining project presentations one whose start time is greater than or equal to the current time and whose start time is the earliest.

Is this arrangement reasonable? Clearly not, because it cannot achieve the global optimum. Using the example above, we can easily construct a counterexample:

Following this strategy, the selected projects would be {1,2} -> {2,15} -> {16, 18} , and the method would return 3, whereas the correct answer is 4.

According to our approach to solving greedy problems, if we can construct a counterexample, we discard the strategy.

Greedy Strategy 2: Always Choose the Earliest End Time

This time, we always choose the project with the earliest end time. In the example above, our meeting schedule would be:

{1, 2} -> {3, 4} -> {4, 5} -> {7, 17}

This matches the correct answer from our analysis, so the strategy appears feasible.

How, then, can we prove that this strategy is always optimal?

The answer is: we do not need to prove it. We can verify it directly by writing code.

Implementation of Greedy Strategy 2

Once the greedy strategy has been determined, the approach is straightforward: first sort the entire array by end in ascending order, and then iterate through it. During each iteration, schedule a meeting and record its end time. If the project Start >= currentTime, it can be scheduled. Finally, count the number of scheduled presentations. The implementation is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// BestArrange2 uses a greedy strategy: always choose the project that ends earliest.
func BestArrange2(programs []Program) int {
 // Sort projects by end time in ascending order.
 sort.Slice(programs, func(i, j int) bool {
 return programs[i].End < programs[j].End
 })
 curTime := 0 // Current point on the timeline, starting at 0
 count := 0 // Number of presentations scheduled
 for _, program := range programs {
 if program.Start >= curTime {
 count ++
 curTime = program.End
 }
 }
 return count
}

Verification with a Testing Harness

Brute-Force Implementation

First, we implement a brute-force solution to this problem. This method enumerates every possible arrangement and returns the maximum number of presentations. Recursion can be used here. The code is as follows:

 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


// BestArrange1 uses brute force to enumerate every possible schedule and returns the maximum count.
// It is implemented recursively.
func BestArrange1(programs []Program) int {
 // Start with all projects, a timeline at 0, and no presentations scheduled.
 return bestArrange1Process(programs, 0, 0)
}

// @param leftPrograms contains the projects remaining after one has been selected.
// @param timeLine is the current time after the selected presentation ends.
// @param done is the number of presentations already scheduled.
// Returns the maximum number of presentations achievable from this state.
func bestArrange1Process(leftPrograms []Program, timeLine int, done int) int {
 // If no projects remain, return the number already scheduled.
 if len(leftPrograms) == 0 {
 return done
 }
 max := done
 // Try every remaining project that can start at the current time.
 for i := 0; i < len(leftPrograms); i++ {
 // Remove the selected project, copy the remainder, and recurse.
 if leftPrograms[i].Start >= timeLine {
 next := copyButExcept(leftPrograms, i)
 // Advance the timeline to this project's end and increment the completed count.
 max = utils.Max(max, bestArrange1Process(next, leftPrograms[i].End, done+1))
 }
 }
 return max
}

func copyButExcept(leftPrograms []Program, index int) []Program {
 var ans []Program
 for i, program := range leftPrograms {
 if i != index {
 ans = append(ans, program)
 }
 }
 return ans
}

Code explanation:

1. Recursive function bestArrange1Process

After some projects have already been selected through brute-force enumeration, this recursive function considers the remaining projects, with the timeline advanced to the point when the previously selected projects have finished. It enumerates every remaining project as the next project and returns the maximum number of presentations that can be scheduled.

This function has three parameters:

leftPrograms: the list of remaining projects
timeLine: the time point reached after the previously selected projects have finished
done: the number of presentations already completed

Therefore, the main function invokes it as follows:

1
2
3
4


func BestArrange1(programs []Program) int {
 // Start with all projects, a timeline at 0, and no presentations scheduled.
 return bestArrange1Process(programs, 0, 0)
}

2. Function copyButExcept

After the recursive function selects a project to execute through brute force, copyButExcept removes the selected project from all remaining projects and returns the rest. The remaining projects are then passed into the recursive call, which returns the maximum number of additional presentations.

Testing with the Harness

 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


func TestBestArrange(t *testing.T) {
 testTimes := 100000 // Number of tests
 maxSize := 100
 timeMax := 100
 t.Log("测试开始...")
 for i := 0; i < testTimes; i++ {
 programs := generateRandomPrograms(maxSize, timeMax)
 ans1 := BestArrange1(programs)
 ans2 := BestArrange2(programs)
 if ans1 != ans2 {
 t.Errorf("测试失败 \n 样本：%v \n ans1:%d \n ans2:%d", programs, ans1, ans2)
 return
 }
 }
 t.Log("测试成功")
}

// Returns a random sample of projects.
// maxSize is the maximum number of projects.
// timeMax is the maximum time value for each project.
func generateRandomPrograms(maxSize int, timeMax int) []Program {
 myRand := rand.New(rand.NewSource(time.Now().UnixNano()))
 ans := make([]Program, myRand.Intn(maxSize+1))
 for i := 0; i < len(ans); i++ {
 t1 := myRand.Intn(timeMax + 1)
 t2 := myRand.Intn(timeMax + 1)
 if t1 == t2 {
 ans[i] = Program{Start: t1, End: t1 + 1}
 } else {
 ans[i] = Program{Start: utils.Min(t1, t2), End: utils.Max(t1, t2)}
 }
 }
 return ans
}

After testing 100,000 sets of randomly generated test cases, the results of both implementations are identical, which is sufficient to demonstrate the correctness of Greedy Strategy 2.

Summary

In this article, we applied our problem-solving approach for greedy algorithms to a real greedy algorithm problem.

For this problem, we considered two greedy strategies. We easily constructed a counterexample for the first strategy, so we rejected it. The second strategy worked for our example, so after implementing it, we experimentally verified its correctness using a testing harness.

As mentioned in the previous article, greedy algorithms require continuous accumulation of experience, but they are also among the most natural and elegant types of algorithms. In this example, Greedy Strategy 2 is correct because each step makes the meeting end as early as possible by prioritizing the project with the earliest end time. This leaves more time for other projects, allowing the maximum number of presentations to be scheduled. As you can see, the reasoning is both sensible and natural.

When encountering a greedy problem, we should draw on our accumulated experience to identify possible greedy strategies. We do not need to rigorously prove their correctness. Practice is the sole criterion for testing truth: verify the strategy directly with a testing harness.

Greedy Algorithms I: Exploring Greedy Methodology Through a Basic Problem

Fri, 03 Nov 2023 16:55:59 +0800

A greedy algorithm solves a problem using a greedy strategy. Its core idea is to define a clear and effective strategy that selects the currently optimal solution at each step, with the expectation of reaching the global optimum. In some cases, a greedy strategy produces the optimal solution; in others, it does not. A successful greedy strategy is one that reaches the global optimum.

Characteristics of Greedy Algorithms

Greedy algorithms are among the most “natural and intelligent” algorithms. Just as things in nature evolve by choosing the most favorable conditions available at the moment, greedy algorithms make choices based on what is currently most advantageous.
A greedy algorithm uses a locally most self-serving criterion, always making what appears to be the best choice at the moment.
The difficulty of greedy algorithms lies in proving that a locally optimal criterion can produce the global optimum.
Learning greedy algorithms primarily involves building knowledge and experience.

Starting with a Problem

Below, I will begin with a classic greedy algorithm problem, propose different greedy strategies, and prove that one of them leads to the global optimum.

Problem: Find the Lexicographically Smallest Permutation of a String Array

Given an array of strings strings, concatenate all the strings and return the lexicographically smallest result among all possible concatenations.

For example, given ["df", "abd", "d"], the result should be "abdddf".

What Is Lexicographic Order?

Lexicographic order determines the ordering of two strings in a program. For example, "abc" is smaller than "bbc". The comparison works as follows:

If two strings have the same length, compare them character by character from the beginning. The string with the larger character at the first differing position is larger, regardless of the characters that follow.

For example, "azzz" is smaller than "bcde" because a is smaller than b. Although the following z characters are larger than c, d, and e, the former string is still smaller.
If two strings have different lengths, imagine padding the shorter string with the smallest ASCII value until it has the same length as the longer string, and then compare them.

For example, when comparing "abcd" and "ad", treat "ad" as "ad00" and compare "abcd" with "ad00" (the 0 here represents an imaginary minimum ASCII value, not the actual character 0; every character is larger than it). Since d is larger than b, "ad" is larger than "abcd".
The essence of lexicographic order is to treat strings as numbers and compare their values. For example, two strings consisting only of lowercase letters can be treated as two base-26 numbers. Given "abc" and "kaj", "kaj" is larger because k, the higher-order digit, is larger. Similarly, if the character set contains 65,535 characters, a string can be viewed as a base-65,535 number. The bases differ, but the comparison method is the same: the number with the larger higher-order digit is larger.

A Greedy Approach to the Problem

The solution is straightforward: first sort the array according to a particular strategy, ensuring that concatenating the sorted strings in order produces the lexicographically smallest result among all possible concatenations. Sorting is based on comparisons. For example, when comparing arr[i] and arr[j], which one should come first? This comparison strategy is our greedy strategy. Each comparison uses this strategy to determine which string comes first and which comes later—the local optimum. Once all strings have been sorted, the resulting concatenation satisfies the problem’s requirement—the global optimum.

Therefore, the key question is: what should this comparison strategy be?

Greedy Strategy 1: Sort All Strings Lexicographically and Then Concatenate Them

For example:

1
2
3


["def", "abc", "c"]
By this strategy, the result is:
The end result is "abccdef."

The code implementation is:

1
2
3
4
5
6
7


func minConcatenation(arr []string) string {
 // Incoming comparators, small dictionaries in front, large dictionaries in the back
 sort.Slice(arr, func(i, j int) bool {
 return arr[i] < arr[j]
 })
 return strings.Join(arr, "")
}

This strategy ensures that the strings in the array are sorted in ascending lexicographic order, but does it guarantee that their complete concatenation is lexicographically smallest?

The answer is no.

We can easily construct a counterexample, such as the following:

1
2
3
4


["ba","b"]
After the sequence, the result was "bba."

But obviously, the correct answer is "bab" smaller.

A single counterexample is enough to show that this greedy strategy fails.

Greedy Strategy 2: If a·b < b·a, Place a First; Otherwise, Place b First

Explanation: During sorting, when comparing strings a and b at positions i and j, concatenate a and b in both possible orders before comparing them.

If a·b < b·a, place a first; otherwise, place b first.

In the example above, because "ba·b" < "b·ba", "ba" will ultimately be placed before "b". The sorted array is:

1

["ba", "b"]

This produces the correct answer, "bab". It satisfies the requirement, and the overall solution is as expected.

The code implementation is:

1
2
3
4
5
6
7


func minConcatenation(arr []string) string {
 // The imported comparator, which will be compared after a.b < b.a., and a row in front, or b row in front
 sort.Slice(arr, func(i, j int) bool {
 return arr[i]+arr[j] < arr[j]+arr[i]
 })
 return strings.Join(arr, "")
}

How can we prove that this strategy is indeed a correct greedy strategy?

Proving the Correctness of Greedy Strategy 2

1. Prove That the Sorting Strategy in Greedy Strategy 2 Is Transitive

Under the strategy above, suppose:

a·b <= b·a
b·c <= c·b

If we can derive a·c <= c·a, then the strategy is transitive. The conclusion is that we can indeed derive it. The proof follows:

As mentioned above, comparing strings lexicographically is essentially equivalent to converting them into numbers and comparing their values. For example:

Concatenating "123" and "456" produces "123456", which is effectively 123 * 1000 + 456.

a·b is essentially a base-k number.

Its value is a * k^len(b) + b (a multiplied by k raised to the power of the length of b, plus b).

For convenience in the mathematical description, suppose k^len(b) is represented by a function m(b). We then have:

 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


, which can be defined as:
1) a·b = a*m(b) + b
2) b·a = b*m(a) + a
3) b·c = b*m(c) + c
4) c·b = c*m(b) + b

For example:
1) a*m(b) + b <= b*m(a) + a
2) b*m(c) + c <= c*m(b) + b

We're going to split it by two steps, minus one b, then multiply it by one c. Since c is a string and is a non-negative number, no sign direction is changed after multiplying)
=> a*m(b) <= b*m(a) + a - b
=> a*m(b)*c <= b*m(a)* c + a*c - b*c

We'll divide them by one b and multiply them by a.
=> b*m(c) + c - b <= c*m(b)
=> b*m(c)*a + a*c - a*b <= a*m(b)*c

Thus: b*m(c)*a + a*c - a*b < = a*m(b)*c < = b*m(a)*c + a*c - b*c
Thus: b*m(c)*a + a*c - a*b < = b*m(a)*c + a*c - b*c
There's a*c on both sides.
a*b*m(c) - a*b <= b*c*m(a) - b*c
Remove the b on both sides.
a*m(c) - a <= c*m(a) - c
And this is: a c < = c a

From the derivation above, we have proven that the sorting rule in Greedy Strategy 2 is transitive.

2. Prove That the Entire Sorted Array Is Lexicographically Smallest

After sorting, suppose a is any string that appears earlier and b is any string that appears later, as shown below:

1

[......a.......b......]

We now need to prove that swapping the positions of a and b necessarily increases the lexicographic order of the entire result. The proof is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


We assume that there are only two strings m1 and m2 between a and b, as follows:
[......a,m1,m2,b......]
As this is sequenced, a.m1 sure < = m1a
[......a,m1,m2,b......] <= [......m1,a,m2,b......]
a Before m2, a. m2 < = m2 a, so if the exchange of m2 and a continues, yes
[......m1,a,m2,b......] <= [......m1,m2,a,b......]
The same thing.
[......m1,m2,a,b......] <= [......m1,m2,b,a......]
[......m1,m2,b,a......] <= [......m1,b,m2,a......]
[......m1,b,m2,a......] <= [......b,m1,m2,a......]
As this sorting strategy has been shown to be transmissible, it is ultimately:
[......a,m1,m2,b......] <= [......b,m1,m2,a......]
Note: Any exchange of any two strings in the final array increases the final dictionary sequence.

Although the example above contains only two strings between a and b, it is easy to see that regardless of how many strings lie between them, swapping any such a and b will increase the lexicographic order of the final result. Therefore, after sorting, the overall concatenation must be lexicographically smallest. This completes the proof.

Greedy Methodology

We can see that the rigorous proof above applies only to this specific strategy for this particular problem. Once the problem or strategy changes, the proof is no longer useful. In practice, rigorously proving a greedy strategy mathematically is very difficult.

Moreover, we always propose a greedy strategy first and then attempt to prove it.

Therefore, we only need to verify whether a greedy strategy can produce the global optimum—that is, whether it is correct. We can use the following methods:

If a counterexample can quickly be found for a strategy, the greedy strategy has failed and should be discarded immediately.
If no counterexample can be found, then in addition to a rigorous mathematical derivation like the one above, we can simply verify it experimentally using a test harness.

The test harness works as follows:

First, implement a brute-force solution that has high complexity but is easy to write. It does not have to use a greedy approach.
Implement the greedy strategy we devised.
Generate random test data in code.
Write a test function that runs against the random samples 100,000 times—or more or fewer, depending on the situation. If the brute-force and greedy solutions produce the same result every time, this verifies that the greedy strategy is correct.
If the results differ, the greedy strategy is incorrect. Devise a new greedy strategy and repeat step 4 until a correct one is found.

Note: During testing, the sample size, number of test runs, and other parameters can be adjusted as needed to achieve the verification objective.

This is the proper way to solve greedy algorithm problems. We do not need to prove the strategy; instead, we can directly verify its correctness through experiments.

Solving the Problem Above with a Test Harness

Now that we have introduced experimental verification using a test harness, we can solve the previous problem again in this way. First, we need to implement a purely brute-force solution. The brute-force approach is as follows:

Exhaustively generate the strings produced by all possible permutations of the string array.
Find the lexicographically smallest string among all concatenated permutation results.

The brute-force code is as follows:

 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


// Method I: Violent methods, with all possible sequencing and least dictionaries
func minConcatenation1(arr []string) string {
 if len(arr) == 0 {
 return ""
 }
 // Get the results of all possible grouping.
 ans := process1(arr)
 // Sort the results from small to large by dictionary
 sort.Slice(ans, func(i,j int) bool {
 return ans[i] < ans[j]
 })
 // Number one is the return value.
 return ans[0]
}

// Enter a string array and return the result of the string spelled after all grouping
// Like in.
// Will return ["abcd", "cdab"]
func process1(arr []string) []string {
 ans := make([]string, 0)
 if len(arr) == 0 {
 ans = append(ans, "")
 return ans
 }
 // Starts with the string of the i position, and after the string of the i position is removed, the remaining string list continues to be organized and the characters of the i position are spelled on the head Thread
 for i := 0; i < len(arr); i++ {
 first := arr[i]
 removedList := removeIndexString(arr, i)
 next := process1(removedList)
 for _, cur := range next {
 ans = append(ans, first + cur)
 }
 }
 return ans
}

// Remove string from i position, return new number Group
func removeIndexString(arr []string, index int) []string {
 N := len(arr)
 if N == 0 {
 return nil
 }
 ans := make([]string, N-1)
 ansIndex := 0
 for i:=0; i < N; i ++ {
 if i != index {
 ans[ansIndex] = arr[i]
 }
 }
 return ans
}

Our greedy solution is as follows:

1
2
3
4
5
6


func minConcatenation2(arr []string) string {
 sort.Slice(arr, func(i, j int) bool {
 return arr[i]+arr[j] < arr[j]+arr[i]
 })
 return strings.Join(arr, "")
}

The test harness code is as follows:

 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


package class_14

import (
 "math/rand"
 "testing"
 "time"
)

func TestMinConcatenation(t *testing.T) {
 testTimes := 100000 // Number of tests
 maxStrLength := 5 // Maximum string length in sample
 maxArrayLength := 6 // Maximum size of array in sample
 t.Log("测试开始...")
 for i := 0; i < testTimes; i++ {
 arr := generateRandomStrArr(maxStrLength, maxArrayLength)
 arr1 := copyStringArray(arr)
 arr2 := copyStringArray(arr)
 ans1 := minConcatenation1(arr)
 ans2 := minConcatenation2(arr1)
 if ans1 != ans2 {
 t.Errorf("测试失败\n 数组为：%v\n 暴力方法结果：%s\n 贪心方法结果: %s", arr2, ans1, ans2)
 return
 }
 }
 t.Log("测试成功")
}

const letterBytes = "abcdefghijklmnopqrstuvwxyz"

func generateRandomStrArr(maxStrLength, maxLength int) []string {
 myRand := rand.New(rand.NewSource(time.Now().UnixNano()))
 ans := make([]string, 0)
 n := myRand.Intn(maxLength + 1)
 for i := 0; i < n; i++ {
 ans = append(ans, generateRandomString(maxStrLength))
 }
 return ans
}

func generateRandomString(maxLength int) string {
 myRand := rand.New(rand.NewSource(time.Now().UnixNano()))
 length := myRand.Intn(maxLength+1) + 1
 b := make([]byte, length)
 for i := range b {
 b[i] = letterBytes[myRand.Intn(len(letterBytes))]
 }
 return string(b)
}

func copyStringArray(arr []string) []string {
 // Create a new string array with the same length as the input array
 copiedArray := make([]string, len(arr))

 // Use a cycle to copy each element to a new array Medium
 for i, value := range arr {
 copiedArray[i] = value
 }

 return copiedArray
}

The test result is shown below:

A Standard Approach to Solving Greedy Algorithm Problems

Implement a solution X that does not rely on a greedy strategy. It can use the most straightforward brute-force approach.
Come up with Greedy Strategy A, Greedy Strategy B, Greedy Strategy C, and so on.
Use solution X and a test harness to experimentally determine which greedy strategy is correct.
Do not get hung up on proving the greedy strategy.

Binary Tree Fundamentals and Related Interview Questions

Wed, 25 Oct 2023 23:17:52 +0800

Binary Trees

A binary tree is a classic data structure. Each node has a Value and two subtrees: a left subtree and a right subtree.

Binary Tree Traversal

Binary tree traversal is generally divided into three types: preorder traversal, inorder traversal, and postorder traversal.

Preorder traversal: Visit the root node first, then the left subtree, and finally the right subtree.
Inorder traversal: Visit the left subtree first, then the root node, and finally the right subtree.
Postorder traversal: Visit the left subtree first, then the right subtree, and finally the root node.

These three traversal orders are merely conventions. There are actually six possible traversal orders in total. For example, what kind of traversal would visit the right subtree first, then the left subtree, and finally the root node?

Binary trees can also be traversed level by level, visiting the nodes on each level from left to right. For example:

1
2
3
4
5
6


 1 
 / \ 
 2 3 
 / \ / \ 
4 5 6 7
It's like: 1 2 3 4 5 6 7

Traversing a Binary Tree Recursively

1. Preorder Traversal

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// Pre performs a preorder traversal.
func (r *RecursiveTraversalBT) Pre(root *Node) {
	if root == nil {
		return
	}
	// Print root nodes first
	fmt.Printf("%d ", root.Value)
	// Print left tree again
	r.Pre(root.Left)
	// Print right subtree again
	r.Pre(root.Right)
}

2. Inorder Traversal

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// In-Sequence
func (r *RecursiveTraversalBT) In(root *Node) {
	if root == nil {
		return
	}
	// Print left tree first
	r.In(root.Left)
	// Then visit the current node.
	fmt.Printf("%d ", root.Value)
	// Final printing of the right subtree
	r.In(root.Right)
}

3. Postorder Traversal

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// Post-Pos Sequence
func (r *RecursiveTraversalBT) Pos(root *Node) {
	if root == nil {
		return
	}
	// Print left tree first
	r.Pos(root.Left)
	// Print right subtree again
	r.Pos(root.Right)
	// Finally visit the current node.
	fmt.Printf("%d ", root.Value)
}

Recursive Traversal Sequence

The recursive traversal sequence refers to the fact that each node is reached three times during traversal. The first time is when the current node is initially visited, the second time is after the left subtree has been traversed and execution returns to the current node, and the third time is after the right subtree has been traversed and execution returns to the current node.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


func f(root *Node) {
	if root == nil {
		return
	}
	fmt.Println("第一次到达")
	// Through the left tree.
	f(root.Left)
	fmt.Println("第二次到达")
	// Through the right tree.
	f(root.Right)
	fmt.Println("第三次到达")
}

The essence of preorder traversal is to process the current node when it is reached for the first time. The essence of inorder traversal is to process the current node when it is reached for the second time. The essence of postorder traversal is to process the current node when it is reached for the third time.

Traversing a Binary Tree Iteratively

1. Preorder Traversal

Prepare a stack and follow these steps:

Push the root node onto the stack and continue traversing as long as the stack is not empty.
Pop the top element into cur and print it immediately.
If it has a right subtree, push the right subtree onto the stack. If it has a left subtree, push the left subtree onto the stack. Push the right subtree before the left subtree.
Repeat steps 2 and 3 until the stack is empty.

Explanation: For every subtree, its root node is pushed onto the stack first and then popped. Its right subtree is then pushed, followed by its left subtree. Therefore, the nodes are popped in root-left-right order. This applies to every subtree, so the overall order is preorder traversal.

The code is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// Pre performs a preorder traversal.
func (r *UnRecursiveTraversalBT) Pre(root *Node) {
	if root == nil {
		return
	}
	// Create a stack and push the root node first.
	stack := class_03.NewMyStack[*Node]()
	stack.Push(root)
	for !stack.IsEmpty() {
		cur := stack.Pop()
		// Print when you're out.
		fmt.Printf("%d ", cur.Value)
		// If you have a right tree, you enter it.
		if cur.Right != nil {
			stack.Push(cur.Right)
		}
		// Push the left subtree when present.
		if cur.Left != nil {
			stack.Push(cur.Left)
		}
	}
	fmt.Println()
}

2. Postorder Traversal

In the preorder traversal process, we use a stack to print nodes in root-left-right order. The root is pushed onto and then popped from the stack, after which the root’s right and left subtrees are pushed onto the stack in that order.

Similarly, we can produce a root-right-left order by pushing the left subtree first and then the right subtree after popping the root.

Furthermore, the process above prints a node as soon as it is popped. We can modify it so that a popped node is not printed immediately but is instead pushed onto another stack. After the entire process is complete, we pop and print the nodes from the second stack.

The final output is therefore the reverse of root-right-left, which is left-right-root, implementing postorder traversal.

The code is as follows:

 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


// Post-Pos1 Sequence
func (r *UnRecursiveTraversalBT) Pos1(root *Node) {
	if root == nil {
		return
	}
	s1 := class_03.NewMyStack[*Node]()
	s2 := class_03.NewMyStack[*Node]()
	s1.Push(root)
	for !s1.IsEmpty() {
		head := s1.Pop()
		// Just go out, don't print, but press into another.
		s2.Push(head)
		// Push the left and right children to produce root-right-left order.
		if head.Left != nil {
			s1.Push(head.Left)
		}
		if head.Right != nil {
			s1.Push(head.Right)
		}
	}
	// Everything's done. Out
	for !s2.IsEmpty() {
		fmt.Printf("%d ", s2.Pop().Value)
	}
}

4. Implementing Postorder Traversal with Only One Stack

This process is difficult, and even few interviewers know how to implement it. Zuo did not explain it in class and only provided the code. You may choose whether to learn it. The code is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public static void pos2(Node h) {
	System.out.print("pos-order: ");
	if (h != null) {
		Stack<Node> stack = new Stack<Node>();
		stack.push(h);
		Node c = null;
		while (!stack.isEmpty()) {
			c = stack.peek();
			if (c.left != null && h != c.left && h != c.right) {
				stack.push(c.left);
			} else if (c.right != null && h != c.right) {
				stack.push(c.right);
			} else {
				System.out.print(stack.pop().value + " ");
				h = c;
			}
		}
	}
	System.out.println();
}

5. Inorder Traversal

Inorder traversal visits the left subtree first, then the root node, and finally the right subtree. Regardless of how tall a binary tree is, the first node visited must be the last node on the left boundary, followed by the root node and the right subtree. Therefore, the essence of inorder traversal is to divide the entire tree along its left boundaries.

The inorder traversal process is as follows:

Prepare a stack and a cur variable. Initially, cur points to the root node. Continue looping while the stack is not empty or cur is not nil. Exit when both the stack and cur are empty.

If cur is not nil, push cur onto the stack and move cur to its left subtree.
If cur is nil, pop a node from the stack into cur, print it, and then move cur to its right subtree.
Repeat the process until cur is nil and the stack is empty.

A concrete example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


We take this tree as an example:
 1 
 / \ 
 2 3 
 / \ / \ 
4 5 6 7
1. At the beginning, cur went to the left border until it went to four, went to the inn, stack = one, two, four on the top, and then cur went to the left child, and it was empty.
2. Eject 4 printing. The inn is 12, Cur points to the right child. Cur is empty.
3. Eject 2 print, the stack is 1, Cur points to 5 to the right child, not empty, 5 to the left child, 15 to the left child, is empty
4. Eject 5 print. The stack is 1, Cur points to the right child as empty.
5. Pop one print, the inn is empty, Cur points to the right one, three.
6. 3入栈，栈是3，cur指向3的左孩子6
7. 6入栈，栈是3 6，cur指向6的左孩子，为空
8. Eject 6 print, the inn is 3, Cur points to the right child as empty.
9. Eject 3 printout. The inn is empty. Cur points to the right child of 3.
10.7入栈，栈是7，cur指向7的左孩子，是空
11.Eject 7 printing, Cur points to the right child of 7. It is empty, and it is empty, and Cur is empty and the cycle exits.
So, four, two, five, one, six, three, seven.

The code is as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// In-Sequence
func (r *UnRecursiveTraversalBT) In(root *Node) {
	if root == nil {
		return
	}
	// Push nodes while following the left boundary of the tree.
	stack := class_03.NewMyStack[*Node]()
	cur := root
	for !stack.IsEmpty() || cur != nil {
		if cur != nil {
			stack.Push(cur)
			cur = cur.Left
		} else {
			cur = stack.Pop()
			fmt.Printf("%d ", cur.Value)
			cur = cur.Right
		}
	}
	fmt.Println()
}

6. Implementing Level-Order Traversal

If a binary tree is viewed as a graph, level-order traversal is breadth-first search and can be implemented using a queue.

Prepare a queue and first enqueue the root node.

Dequeue a node, print it, and assign it to cur.
If cur has a left child, enqueue the left child. If it has a right child, enqueue the right child.
Repeat steps 1 and 2 until the queue is empty.

Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


We take this tree as an example:
 1 
 / \ 
 2 3 
 / \ / \ 
4 5 6 7
1. 1入队列
2. 1弹出，打印，1给cur，cur的左右子树入队列[2,3]
3. 2弹出，打印，2给cur，cur的左右子树入队列[3,4,5]
4. 3弹出，打印，3个cur，cur的左右子树入队列[4,5,6,7]
5. 4弹出，打印，无左右子树，不入队列
6. 5弹出，打印，无左右子树，不入队列
7. 6弹出，打印，无左右子树，不入队列
8. 7弹出，打印，入左右子树，不入队列

In summary, the overall print order is 1 2 3 4 5 6 7 by layer.

Summary: This process traverses the tree level by level, but during traversal, we do not know where each level begins or ends. Some algorithm problems require this information, such as finding the maximum width of a level.

Binary Tree Serialization and Deserialization

Given a binary tree in memory, we can convert it into a unique string according to a particular set of rules and reconstruct the same unique binary tree from that string. This is serialization and deserialization.

The conventional approaches are preorder serialization and level-order serialization.

For example, during preorder traversal, nil nodes are not omitted but are represented by #. For non-nil nodes, their values are appended, and all entries are separated by ,.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


 1 
 / \ 
 2 3 
 / \ / \ 
 4 5 6 7
 /\ / \ / \ / \
 nil nil nil nil nil nil nil nil
 
The sequence is: "1,2,4,#, #, 5, #, #, #, 3, 6, #, #, 7, #"

When it's re-sequenced, it's re-established in a priori way.

A binary tree can be serialized and deserialized using preorder, postorder, or level-order traversal. However, a binary tree cannot be serialized and deserialized using inorder traversal. This is because two different trees may produce the same inorder sequence, even if placeholders for nil nodes are included. Consider the following two trees:

After filling in the nil positions, both produce the same inorder traversal result: { null, 1, null, 2, null} (#,1,#,2,#).

Empty Trees

If the serialized string is “#”, whether preorder, postorder, or level-order serialization is used, it represents a single nil node—that is, an empty tree. An empty string can also represent an empty tree. To avoid ambiguity, we specify that an empty tree must always be serialized as “#”. During deserialization, both an empty string and “#” are deserialized as an empty tree.

Code Implementation

 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
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262


// Sequenced and inverse fork tree

// Sets the head node of a fork tree, returns the serialized string
// Rule: Comma-separated between node values and empty node #

// SerializeAndReconstractBT to sequence and inverse the fork tree
type SerializeAndReconstructBT struct{}

// PreSerialize sequenced into string
func (s *SerializeAndReconstructBT) PreSerialize(head *TreeNode) string {
	queue := class_03.NewMyQueue[string]()
	// Sequenced
	s.preSerialize(head, queue)
	// Convert Queue to String
	return s.queueToStr(queue)
}

// Recursively sequenced
func (s *SerializeAndReconstructBT) preSerialize(head *TreeNode, queue *class_03.MyQueue[string]) {
	if head == nil {
		queue.Push("#")
	} else {
		// Let's go first.
		queue.Push(strconv.Itoa(head.Val))
		// Then to the left and the right.
		s.preSerialize(head.Left, queue)
		s.preSerialize(head.Right, queue)
	}
}

// Sequenced sequence of InSerialize
func (s *SerializeAndReconstructBT) InSerialize(head *TreeNode) string {
	queue := class_03.NewMyQueue[string]()
	// Sequenced
	s.inSerialize(head, queue)
	// Convert Queue to String
	return s.queueToStr(queue)
}

// Recursively sequence the middle sequence
func (s *SerializeAndReconstructBT) inSerialize(head *TreeNode, queue *class_03.MyQueue[string]) {
	if head == nil {
		queue.Push("#")
	} else {
		// Do left tree first.
		s.inSerialize(head.Left, queue)
		// Incoming.
		queue.Push(strconv.Itoa(head.Val))
		// And execute the right subtree.
		s.inSerialize(head.Right, queue)
	}
}

// Pos Serialize Sequenced to String
func (s *SerializeAndReconstructBT) PosSerialize(head *TreeNode) string {
	queue := class_03.NewMyQueue[string]()
	// Sequenced
	s.posSerialize(head, queue)
	// Convert Queue to String
	return s.queueToStr(queue)
}

// Recursive sequence
func (s *SerializeAndReconstructBT) posSerialize(head *TreeNode, queue *class_03.MyQueue[string]) {
	if head == nil {
		queue.Push("#")
	} else {
		// Do left tree first.
		s.posSerialize(head.Left, queue)
		// And execute the right subtree.
		s.posSerialize(head.Right, queue)
		// Incoming.
		queue.Push(strconv.Itoa(head.Val))
	}
}

func (s *SerializeAndReconstructBT) queueToStr(queue *class_03.MyQueue[string]) string {
	if queue == nil || queue.IsEmpty() {
		return ""
	}
	var ans string
	isFirst := true
	for !queue.IsEmpty() {
		if isFirst {
			ans += queue.Poll()
			isFirst = false
		} else {
			ans += "," + queue.Poll()
		}
	}
	return ans
}

// Level Serialize Sequence by Layer
func (s *SerializeAndReconstructBT) LevelSerialize(head *TreeNode) string {
	queue := class_03.NewMyQueue[string]()
	// Sequenced
	// Prepare a Node queue for all layers.
	nodeQueue := NewTreeNodeQueue()
	// First in line.
	nodeQueue.Push(head)
	for !nodeQueue.IsEmpty() {
		// Let's go first.
		head = nodeQueue.Poll()
		// When you're out of the queue, add sequence. It's probably empty.
		if head == nil {
			queue.Push("#")
		} else {
			queue.Push(strconv.Itoa(head.Val))
			// The right and right sub-trees are in the queue. They don't judge empty, because empty is sequenced.
			nodeQueue.Push(head.Left)
			nodeQueue.Push(head.Right)
		}
	}
	// Convert Queue to String
	return s.queueToStr(queue)
}

// Inverse sequence

// BuildByPreSerialize transforms the string back into a tree by sequencing it.
func (s *SerializeAndReconstructBT) BuildByPreSerialize(preSer string) *TreeNode {
	// Empty Tree
	if preSer == "" || preSer == "#" {
		return nil
	}
	// Revert to Serialization Queue
	preQueue := s.getQueue(preSer)
	// Build a target tree by queue
	ans := s.buildByPreQueue(preQueue)
	return ans
}

func (s *SerializeAndReconstructBT) buildByPreQueue(queue *class_03.MyQueue[string]) *TreeNode {
	// Take one out of the queue as header Points
	head := s.buildNodeByQueue(queue)
	// Recursive
	if head != nil {
		head.Left = s.buildByPreQueue(queue)
		head.Right = s.buildByPreQueue(queue)
	}
	return head
}

// BuildByPosSerialize inverse string to tree after serialization
// 1
// / \
// 2 3
// /
// 4
// #,#,2,#,#,4,#,3,1
func (s *SerializeAndReconstructBT) BuildByPosSerialize(posSer string) *TreeNode {
	// Empty Tree
	if posSer == "" || posSer == "#" {
		return nil
	}
	// Back-to-back sequences: left right head, first left tree, then right subtree, then head node
	// And we've done it all the time: head, left, right.

	// In reordering the code of the non-retrogression method, we're going to start with the head, left, right, then the head, right, left.
	// And then you reverse it with a stack, and you turn it into a left, right, head sequence, which means you've got to go through it.

	// It's the same here, if the value of the posser is pressed sequentially into a canal, it becomes the head, right, left order, and then we proceed in a sequential way.

	// Revert to Serialized Stack.
	posStack := s.getStack(posSer)
	// Build a target tree by queue
	ans := s.buildByPosStack(posStack)
	return ans
}

func (s *SerializeAndReconstructBT) buildByPosStack(posStack *class_03.MyStack[string]) *TreeNode {
	// The current stack is the head, right, left, first the head, then the right, then the left.
	// 1. Ejection value
	strValue := posStack.Pop()
	if strValue == "#" {
		return nil
	}
	// Build header first
	headValue, _ := strconv.Atoi(strValue)
	head := &TreeNode{Val: headValue}
	// Recursive, build left and right subpoints, note that the order in the stack is head right left, so build follows the order first right and then left
	if head != nil {
		head.Right = s.buildByPosStack(posStack)
		head.Left = s.buildByPosStack(posStack)
	}
	return head
}

// BuildByLevelSerialize back-sequencing in layers
// 1
// / \
// 2 3
// /
// 4
// 1,2,3,#,#,4,#,#,#
func (s *SerializeAndReconstructBT) BuildByLevelSerialize(preSer string) *TreeNode {
	// Empty Tree
	if preSer == "" || preSer == "#" {
		return nil
	}
	// Revert to Serialization Queue
	preQueue := s.getQueue(preSer)
	// Build a target tree by queue
	ans := s.buildByLevelQueue(preQueue)
	return ans
}

func (s *SerializeAndReconstructBT) buildByLevelQueue(queue *class_03.MyQueue[string]) *TreeNode {
	head := s.buildNodeByQueue(queue)
	// Build a Node queue
	nodeQueue := NewTreeNodeQueue()
	// Queue front nodes
	nodeQueue.Push(head)
	for !nodeQueue.IsEmpty() {
		// Queue header
		node := nodeQueue.Poll()
		// The next two of the left trees of the current head queue must be the right and right trees of the current node
		left := s.buildNodeByQueue(queue)
		right := s.buildNodeByQueue(queue)
		if node != nil {
			node.Left = left
			node.Right = right
			if left != nil {
				nodeQueue.Push(left)
			}
			if right != nil {
				nodeQueue.Push(right)
			}
		}
	}
	return head
}

func (s *SerializeAndReconstructBT) getQueue(serialized string) *class_03.MyQueue[string] {
	queue := class_03.NewMyQueue[string]()
	for _, str := range strings.Split(serialized, ",") {
		queue.Push(str)
	}
	return queue
}

func (s *SerializeAndReconstructBT) getStack(serialized string) *class_03.MyStack[string] {
	stack := class_03.NewMyStack[string]()
	for _, str := range strings.Split(serialized, ",") {
		stack.Push(str)
	}
	return stack
}

func (s *SerializeAndReconstructBT) buildNodeByQueue(queue *class_03.MyQueue[string]) *TreeNode {
	if queue.IsEmpty() {
		return nil
	}
	v := queue.Poll()
	if v == "#" {
		return nil
	} else {
		nodeValue, _ := strconv.Atoi(v)
		return &TreeNode{Val: nodeValue}
	}
}

See the code for details:

code04_serialize_and_reconstruct_tree.go

Algorithm Interview Question: Encode an N-ary Tree as a Binary Tree

Encode N-ary Tree to Binary Tree

Original LeetCode problem: https://leetcode.cn/problems/encode-n-ary-tree-to-binary-tree/

Design an algorithm that encodes an N-ary tree into a binary tree and decodes the binary tree back into the original N-ary tree. An N-ary tree is a rooted tree in which each node has no more than N children. Similarly, a binary tree is a rooted tree in which each node has no more than two children. There are no restrictions on the implementation of your encoding and decoding algorithms. You only need to ensure that an N-ary tree can be encoded into a binary tree and that the binary tree can be decoded back into the original N-ary tree.

The binary tree can be viewed as the serialized representation of the N-ary tree, from which the original N-ary tree can be reconstructed.

For example, you could encode the following ternary tree in this way:

Note that the method above is only an example and may or may not work. You do not need to follow this conversion format; you may devise and implement a different method.

Approach

The approach can be summarized in one sentence: Suppose x is any node in the N-ary tree. Place all children of x along the right boundary starting from the left child of x in the binary tree. Here is an example:

Suppose we have the following N-ary tree:

The binary tree produced using the approach above is as follows:

As we can see, all of a’s children are attached along the right boundary of a’s left subtree: b->c->d.

The children of b are also attached along the right boundary beginning with b’s left child: e->f.

All of c’s children are attached along the right boundary beginning with c’s left child: g->h->i->j.

Detailed Code Explanation

 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


/**
 * Definition for a Node.
 * type Node struct {
 * Val int
 * Children []*Node
 * }
 */

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 * Val int
 * Left *TreeNode
 * Right *TreeNode
 * }
 */


type Codec struct {
}

func Constructor() *Codec {
	return &Codec{}
}

func (this *Codec) encode(root *Node) *TreeNode {
	if root == nil {
		return nil
	}
	btRoot := &TreeNode{Val: root.Val}
	btRoot.Left = this.ec(root.Children)
	return btRoot
}

// Attach all children along the right boundary of btRoot's left child.
func (this *Codec) ec(children []*Node) *TreeNode {
	var head *TreeNode
	var cur *TreeNode
	for _, child := range children {
		childBT := &TreeNode{Val: child.Val}
		if head == nil {
			head = childBT
		} else {
			cur.Right = childBT
		}
		cur = childBT
		cur.Left = this.ec(child.Children)
	}
	return head
}

func (this *Codec) decode(root *TreeNode) *Node {
	if root == nil {
		return nil
	}
	nRoot := &Node{Val: root.Val, Children: this.dc(root.Left)}
	return nRoot
}

func (this *Codec) dc(left *TreeNode) []*Node {
	var children []*Node
	cur := left
	for cur != nil {
		n := &Node{Val: cur.Val, Children: this.dc(cur.Left)}
		children = append(children, n)
		cur = cur.Right
	}
	return children
}

See the code for details:

code05_encode_nary_tree_to_binary_tree.go

Algorithm Interview Question: Given a Binary Tree, Return Its Maximum Width

For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


 1
 / \
 2 3
 / \
 4 5
 /
 6
 \
 7
The width of the 2rd layer is 2 and returns 2.
Obviously it's not the higher the width of the layers.

Approach

We have already implemented level-order traversal. If we can keep track of where the current level begins and ends during traversal, we can calculate the width of each level. This assumes that you are already familiar with the level-order traversal process. If not, refer to the earlier level-order traversal code. We only need a few variables, defined as follows:

max: Records the maximum width globally. Whenever the width of a level exceeds max, update max. Finally, return max.
curEnd (*TreeNode type): Records the final node of the level currently being traversed.
nextEnd (*TreeNode type): Records the final node of the next level to be traversed, preparing for traversal of that level.
count: Records the width of the current level. Whenever a node from the current level is dequeued, increment count.

The process is illustrated below: Suppose a tree has the following structure:

The process proceeds as follows:

 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


max=0; curEnd=nil; nextEnd=nil; count=0;
1. Queue to 1, 1, Curend = 1; queue = [1];

2. 1出队列，count++; 
 1Left child 2 in queue, nextend = 2;
 1Right child 3 in line, nextend = 3;
 As 1=curEnd, the current line ends, max is updated to 1, while curEnd=nextEnd, nextEnd=nil, count zero;
 Final: queue= [3,2]; count=0; max=1; Curend=3; nextend= Neil

3. 2出队列，count++，count=1;
 2Left child 4 in line, nextend = 4;
 2Right child 5 in line, nextend = 5;
 Ultimately: queue= [5,4,3]; count=1; max=1; Curend=3; nextend=5;

4. 3出队列，count++,count=2;
 3No left child, why don't we line up?
 3Right child in line, nextend = 6;
 As 3=curEnd, current line end, max update to 2, while curEnd=nextEnd, nextEnd=nil, count zero
 Final: queue = [6,5,4]; count = 0; max = 2; Curend = 6; nextend = Neil;

5. 4出队列，count++，count=1，4没有孩子，不入队列。

6. 5出队列，count++，count=2；
 5Left child 7 in line, nextend = 7;
 Ultimately: queue = [7,6]; count = 2; max = 2; Curend = 6; nextend = 7;

7. 6出队列，count++，count=3；
 6Right child 8 in line, nextend = 8;
 Due to 6=curEnd, current line end, max update to 3 with curEnd=nextEnd, nextEnd=nil, count zero
 Final: queue = [8,7]; count = 0; max = 3; Curend = 8; nextend = Neil;
 
8. 7出队列，count++,count=1;
 7No children, no queue, 7 is not the same as curend, and the current line continues;
 
9. 8出队列，count++,count=2;
 8No children, no queues;
 As a result of 8=curEnd, the current line ends, max = 3 = 2 = not updated, while curEnd = nextEnd, nextEnd = Nil, count zero.
 Ultimately: queue=[]; count=2; max=3; Curend=nil; nextend=nil;
 At this point, the team is empty and the entire process is over and returns the maximum value 3.

Summary: Whenever a node is visited—that is, dequeued—we prepare the final node of the next level in advance and continually move it to the right. When the current level ends, nextEnd will point exactly to the final node of the next level. At the same time, curNext tells us whether the current level has ended.

Code Implementation

 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


package class_11_12

import "ZuoShenAlgorithmGo/utils"

// Set a fork tree and return maximum width

// MaxWidth doesn't use containers to make it happen.
func MaxWidth(root *TreeNode) int {
	if root == nil {
		return 0
	}
	// Generate a queue of the FreeNode type
	queue := NewTreeNodeQueue()
	var curEnd = root // End of current line
	var nextEnd *TreeNode // End of next line
	var count int // Statistics the width of the current row
	var max int // Maximum width of the whole tree
	// Enqueue the root node first.
	queue.Push(root)
	// Queue is not empty, but it's going on.
	for !queue.IsEmpty() {
		// Dequeue one node and increment the current level width.
		cur := queue.Poll()
		count++
		// As long as there are right and right trees, it's the next line. Stay.
		if cur.Left != nil {
			queue.Push(cur.Left)
			nextEnd = cur.Left
		}
		if cur.Right != nil {
			queue.Push(cur.Right)
			nextEnd = cur.Right
		}
		// Determines whether the current line is now over, and if the current line is over, calculates max and resets the count, curend, nextend 3 variables
		if cur == curEnd {
			max = utils.Max(max, count)
			count = 0
			curEnd = nextEnd
			nextEnd = nil
		}
	}
	return max
}

// MaxWidthWithMap
func MaxWidthWithMap(root *TreeNode) int {
	if root == nil {
		return 0
	}
	// Generate a queue of the FreeNode type
	queue := NewTreeNodeQueue()
	// Generate a Map to record each node at the first level
	nodeLevelMap := make(map[*TreeNode]int)
	curLevel := 1 // Recording the current level
	count := 0 // Number of current layers of statistics
	max := 0 // Count the maximum width of the whole tree
	// First head node in line, while marking root on the first floor.
	queue.Push(root)
	nodeLevelMap[root] = 1

	// Queue is not empty, but it's going on.
	for !queue.IsEmpty() {
		// Popup a Node
		cur := queue.Poll()
		// Get this node on the first floor.
		curNodeLevel := nodeLevelMap[cur]
		// If current layer, the number of current layer ++
		if curNodeLevel == curLevel {
			count++
		} else {
			// If it's not the current layer, CurLevel jumps to the next layer.
			curLevel = curNodeLevel
			count = 1
		}
		max = utils.Max(max, count)
		// As long as there's a tree on the right and the right, it's the next line.
		if cur.Left != nil {
			queue.Push(cur.Left)
			nodeLevelMap[cur.Left] = curLevel + 1
		}
		if cur.Right != nil {
			queue.Push(cur.Right)
			nodeLevelMap[cur.Right] = curLevel + 1
		}
	}
	return max
}

See the code for details:

code05_tree_max_width.go

Interview Question: Given a Node in a Binary Tree with Parent Pointers, Return Its Successor Node

The binary tree node structure is as follows:

1
2
3
4
5
6


type TreeNodeP struct {
	Val int
	Parent *TreeNodeP
	Left *TreeNodeP
	Right *TreeNodeP
}

Given a node in this binary tree, return its successor node. If it has no successor, return nil.

Successor Node

A successor node is the node immediately following a given node when the binary tree’s nodes are arranged in inorder traversal order. For example, consider the following binary tree:

1
2
3
4
5
6
7
8
9


 a
 / \
 b c
 / \ / \
 d e f g
 / \
 h i
 \
 j

Its inorder traversal is dbeahfijcg. Therefore, the successor of b is e, and the successor of c is g.

Approach

Normally, to find the successor of a node in a binary tree, we need both the root node and the target node X. We first generate the inorder traversal sequence from the root node and then find the node following X in that sequence. The time complexity of this process is O(N), where N is the number of nodes.

Now that node X can access its parent, we can solve the problem using only X, without being given the root node. This is because X can repeatedly move upward until it reaches the root, after which the inorder traversal can be generated.

However, this method still has O(N) time complexity. Is there a way to achieve O(K) time complexity, where K is the distance between the current node and its successor? For example, in the tree above, the successor of node e is the root node a, and the distance between e and a is only 2, while traversing the entire tree involves 10 nodes.

The answer is yes. The process is as follows:

If X has a right child, the successor of X is the leftmost node in X’s right subtree. For example, the successor of a above is h, the leftmost node in its right subtree.
If X has no right child, follow its parent pointers upward. If X is the right child of its parent, continue moving upward until reaching a node that is the left child of its parent. That parent is the successor of X. For example, starting from node j above, we find its parent i. Since j is the right child of i, continue. We then find i’s parent f. Since i is the right child of f, continue. Next, we find f’s parent c. Since f is the left child of c, stop. Therefore, c is the successor of i.
If step 2 reaches nil without finding a node that is the left child of its parent, the original node is the rightmost node in the entire tree and has no successor.

The time complexity of this process is O(K).

Code Implementation

 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


package class_11_12

import "ZuoShenAlgorithmGo/class_03"

// Sets a node of a fork tree with a parent pointer, returns the node of the node Points

type TreeNodeP struct {
	Val int
	Parent *TreeNodeP
	Left *TreeNodeP
	Right *TreeNodeP
}

func GetSuccessorNode(node *TreeNodeP) *TreeNodeP {
	if node == nil {
		return nil
	}
	// With right subtree, get the leftmost node of the right subtree
	if node.Right != nil {
		return getLeftMost(node.Right)
	} else {
		// No right tree.
		parent := node.Parent
		for parent != nil && parent.Right == node {
			node = parent
			parent = node.Parent
		}
		return parent
	}
}

// Find the left end of a tree.
func getLeftMost(node *TreeNodeP) *TreeNodeP {
	// Row left until Left is empty.
	cur := node
	for cur.Left != nil {
		cur = cur.Left
	}
	return cur
}

// GetSuccessor NodeNormal common method to find a follow-up node and do a logarithmometer test
func GetSuccessorNodeNormal(node *TreeNodeP) *TreeNodeP {
	if node == nil {
		return nil
	}
	// Found Roots
	root := node
	for root.Parent != nil {
		root = root.Parent
	}
	// Middle Sequence
	inQueue := class_03.NewMyQueue[*TreeNodeP]()
	inTreeNodeP(root, inQueue)
	// Middle-sequence eject and find the next
	for !inQueue.IsEmpty() && inQueue.Peek() != node {
		inQueue.Poll()
	}
	// Popup Current Node
	inQueue.Poll()
	// Popup Next of the current node
	return inQueue.Poll()
}

func inTreeNodeP(root *TreeNodeP, inQueue *class_03.MyQueue[*TreeNodeP]) {
	if root == nil {
		return
	}
	inTreeNodeP(root.Left, inQueue)
	inQueue.Push(root)
	inTreeNodeP(root.Right, inQueue)
}

See the code for details:

code06_successor_node.go

Microsoft Interview Question: The Binary Tree Paper-Folding Problem

Place a strip of paper vertically on a table. Fold it once from the bottom upward, press it to create a crease, and then unfold it. The crease is now concave, meaning that its raised side points toward the back of the paper. If the strip is folded twice consecutively from the bottom upward and then unfolded, there will be three creases. From top to bottom, they are a down crease, a down crease, and an up crease. Given an input parameter N, representing the number of times the strip is folded consecutively from the bottom upward, print the directions of all creases from top to bottom. For example, when N=1, print: down. When N=2, print: down down up.

Approach

After folding once, one concave crease appears, which we denote as 1-concave. After folding twice, a concave crease and a convex crease appear above and below the first crease, respectively. We denote them as 2-concave and 2-convex. The resulting order is concave, concave, convex. After folding three times, a concave crease and a convex crease appear above and below each crease introduced during the second fold. We denote them as 3-concave and 3-convex. The resulting order is concave, concave, convex, concave, concave, convex, convex.

In other words, each time we fold the paper, a concave crease and a convex crease appear above and below every crease introduced during the previous fold. This forms a complete binary tree, as shown below:

1
2
3
4
5
6
7
8


We're dented, } } } } , and three times folded as follows:

 1Dent
 / \
 2Zoom 2
 / \ / \
 3Zoom. Three. Three.
Go, go, go, go!

The objective of the problem is to print the inorder traversal of the tree above.

This binary tree has the following characteristics:

The root node is concave.
The root node of every left subtree is concave.
The root node of every right subtree is convex.

Code Implementation

 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


package class_11_12

import "fmt"

// The issue of dident tree origami

// PrintAllFolds in the order in which the creases are printed in turn
func PrintAllFolds(n int) {
	// Print from 1st floor (starting with root node) and a total of n, and the creases from 1st layer are dent marks
	process(1, n, true)
	fmt.Println()
}

// Recursive process: Imagine a problem-like fork tree, which is currently at some point in the first layer of the fork tree, with a total of N layers.
// And the crease of the current node is down = true, the dent, the false.
// Print the middle sequence of this subtree
func process(i int, n int, down bool) {
	// If the current layer exceeds the total number, return
	if i > n {
		return
	}
	// First left, then head, and then right.
	// I'll print the left tree. My left tree must have a dent and a layer bigger than me.
	process(i+1, n, true)
	// Print me again.
	if down {
		fmt.Print("凹 ")
	} else {
		fmt.Print("凸 ")
	}
	// Finally printing the right tree, my right tree must be crumbling, and it's one more layer than I am.
	process(i+1, n, false)
}

See the code for details:

code07_paper_folding.go