📜  左右遍历所有二叉树

📅  最后修改于: 2021-05-30 05:44:36             🧑  作者: Mango

给定一个以节点1为根的二叉树,任务是按照以下定义的顺序打印元素。

  1. 首先,以另一种方式打印最后一层的所有元素,例如,首先打印最左边的元素,然后再打印最右边的元素,并继续进行此操作,直到遍历所有元素到最后一层。
  2. 现在,对其余级别执行相同的操作。

例子:

Input:
            1
          /   \
        2      3
      /   \   /
     4     5 6
Output: 4 6 5 2 3 1
Explanation:
First print all elements of the last 
level which will be printed as follows: 4 6 5
Now tree becomes
       1
     /   \
    2     3
    
Now print elements as 2 3
Now the tree becomes: 1

Input:
        1
      /   \
     2     3
Output: 2 3 1

方法

  • 进行bfs调用,并将第i级存在的所有节点存储在向量数组中。
  • 还要跟踪bfs调用中达到的最大级别。
  • 现在打印从最大级别到0的所需图案

下面是上述方法的实现:

C++
// C++ implementation
// for the above approach
#include 
using namespace std;
 
const int sz = 1e5;
int maxLevel = 0;
 
// Adjacency list
// representation of the tree
vector tree[sz + 1];
 
// Boolean array to mark all the
// vertices which are visited
bool vis[sz + 1];
 
// Integer array to store
// the level of each node
int level[sz + 1];
 
// Array of vector where ith index
// stores all the nodes at level i
vector nodes[sz + 1];
 
// Utility function to create an
// edge between two vertices
void addEdge(int a, int b)
{
    // Add a to b's list
    tree[a].push_back(b);
 
    // Add b to a's list
    tree[b].push_back(a);
}
 
// Modified Breadth-First Function
void bfs(int node)
{
  // Create a queue of {child, parent}
  queue > qu;
 
  // Push root node in the front of
  // the queue and mark as visited
  qu.push({ node, 0 });
  nodes[0].push_back(node);
  vis[node] = true;
  level[1] = 0;
 
  while (!qu.empty()) {
 
    pair p = qu.front();
    // Dequeue a vertex from queue
    qu.pop();
    vis[p.first] = true;
 
    // Get all adjacent vertices of the dequeued
    // vertex s. If any adjacent has not
    // been visited then enqueue it
    for (int child : tree[p.first]) {
        if (!vis[child]) {
            qu.push({ child, p.first });
            level[child] = level[p.first] + 1;
            maxLevel = max(maxLevel, level[child]);
            nodes[level[child]].push_back(child);
        }
    }
  }
}
 
// Function to display
// the pattern
void display()
{
  for (int i = maxLevel; i >= 0; i--) {
    int len = nodes[i].size();
    // Printing all nodes
    // at given level
    for (int j = 0; j < len / 2; j++) {
        cout << nodes[i][j] << " " << nodes[i][len - 1 - j] << " ";
    }
    // If count of nodes
    // at level i is odd
    // print remaining node
    if (len % 2 == 1) {
        cout << nodes[i][len / 2] << " ";
    }
  }
}
 
// Driver code
int main()
{
  // Number of vertices
  int n = 6;
 
  addEdge(1, 2);
  addEdge(1, 3);
  addEdge(2, 4);
  addEdge(2, 5);
  addEdge(3, 6);
 
  // Calling modified bfs function
  bfs(1);
 
  display();
 
  return 0;
}


Java
// Java implementation
// for the above approach
import java.util.*;
 
@SuppressWarnings("unchecked")
 
