二叉搜索树（模板）

#include<cstdio>
using namespace std;
const int M=9999;
struct tr{
	int l,r,x,size,num,f;
}a[M];
int tot=1;
void insert(int v,int u){
    if(!v)return;
    if(u>a[v].x)
	{
        if(!a[v].r)
		{
            a[++tot].x=u;
            a[tot].f=v;
			a[tot].size=1;
            a[v].r=tot;    

        }
		else insert(a[v].r,u);
    }
	else{
        if(!a[v].l)
		{
            a[++tot].x=u;
            a[tot].size=1;
            a[tot].f=v;
            a[v].l=tot;
        }
		else insert(a[v].l,u);
    }
	a[v].size=a[a[v].l].size+a[a[v].r].size+1;
}
/*int ins(int t,int v,int l,int r){

	if(!s[l].key)
	s[t].l=newcode(v);
	else if(s[l].key>v&&!s[r].key) s[t].r=newcode(v);
	else if(v<s[l].key){
		ins(l,v,s[l].l,s[l].r);
	}
	else if(){

		ins(s[t].r,v);
	}
	s[t].size=s
}*/
int getmax(int t){
	while(a[t].r!=0){
		t=a[t].r;
	}
	return t;
}
int check(int t,int k){
	if(a[a[t].l].size==k-1)
	return a[t].x;
	if(a[a[t].l].size>k-1)
	{
		return check(a[t].l,k);
	}
	else{
		return check(a[t].r,k-a[a[t].l].size-1);
	}
}
int check2(int t,int k,int ans){
	if(a[t].x==k){

		return ans+a[a[t].l].size;
	}
	if(a[t].x>k){
		return check2(a[t].l,k,ans);
	}
	else return check2(a[t].r,k,ans+a[a[t].l].size+1);

}
int check3(int t,int k){
	if(a[t].x==k){

		return k;
	}
	if(a[t].x>k){
		if(!a[a[t].l].x)return a[t].x;
		return check3(a[t].l,k);
	}
	if(a[t].x<k){
		if(!a[a[t].r].x)return a[t].x;
		return check3(a[t].r,k);
	}

}
/*int check4(int t,int k,int ans){
	if(a[t].x==k){

		check();
	}
	if(a[t].x>k){
		return check2(a[t].l,k,ans);
	}
	else return check2(a[t].r,k,ans+a[a[t].l].size+1);

}*/
int n;
int main(){
	scanf("%d",&n);

	for(int i=1;i<=n;i++){
		int q,y;
		scanf("%d%d",&q,&y);
		if(i==1)
		{
			a[1].x=y;
			a[1].size=1;
			continue;
		}
		if(q==1){
			insert(1,y);
		}
		if(q==2){

		}
		if(q==3)
		printf("%d\n",check(1,y));
		if(q==4)
		printf("%d\n",check2(1,y,1));
		if(q==5){
			printf("%d\n",check3(1,y));
		}
		if(q==6)
		{
			int k=check2(1,y,1);
			printf("%d\n",check(1,k-1));
		}
		if(q==7)
		{
			int k=check2(1,y,1);
			printf("%d\n",check(1,k+1));
		}
	}
	for(int i=1;i<=tot;i++){
	//	printf("%d \n",a[i].size);
	}
}

#include<cstdio>
using namespace std;
const int M=9999;
struct tr{
    int l,r,x,size,num,f;
}a[M];
int tot=1;
void insert(int v,int u){
    if(!v)return;
    if(u>a[v].x)
    {
        if(!a[v].r)
        {
            a[++tot].x=u;
            a[tot].f=v;
            a[tot].size=1;
            a[v].r=tot;    

        }
        else insert(a[v].r,u);
    }
    else{
        if(!a[v].l)
        {
            a[++tot].x=u;
            a[tot].size=1;
            a[tot].f=v;
            a[v].l=tot;
        }
        else insert(a[v].l,u);
    }
    a[v].size=a[a[v].l].size+a[a[v].r].size+1;
}
/*int ins(int t,int v,int l,int r){

    if(!s[l].key)
    s[t].l=newcode(v);
    else if(s[l].key>v&&!s[r].key) s[t].r=newcode(v);
    else if(v<s[l].key){
        ins(l,v,s[l].l,s[l].r);
    }
    else if(){

        ins(s[t].r,v);
    }
    s[t].size=s
}*/
int getmax(int t){
    while(a[t].r!=0){
        t=a[t].r;
    }
    return t;
}
int check(int t,int k){
    if(a[a[t].l].size==k-1)
    return a[t].x;
    if(a[a[t].l].size>k-1)
    {
        return check(a[t].l,k);
    }
    else{
        return check(a[t].r,k-a[a[t].l].size-1);
    }
}
int check2(int t,int k,int ans){
    if(a[t].x==k){

        return ans+a[a[t].l].size;
    }
    if(a[t].x>k){
        return check2(a[t].l,k,ans);
    }
    else return check2(a[t].r,k,ans+a[a[t].l].size+1);

}
int check3(int t,int k){
    if(a[t].x==k){

        return k;
    }
    if(a[t].x>k){
        if(!a[a[t].l].x)return a[t].x;
        return check3(a[t].l,k);
    }
    if(a[t].x<k){
        if(!a[a[t].r].x)return a[t].x;
        return check3(a[t].r,k);
    }

}
/*int check4(int t,int k,int ans){
    if(a[t].x==k){

        check();
    }
    if(a[t].x>k){
        return check2(a[t].l,k,ans);
    }
    else return check2(a[t].r,k,ans+a[a[t].l].size+1);

}*/
int n;
int main(){
    scanf("%d",&n);

    for(int i=1;i<=n;i++){
        int q,y;
        scanf("%d%d",&q,&y);
        if(i==1)
        {
            a[1].x=y;
            a[1].size=1;
            continue;
        }
        if(q==1){
            insert(1,y);
        }
        if(q==2){

        }
        if(q==3)
        printf("%d\n",check(1,y));
        if(q==4)
        printf("%d\n",check2(1,y,1));
        if(q==5){
            printf("%d\n",check3(1,y));
        }
        if(q==6)
        {
            int k=check2(1,y,1);
            printf("%d\n",check(1,k-1));
        }
        if(q==7)
        {
            int k=check2(1,y,1);
            printf("%d\n",check(1,k+1));
        }
    }
    for(int i=1;i<=tot;i++){
    //    printf("%d \n",a[i].size);
    }
}

