遍历某一层的二叉树哦

最新推荐文章于 2022-08-15 12:50:35 发布

kazeshiro

最新推荐文章于 2022-08-15 12:50:35 发布

阅读量387

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/weixin_44160352/article/details/89048161

这篇博客探讨了在风之城中如何遍历二叉树的某一层，时间复杂度在最坏情况下为O(n^2)，尤其在倾斜的二叉树中，操作时间为O(n)。因此，整个层序遍历的时间复杂度为O(n^2)。

风之城的遍历某一层的二叉树

#include <iostream>
#include "stdlib.h"

struct Node{
	int data;
	Node *left,*right; 
};

Node* newNode(int data);
void printLevelOrder(Node* root);
void printGivenLevel(Node* root, int level) ;
int height(Node *root);

//创建一个新的节点 
Node* newNode(int data)
{
	Node *new_node = (Node*) malloc(sizeof(Node));
	
	new_node->data = data;
	new_node->left = NULL;
	new_node->right = NULL;
}

//打印整个层的树 
void printLevelOrder(Node* root){
	int heigh = height(root);
	
	for(int i=0;i<=heigh;i++){
		printGivenLevel(root,i);
	}
}

//递归将树的某一层打印
//因为要打印某一层，则到了这层，level就被减到1，然后就可以打印了 
void printGivenLevel(Node* root, int level) 
{
	if(level==0)
		return;
	if(level==1)
		printf("%d",root->data);
	else if (level > 1) 
    { 
        printGivenLevel(root->left, level-1); 
        printGivenLevel(root->right, level-1); 
    } 
}

int height(Node *root)
{
	if(root == NULL)
		return 0; 
	//因为递归每次都要判断该节点是否为空 ，所以下面部分都要套else 
	else
	{ 
		int lheight = height(root->left);
		int rheight = height(root->left);
		if(lheight>rheight)
			return (lheight+1);
		else
			return (rheight+1);
	}	
}
int main(int argc, char** argv) {
	
//	效率低下 
//	Node* new_node1 = newNode(3);
//	Node* new_node2 = newNode(8);
//	Node* new_node3 = newNode(2);
//	Node* new_node4 = newNode(6);
//	Node* new_node5 = newNode(4);
//	new_node1->left = new_node2;
//		new_node1->left = new_node2;
	
	Node *root = newNode(1); 
    root->left        = newNode(2); 
    root->right       = newNode(3); 
    root->left->left  = newNode(4); 
    root->left->right = newNode(5); 
  
    printf("Level Order traversal of binary tree is \n"); 
    printGivenLevel(root,2) ;
    printf("\n");
    printLevelOrder(root); 
    return 0; 
	 
}

Time Complexity: O(n^2) in worst case. For a skewed tree, printGivenLevel() takes O(n) time where n is the number of nodes in the skewed tree. So time complexity of printLevelOrder() is O(n) + O(n-1) + O(n-2) + … + O(1) which is O(n^2).