class GFG{
  
static int sz = 100000;
static int maxLevel = 0;
   
// Adjacency list
// representation of the tree
static ArrayList []tree = new ArrayList[sz + 1];
   
// boolean array to mark all the
// vertices which are visited
static boolean []vis = new boolean[sz + 1];
   
// Integer array to store
// the level of each node
static int []level = new int[sz + 1];
   
// Array of vector where ith index
// stores all the nodes at level i
static ArrayList []nodes = new ArrayList[sz + 1];
   
// Utility function to create an
// edge between two vertices
static void addEdge(int a, int b)
{
     
    // Add a to b's list
    tree[a].add(b);
   
    // Add b to a's list
    tree[b].add(a);
}
 
static class Pair
{
    int Key, Value;
    Pair(int Key, int Value)
    {
        this.Key = Key;
        this.Value = Value;
    }
}
   
// Modified Breadth-Key Function
static void bfs(int node)
{
     
    // Create a queue of {child, parent}
    Queue qu = new LinkedList<>();
     
    // Push root node in the front of
    // the queue and mark as visited
    qu.add(new Pair(node, 0));
    nodes[0].add(node);
    vis[node] = true;
    level[1] = 0;
      
    while (qu.size() != 0)
    {
        Pair p = qu.poll();
                                              
        // Dequeue a vertex from queue
        vis[p.Key] = true;
          
        // Get all adjacent vertices of the dequeued
        // vertex s. If any adjacent has not
        // been visited then put it
        for(int child : (ArrayList)tree[p.Key])
        {
            if (!vis[child])
            {
                qu.add(new Pair(child, p.Key));
                level[child] = level[p.Key] + 1;
                maxLevel = Math.max(maxLevel,
                                    level[child]);
                nodes[level[child]].add(child);
            }
        }
    }
}
   
// Function to display
// the pattern
static void display()
{
    for(int i = maxLevel; i >= 0; i--)
    {
        int len = nodes[i].size();
         
        // Printing all nodes
        // at given level
        for(int j = 0; j < len / 2; j++)
        {
            System.out.print((int)nodes[i].get(j) + " " +
                             (int)nodes[i].get(len - 1 - j) +
                             " ");
        }
          
        // If count of nodes
        // at level i is odd
        // print remaining node
        if (len % 2 == 1)
        {
            System.out.print(
                (int)nodes[i].get(len / 2) + " ");
        }
    }
}
  
// Driver code
public static void main(String[] args)
{
    for(int i = 0; i < sz + 1; i++)
    {
        tree[i] = new ArrayList();
        nodes[i] = new ArrayList();
        vis[i] = false;
        level[i] = 0;
    }
      
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
    addEdge(3, 6);
      
    // Calling modified bfs function
    bfs(1);
      
    display();
}
}
 
// This code is contributed by pratham76


Python3
# Python3 implementation
# for the above approach
from collections import deque
 
sz = 10 ** 5
maxLevel = 0
 
# Adjacency list
# representation of the tree
tree = [[] for i in range(sz + 1)]
 
# Boolean array to mark all the
# vertices which are visited
vis = [False] * (sz + 1)
 
# Integer array to store
# the level of each node
level = [0] * (sz + 1)
 
# Array of vector where ith index
# stores all the nodes at level i
nodes = [[] for i in range(sz + 1)]
 
# Utility function to create an
# edge between two vertices
def addEdge(a, b):
     
    global tree
     
    # Add a to b's list
    tree[a].append(b)
 
    # Add b to a's list
    tree[b].append(a)
 
# Modified Breadth-First Function
def bfs(node):
     
    global maxLevel
     
    # Create a queue of {child, parent}
    qu =  deque()
     
    # Push root node in the front of
    # the queue and mark as visited
    qu.append([node, 0 ])
 
    nodes[0].append(node)
    vis[node] = True
    level[1] = 0
 
    while (len(qu) > 0):
 
        p = qu.popleft()
         
        # Dequeue a vertex from queue
        # qu.pop()
        vis[p[0]] = True
 
        # Get all adjacent vertices of the dequeued
        # vertex s. If any adjacent has not
        # been visited then enqueue it
        for child in tree[p[0]]:
            if (not vis[child]):
                qu.append([child, p[0]])
                level[child] = level[p[0]] + 1
                maxLevel = max(maxLevel, level[child])
                nodes[level[child]].append(child)
 