时间： 2024-09-16 12:55:03

二叉搜索树（模板）的相关文章

hdoj-3791-二叉搜索树(二叉搜索树模板题)

#include <cstring> #include <cstdio> #include <iostream> using namespace std; typedef int ElemType; template<typename T> int getArrayLength(T &array) { return (sizeof(array) / sizeof(array[0])); } typedef struct node{ ElemType

【模板】二叉搜索树

二叉搜索树:对于二叉树中的任意节点,左子树中所有的值都小于当前位置的值,右子树中所有的值都大于当前位置的值. 操作: 1.插入一个数值. 2.查询是否包含某个数值. 3.删除某个数值. 插入和查找是差不多的,都是比当前值(要找的值)大就往左走,否则就往右走,直到找到为止. 最复杂的操作是删除某个节点,不过可以分为3种情况来讨论: 1.需要删除的节点没有左子树,那就把右子树提上去. 2.需要删除的节点的左子树没有右子树,那就把左子树提上去. 3.其他情况,把左子树中最大的节点提到当前删除的节点的位

【模板】二叉搜索树（二叉排序树，二叉查找树，BST）

二叉搜索树其实就是满足左结点小于根,右结点大于根这类规则的树形结构. 1 int n; 2 int a[MAX_N]; 3 int lt[MAX_N], rt[MAX_N]; 4 // 没有则为-1 5 // 默认a[0]为根结点 6 7 void Insert(int x, int obj) // 插入结点a[obj] 8 { 9 if(a[obj] < a[x]) 10 { 11 if(lt[x] ^ -1) Insert(lt[x], obj); 12 else lt[x] = obj;

ACM-数据结构-二叉搜索树（C++实现）

近日研习<计算机算法>,一点点弄明白了二叉搜索树. /* @header BSTree @abstract BSTree @discussion Insert,delete,search and order @author WalterBright,2016 */ #include <iostream> using namespace std; template <class Type> class BSTree; //模板类作为友元类需提前声明 template &l

数据结构（三）:非线性逻辑结构-特殊的二叉树结构：堆、哈夫曼树、二叉搜索树、平衡二叉搜索树、红黑树、线索二叉树

在上一篇数据结构的博文<数据结构(三):非线性逻辑结构-二叉树>中已经对二叉树的概念.遍历等基本的概念和操作进行了介绍.本篇博文主要介绍几个特殊的二叉树,堆.哈夫曼树.二叉搜索树.平衡二叉搜索树.红黑树.线索二叉树,它们在解决实际问题中有着非常重要的应用.本文主要从概念和一些基本操作上进行分类和总结. 一.概念总揽 (1) 堆堆(heap order)是一种特殊的表,如果将它看做是一颗完全二叉树的层次序列,那么它具有如下的性质:每个节点的值都不大于其孩子的值,或每个节点的值都不小于其孩子的值

用JS实现二叉搜索树

二叉树的节点最多只能有两个子节点,一个左侧子节点,一个右侧子节点. 二叉搜索树(BST),是二叉树的一种,但只允许在左侧节点存储比父节点小的值,在右侧节点存储比父节点大或等于父节点的值. 1.创建BST 1.1创建BST类首先申明BST类的基本结构 function BinarySearchTree() { var Node = function(key){ this.key = key; this.left = null; this.right = null; }; var root = n

538. Convert BST to Greater Tree 二叉搜索树转换为更大树

Given a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus sum of all keys greater than the original key in BST. Example: Input: The root of a Binary Search Tree like thi

二叉搜索树

#include<stdio.h> #include<iostream> #include<math.h> #include<stdlib.h> using namespace std; struct TreeNode { TreeNode* p; TreeNode* l; TreeNode* r; int key; TreeNode() { p = 0; l = 0; r = 0; key = -1; } }; const int RANDMOD = 30

04-树4 是否同一棵二叉搜索树

给定一个插入序列就可以唯一确定一棵二叉搜索树.然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到.例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树,都得到一样的结果.于是对于输入的各种插入序列,你需要判断它们是否能生成一样的二叉搜索树. 输入格式: 输入包含若干组测试数据.每组数据的第1行给出两个正整数N (≤10)和L,分别是每个序列插入元素的个数和需要检查的序列个数.第2行给出N个以空格分隔的正整数,作为初始插入序列.最后L行,每行给出N个插入的元素,属于

二叉搜索树建立、插入、删除、前继节点、后继节点之c++实现

一.前言一直以来,都对树有关的东西望而却步.以前每次说要看一看,都因为惰性,时间就那么荒废掉了.今天下个决心,决定好好的数据结构中的东西看一下.不知道看这篇文章的你,是不是和我有同样的感受,空有一颗努力的心,却迟迟没有付出行动.如果是的话,如果也想好好的把树的知识巩固一下的话,就让我们一起好好儿地把知识点过一遍吧.本文争取让看完的每一个没有基础的同学,都能有所收获.在正文开始前,先给自己加个油.加油(^ω^) 二.二叉搜索树的定义二叉搜索树是指,对于某一个节点而言,它左边的节点都小于或等于它