算法与数据结构实验题 6.34 路径

★实验任务

给你一颗空的 AVL 树，你需要完成两个操作：

1. 向树中插入一个元素。

2. 询问某个元素到根的路径。

PS：在任意时刻，这样的 AVL 树是唯一的。

★数据输入

输入第一行为一个正整数 N，表示共有 N 个操作。

接下来 N 行，每行一个操作。

对于第一个操作，输入格式为 1 x，表示往集合里插入一个值为 x 的元素。

对于第二个操作，输入格式为 2 x，表示询问根到 x 这个元素的路径。

1<=N<=100000,1<=x<=1000000000。

★数据输出

对于所有的第二个操作，输出一行若干个整数，表示根到 x 的路径序列，数与数之间用空格隔开。

题目保证每个数最多只会插入一次，并且保证询问的数在之前已经插入过。

输入示例
5 1 2 1 1 1 3 2 1 2 3

输出示例
2 1 2 3

代码示例

#include<bits/stdc++.h>
using namespace std;
//AVL tree

struct node{
	int val;
	node * left;
	node * right;
	int height;
}; 
list<int> li;
int height(node * tree){
	if(tree==NULL)return -1;
	else return tree->height;

}

node * makeempty(node * tree){
	if(tree!=NULL){
		makeempty(tree->left);
		makeempty(tree->right);
		free(tree); 
	}
	return NULL;

}
bool flag = false;
void find(int val, node *tree){
	if(tree!=NULL){
		
		li.push_back(tree->val);
		if(tree->val>val){
			find(val,tree->left);
			if(flag){
			return;
		}
		} 
		else if(tree->val<val)
		{
			find(val,tree->right);
			if(flag){
			return;
		}
		}
		else if(tree->val == val){
			flag = true;
			return;
		}
		li.pop_back();
	}else{
		return;
	}
	

}

node * left_son_rotate(node * tree){
	
	node * k2 = tree;
	node * k1 = tree->left;
	k2 ->left = k1->right;
	k1->right = k2;
	
	k2->height = max(height(k2->left),height(k2->right))+1;
	k1->height = max(height(k1->left),height(k1->right))+1; 
	return k1;
}

node * right_son_rotate(node * tree){

	node * k2 =tree;
	node * k1 = tree->right;
	k2 ->right = k1->left;
	k1->left = k2;
	k2->height = max(height(k2->left),height(k2->right))+1;
	k1->height = max(height(k1->left),height(k1->right))+1; 
	return k1;
}

node * left_right_son_rotate(node * tree){

	tree->left = right_son_rotate(tree->left);
	return left_son_rotate(tree);
}

node * right_left_son_rotate(node * tree){
	tree->right = left_son_rotate(tree->right);
	return right_son_rotate(tree);
}

node * insert(int val,node *tree){//avl插入
	if(tree==NULL){//判断是否为空，树为空则创建结点

		tree=(node*)malloc(sizeof(node));
		tree->val = val;
		tree->left=NULL;
		tree->right = NULL;
		tree->height =0;
	}
	else if(tree->val >val){//如果val在左树
		tree->left = insert(val,tree->left);
//左边插入val
		if(height(tree->left)-height(tree->right)==2){如果左右高度差为二，失衡
		
			if(val<tree->left->val)tree = left_son_rotate(tree);//左左 左旋
			else tree = left_right_son_rotate(tree);左右旋
		}
	}else if(tree->val<val){//同leftinsert
		tree->right = insert(val,tree->right);
		if(height(tree->right)-height(tree->left)==2){
			if(val>tree->right->val)tree = right_son_rotate(tree);
			else tree= right_left_son_rotate(tree); 
		}
}
	tree->height = max(height(tree->left),height(tree->right))+1;

	return tree;
}

void print_tree(node * tree){
	if(tree!=NULL){//中序打印
		print_tree(tree->left);
		printf("%d ",tree->val);
		print_tree(tree->right);
	}
}

int main(){
	node * tree = NULL;
	int n;
	cin>>n;
	int temp,temp1;
	for(int i = 0;i<n;i++){
	cin>>temp;
	if(temp==1){
		cin>>temp1;
		tree = insert(temp1,tree);
	}else{
		cin>>temp1;
		find(temp1,tree);
		while(!li.empty())
		{
		if(li.size()==1)
			cout<<li.front()<<endl;
		else{
			cout<<li.front()<<" ";
		}
		li.pop_front();
		}
		li.clear();
	}
	
	}
	free(tree);
}