# Function to display
# the pattern
def display():
 
    for i in range(maxLevel, -1, -1):
        lenn = len(nodes[i])
         
        # Printing all nodes
        # at given level
        for j in range(lenn // 2):
            print(nodes[i][j],
                  nodes[i][lenn - 1 - j], end = " ")
             
        # If count of nodes
        # at level i is odd
        # prremaining node
        if (lenn % 2 == 1):
            print(nodes[i][lenn // 2], end = " ")
 
# Driver code
if __name__ == '__main__':
 
    # Number of vertices
    n = 6
 
    addEdge(1, 2)
    addEdge(1, 3)
    addEdge(2, 4)
    addEdge(2, 5)
    addEdge(3, 6)
     
    # Calling modified bfs function
    bfs(1)
 
    display()
 
# This code is contributed by mohit kumar 29


C#
// C# implementation
// for the above approach
using System;
using System.Collections.Generic;
using System.Collections;
 
class GFG{
 
static int sz = 100000;
static int maxLevel = 0;
  
// Adjacency list
// representation of the tree
static ArrayList []tree = new ArrayList[sz + 1];
  
// Boolean array to mark all the
// vertices which are visited
static bool []vis = new bool[sz + 1];
  
// Integer array to store
// the level of each node
static int []level = new int[sz + 1];
  
// Array of vector where ith index
// stores all the nodes at level i
static ArrayList []nodes = new ArrayList[sz + 1];
  
// Utility function to create an
// edge between two vertices
static void addEdge(int a, int b)
{
     
    // Add a to b's list
    tree[a].Add(b);
  
    // Add b to a's list
    tree[b].Add(a);
}
  
// Modified Breadth-First Function
static void bfs(int node)
{
     
    // Create a queue of {child, parent}
    Queue qu = new Queue();
     
    // Push root node in the front of
    // the queue and mark as visited
    qu.Enqueue(new KeyValuePair(node, 0));
    nodes[0].Add(node);
    vis[node] = true;
    level[1] = 0;
     
    while(qu.Count != 0)
    {
     
        KeyValuePair p = (KeyValuePair)qu.Peek();
                                             
        // Dequeue a vertex from queue
        qu.Dequeue();
        vis[p.Key] = true;
         
        // Get all adjacent vertices of the dequeued
        // vertex s. If any adjacent has not
        // been visited then enqueue it
        foreach(int child in tree[p.Key])
        {
            if (!vis[child])
            {
                qu.Enqueue(new KeyValuePair(
                           child, p.Key));
                level[child] = level[p.Key] + 1;
                maxLevel = Math.Max(maxLevel, level[child]);
                nodes[level[child]].Add(child);
            }
        }
    }
}
  
// Function to display
// the pattern
static void display()
{
     
    for(int i = maxLevel; i >= 0; i--)
    {
        int len = nodes[i].Count;
         
        // Printing all nodes
        // at given level
        for(int j = 0; j < len / 2; j++)
        {
            Console.Write((int)nodes[i][j] + " " +
                          (int)nodes[i][len - 1 - j] +
                           " ");
        }
         
        // If count of nodes
        // at level i is odd
        // print remaining node
        if (len % 2 == 1)
        {
            Console.Write((int)nodes[i][len / 2] + " ");
        }
    }
}
 
// Driver code
public static void Main(string[] args)
{
    for(int i = 0; i < sz + 1; i++)
    {
        tree[i] = new ArrayList();
        nodes[i] = new ArrayList();
        vis[i] = false;
        level[i] = 0;
    }
     
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
    addEdge(3, 6);
     
    // Calling modified bfs function
    bfs(1);
     
    display();
}
}
 
// This code is contributed by rutvik_56


输出:
4 6 5 2 3 1

如果您希望与行业专家一起参加现场课程,请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。