精华内容
下载资源
问答
  • 二叉排序树

    2018-08-08 10:31:38
    例如:设有一组初始记录关键字序列为(34,76,45,18,26,54,92),则由这组记录关键字生成的二叉排序树的深度为() 1.第一个关键字做根结点 2.每个关键字都与根结点比较,比根结点小的放在左子树,比根结点大的...

    一.生成方法

    例如:设有一组初始记录关键字序列为(34,76,45,18,26,54,92),则由这组记录关键字生成的二叉排序树的深度为()

    1.第一个关键字做根结点

    2.每个关键字都与根结点比较,比根结点小的放在左子树,比根结点大的放在右子树

    结果如下:

      深度为4。

    展开全文
  • 二叉排序树与平衡二叉树实现

    热门讨论 2010-12-26 15:25:31
    对于含有同样一组结点的表,由于结点插入的先后次序不同,所构成的二叉排序树的形态和深度也可能不同。 而在二叉排序树上进行查找时的平均查找长度和二叉树的形态有关: ①在最坏情况下,二叉排序树是通过把一个...
  • BST ——binary search tree 为什么叫二叉排序树? 因为BST的中序序列是个有序... 对于同一组关键字集合,若排列顺序不同,本节的算法生成的BST可能不同,查找效率也就因此不同 高度越小的BST,查找效率越高...

    BST ——binary search tree

    为什么叫二叉排序树?

    因为BST的中序序列是一个有序序列,所以对于一个任意的关键字序列构造一颗二叉排序树,实质就是对其进行排序,使其变为有序序列

     

    特点:

    • 从BST的构造可以看出,任何结点都是作为叶子结点插入的
    • 对于同一组关键字集合,若排列顺序不同,本节的算法生成的BST可能不同,查找效率也就因此不同
    • 高度越小的BST,查找效率越高。
    • 按照中序遍历可得到有序序列

     

    typedef int keytype;
    typedef struct node{
    	keytype key;
    	node *lc, *rc;
    }BSTNode;
    
    bool InsertBST(BSTNode *&bt, keytype k){//bt must be reference type or second rank pointer
    	if(bt == NULL){//allow insert
    		bt = (BSTNode *)malloc(sizeof(BSTNode));
    		bt->key = k;
    		bt->lc = bt->rc = NULL; 	
    		return true;
    	}
    	if(bt->key == k) return false;
    	if(k < bt->key) return InsertBST(bt->lc, k);
    	else return InsertBST(bt->rc, k);
    }
    
    BSTNode *CreateBST(int a[], int n){
    	BSTNode *bt = NULL;//
    	for(int i = 0; i < n; i++)
    		InsertBST(bt, a[i]);//apparently bt will be changed
    	return bt;//return the changed bt
    }
    
    void DispBST(BSTNode *bt){// output in parenthesized notation//括号表示法 
    	if(bt != NULL){
    		cout << bt->key;
    		if(bt->lc != NULL || bt->rc != NULL){
    			cout << "(";
    			DispBST(bt->lc);
    			if(bt->rc != NULL) cout << ",";
    			DispBST(bt->rc);
    			cout << ")";
    		}
    	}
    }
    
    BSTNode *SearchBST(BSTNode *bt, keytype k){
    	if(bt == NULL || bt->key == k) return bt;
    	if(k < bt->key) return SearchBST(bt->lc, k);
    	else return SearchBST(bt->rc, k);
    } 
    
    BSTNode *SearchBST_WithParentNode(BSTNode *bt, keytype k, BSTNode *f1, BSTNode *&f){
    	//f1: middle parameter  f: return the parent node 
    	if(bt == NULL){
    		f = NULL;
    		return NULL;
    	}
    	else if(k == bt->key){
    		f = f1;
    		return bt;
    	}
    	else if(k < bt->key) return SearchBST_WithParentNode(bt->lc, k, bt, f);
    	else return SearchBST_WithParentNode(bt->rc, k, bt, f);
    }
    int main() {
    	
    	BSTNode *bt;
    	//int path[100];
    	keytype k = 6;//search term is 6
    	int a[] = {4,9,0,1,8,6,3,5,2,7};
    	int n = 10;
    	
    	cout << "1. Create a binary search tree..." << endl;
    	bt = CreateBST(a, n);
    	
    	cout << "2. Display BST:  ";
    	DispBST(bt);
    	cout << endl;
    	
    	BSTNode *f;
    	cout << "3. Search a key term...  ";
    	//cout << SearchBST(bt, 5) -> key << endl;
    	cout << SearchBST_WithParentNode(bt, 6, NULL, f) -> key;//lack of robustness
    	
    	return 0; 
    }

     

     

     

     

     

     

     

     

    展开全文
  • 个排列,每个排列都可以生成二叉排序树,如果有重复数可能更多。对于其中任意两个排列,它们生成的二叉查找树可能相同,也可能不同。现在需要你编程序要判断。输入 包含多测试数据。 每测试数据分成两部分。...

    前言必读!http://blog.csdn.net/hnust_v/article/details/51747743
    问题 N: 二叉查找树(Ⅲ)-判同

    题目描述
    
    N个数可以有N!个排列,每个排列都可以生成一棵二叉排序树,如果有重复数可能更多。对于其中任意两个排列,它们生成的二叉查找树可能相同,也可能不同。现在需要你编程序要判断。
    
    输入
    
     包含多组测试数据。
    每组测试数据分成两部分。第一部分是模板树,由两行组成,第一行是空BST待插入关键字的数目n(1<=n<=100)。第2行是n个空格分开的正整数,值不超过100。 
    第二部分的第一行是一个整数数T,1<=T<=20 ,表示有T棵树需要判断是否和模板树一样,随后一共有2T行,每两行代表一棵树,格式和模板树一样。
    输出
    
     对于每一棵要匹配的树,如果和模板树一样输出YES,否则输出NO。
    样例输入
    9
    3 2 1 5 4 6 9 8 7
    3
    9
    1 2 3 4 5 6 7 8 9
    9
    3 2 1 5 6 4 9 8 7
    9
    9 8 7 6 5 4 3 2 1
    样例输出
    NO
    YES
    NO
    提示
    
    //相同条件 大概是先中序一致,或者中后序一致,以防万一我三序全判断了(怪我上课没听-_-!)
    #include <bits/stdc++.h>
    using namespace std;
    typedef struct LNode
    {
        LNode *Lchild,*Rchild;
        int info,flor;
    }LNode,*Fin;
    LNode Q[10000];
    int ERRM[3][10000],ERRD[3][10000];
    int CountM,CountD;
    void Print(Fin P,int &Count1,int &Count2,int &Count3,int flag)
    {
    
        if(P==NULL) return;
        if(flag==1) ERRM[0][++Count1]=P->info;
        else ERRD[0][++Count1]=P->info;
        Print(P->Lchild,Count1,Count2,Count3,flag);
        if(flag==1) ERRM[1][++Count2]=P->info;
        else ERRD[1][++Count2]=P->info;
        Print(P->Rchild,Count1,Count2,Count3,flag);
        if(flag==1) ERRM[2][++Count3]=P->info;
        else ERRD[2][++Count3]=P->info;
    }
    void Add(int a,int FLOR,LNode *P,LNode *Q)
    {
       // if(P.Lchild) printf("P==%d (*P.Lchild).info==%d\n",P.info,(*P.Lchild).info);
        Q->flor=FLOR;
        if(P->info > a)
        {
            if(P->Lchild != NULL) Add(a,FLOR+1,P->Lchild,Q);
            else {P->Lchild = Q;return;}
        }
        else if(P->info < a)
        {
            if(P->Rchild != NULL) Add(a,FLOR+1,P->Rchild,Q);
            else {P->Rchild = Q;return;}
        }
        else if(P->info == a)  return;
        return;
    }
    void Creat(int n,int &Count,int flag)
    {
        Fin Root=NULL;
        int a;LNode P;Count=0;
        scanf("%d",&a);
        P.info=a;P.flor=0;P.Lchild=P.Rchild=NULL;//Print(&P);
        Root = &P;
        for(int i=2,a;i<=n;i++)
        {
            scanf("%d",&a);
            Q[i].info=a;Q[i].Lchild=Q[i].Rchild=NULL;
            Add(a,1,&P,&Q[i]);
        }
        Count=0;
        int O=0,I=0;
        Print(Root,Count,O,I,flag);
    }
    bool Judge(int A,int B)
    {
        if(A!=B) return false;
        for(int i=1;i<=A;i++)
        {
         //   printf("%d %d ",ERRM[0][i],ERRD[0][i]);
          //  printf("%d %d ",ERRM[1][i],ERRD[1][i]);
         //   printf("%d %d\n",ERRM[2][i],ERRD[2][i]);
            if(ERRM[0][i]!=ERRD[0][i]) return false;
            if(ERRM[1][i]!=ERRD[1][i]) return false;
            if(ERRM[2][i]!=ERRD[2][i]) return false;
        }
        return true;
    }
    int main()
    {
        //freopen("F:\\test.txt","r",stdin);
      //  freopen("F:\\tsst.txt","w",stdout);
        int n;
        while(cin>>n)
        {
            Creat(n,CountM,1);
            int m;cin>>m;
            for(int i=1;i<=m;i++)
            {
                scanf("%d",&n);
                Creat(n,CountD,2);
                printf("%s\n",Judge(CountM,CountD)?"YES":"NO");
            }
        }
        return 0;
    }
    展开全文
  • 数据结构 查找

    2012-05-15 17:28:00
    9.2 给定一组关键字K={4,5,2,3,6,1},试按二叉排序树生成规则画出这棵二叉排序树,并说明用这组关键字以不同的次序输入后建立起来的二叉排序树的形态是否相同?当以中序遍历这些二叉排序树时,其遍历结果是否...
  • 输入个整数关键字序列L,生成一棵用链式存储结构存储的二叉排序树,对该二叉排序树能进行查找和插入结点的操作,并对该二叉排序树中结点的关键字按递增和递减顺序输出。具体要求:输入数据的第行为个正整数T, ...
    Problem Description 
     
    输入一个整数关键字序列L,生成一棵用链式存储结构存储的二叉排序树,对该二叉排序树能进行查找和插入结点的操作,并对该二叉排序树中结点的关键字按递增和递减顺序输出。
    具体要求:
    输入数据的第一行为一个正整数T, 表示测试数据的组数。然后是T组测试数据。每组测试数据的第一行输入正整数n(5≤n≤20),第二行输入n个整数,要求依次完成以下工作:
    (1) 以这n个整数生成(建立)一棵用链式存储结构存储的二叉排序树;
    (2) 按递增顺序输出该二叉排序树中的整数(关键字);
    (3) 输入一个整数key,对该二叉排序树进行查找,若在该二叉排序树中存在这个整数key,则输出find,否则输出not find。
    (4) 输入一个整数key,若该二叉排序树中不存在这个整数key,则将key插入到该二叉排序树中,使插入后仍为原性质的二叉排序树;否则不必插入;
    (5) 在(4)的基础上,按递减顺序输出该二叉排序树中的整数(关键字)。
    Input

    输入数据的第一行为一个正整数T, 表示测试数据的组数。然后是T组测试数据。每组测试数据的第一行输入正整数n(5≤n≤20),第二行输入n个整数,第三和第四行均输入整数key。
    Output

    每组输出的第一行为按递增顺序输出该二叉排序树中的整数(关键字),每两个整数之间一个空格;第二行为find或not find;第三行为按递减顺序输出该二叉排序树中的整数(关键字)。
    Sample Input
    2
    8
    10 79 6 81 43 75 26 69
    43
    69
    10
    94 22 25 24 20 42 39 71 53 57
    88
    1
    Sample Output
    6 10 26 43 69 75 79 81
    find
    81 79 75 69 43 26 10 6
    20 22 24 25 39 42 53 57 71 94
    not find
    94 71 57 53 42 39 25 24 22 20 1
     

     

    #include<iostream>
    using namespace std;
    #include<stdio.h>
    #include<stdlib.h>
    /*
    递归前中后遍历
    */
    int N;
    int j=0;
    int j1=0;
    typedef struct node
    {
      int data;
      struct node *left;
      struct node *right;
    }BTnode;
    BTnode* CreateTree(BTnode* root,int x)
    {
        if(!root)  //如果root结点为空,创建叶子结点
        {
            root = new BTnode;
            root->data = x;
            root->left=root->right=NULL;
        }else
        {
            if(root->data>x) 
                root->left = CreateTree(root->left,x);  //递归调用左
            else if(root->data<x)
                root->right = CreateTree(root->right,x);//递归调用右
        }
        return root;
    }
    
    void Inorder(BTnode* root)
    {
    
      if(root)
      {
          Inorder(root->left);
          if(j<N-1)
          {
                cout<<root->data<<" ";
                j++;
          }
       else{
            cout<<root->data<<endl;
       }
          Inorder(root->right);
      }
    }
    
    void Inorder1(BTnode* root)
    {
      if(root)
      {
           Inorder1(root->right);
          if(j1<N-1)
          {
                cout<<root->data<<" ";
                j1++;
          }
       else{
            cout<<root->data<<endl;
       }
          Inorder1(root->left);
      }
    }
    
    int find(BTnode* root,int a) 
    {
        
         while(root!=NULL)
      {
        if(root->data==a){
            return 1;
        }
         else if(root->data>a)
         {
              root=root->left;
         }
         else root=root->right;
      }
      return 0;
    }
     
    
    int main(void)
    { 
    int o;
    cin>>o;
    for(int p=0;p<o;p++)
    {
         BTnode * head = NULL;
     int x;
     int n;
     int i;
     int a;
     int b;
     scanf("%d",&n);
     N=n;
     for(i=0;i<n;i++)
     {
       scanf("%d",&x);
       head = CreateTree(head,x);
     }
     
    Inorder(head);
    
    cin>>a;
    if(find(head,a)==1) cout<<"find"<<endl;
    else cout<<"not find"<<endl;
    cin>>b;
    if(find(head,b)==0)
    {
        head = CreateTree(head,b);
        N=N+1;
        Inorder1(head);
    }
    else{
        Inorder1(head);
    }
    
    j=0;
    j1=0;
    
    }
    
    
    }

     

    转载于:https://www.cnblogs.com/ilovetheworld/p/10838826.html

    展开全文
  • 2.在有n个结点且为完全二叉树的二叉排序树中查找个键值,其平均比较次数的数量级为( )。 A.O(n) B.O(log2n) C.O(n*log2n) D.O(n2) 3.静态查找与动态查找的根本区别在于( )。 A. 它们的逻辑结构不一样 B...
  • 实验七 动态查找表 【实验类别】 综合性实验 【实验目的】 1、掌握查找不同方法,并能用高级语言实现查找算法。 2、熟练掌握顺序表和有序表查找方法。...设计个有关动态查找表(以二叉排序树为例)建立、查找
  • 8.3.1 二叉排序树和二叉平衡树 8.3.2 B-树和B+树 8.4 哈希表及其查找 8.4.1 哈希表与哈希函数 8.4.2 构造哈希函数常用方法 8.4.3 解决冲突主要方法 8.5 哈希表算法实现C语言源程序 习题八 第9章 排序 ...
  • 数据结构课程设计

    2014-06-03 13:26:05
    设计一个读入一串整数构成一颗二叉排序树的程序,从二叉排序树中删除一个结点,使该二叉树仍保持二叉排序树的特性。 24、设定哈希函数 H(key) = key MOD 11 ( 表长=11 ),输入一组关键字序列,根据线性探测再散列...
  • 二叉排序树的构造与基于其的查找问题:给定数据序列,能给出相应的二叉排序树  考点6. 图的存储结构问题:图的矩阵表示,链表表示等表示方法的特点,以及不同的图,不同的应用问题中存储方法的选择  考点7. 图的...
  • 14.4 带有相同关键字元素的二叉搜索 14.5 索引二叉搜索 14.6 应用 14.6.1 直方图 14.6.2 箱子装载问题的最优匹配法 14.6.3 交叉分布 第15章 平衡搜索 15.1 AVL 15.1.1 定义 15.1.2 AVL的高度 15.1.3 AVL...
  • (1)在二叉排序树上进行查找(bstsrch)、插入结点(ins_bstree)和删除结点(del_bstree) (2)在二叉平衡树上插入结点(ins_AVLtree) 和删除结点(del_AVLtree) (3)在 B-树上插入结点(Ins_BTree) 和 删除结点(Del_...
  • 算法导论(原书第三版)

    热门讨论 2013-03-06 14:31:34
    23.1 最小生成树的形成 23.2 Kruskal算法和Prim算法 思考题 本章注记 第24章 单源最短路径 24.1 Bellman-Ford算法 24.2 有向无环图中单源最短路径问题 24.3 Dijkstra算法 24.4 差分约束和最短路径 24.5 ...
  • (1)在二叉排序树上进行查找(bstsrch)、插入结点(ins_bstree)和删除结点(del_bstree) (2)在二叉平衡树上插入结点(ins_AVLtree) 和删除结点(del_AVLtree) (3)在 B-树上插入结点(Ins_BTree) 和 删除结点(Del_...
  • 算法导论中文版

    2016-10-26 10:13:58
     23.1 最小生成树的形成  23.2 Kruskal算法和Prim算法  思考题  本章注记 第24章 单源最短路径  24.1 Bellman?Ford算法  24.2 有向无环图中单源最短路径问题  24.3 Dijkstra算法  24.4 差分约束和...
  • 南理工初试试题

    2015-09-08 09:48:55
    3. 对关键字码集合K={53,30,37,12,45,24,96},从空二叉树出发建立与集合K对应的二叉排序树,若希望得到树的高度最小,应选择下列哪个输入序列 。 A)45,24,53,12,37,96,30 B)12,24,30,37,45,53,96 ...
  • 大话数据结构

    2018-12-14 16:02:18
    也就是在树的定义之中还用到了树的概念,这是比较新的一种定义方法。 6.2.1结点分类 152 6.2.2结点间关系 152 6.2.3树的其他相关概念 153 6.3树的抽象数据类型 154 6.4树的存储结构 155 6.4.1双亲表示法 155 ...
  • 《计算机世界》报组织“世纪评选”把他评为我国“20世纪最有影响IT人物”10个人之(排在第2位)。他功绩是把千百万群众带入计算机大门。 1 C语言概述 1.1 C语言发展过程 1.2 当代最优秀程序设计语言 ...
  • 《计算机世界》报组织“世纪评选”把他评为我国“20世纪最有影响IT人物”10个人之(排在第2位)。他功绩是把千百万群众带入计算机大门。 1 C语言概述 1.1 C语言发展过程 1.2 当代最优秀程序设计语言 ...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    e. 如有可能,请建立个存储商品名称和数量文本文件,并为二叉搜索建立个成员函数SetupInventory(),用于从该文本文件中读取库存商品数据, 实验报告要求: 1、 按要求记录下二叉搜索树的完整实验...
  • 算法导论(part1)

    热门讨论 2010-09-09 22:51:05
    、本书的内容 目前,市面上有关计算机算法的书...*12.4 随机构造的二叉查找 第13章 红黑 13.1 红黑的性质 13.2 旋转 13.3 插入 13.4 删除 第14章 数据结构的扩张 14.1 动态顺序统计 14.2 如何...
  • 数据结构演示软件

    2013-06-02 21:32:36
    (1)在二叉排序树上进行查找(bstsrch)、插入结点(ins_bstree)和删除结点(del_bstree) (2)在二叉平衡树上插入结点(ins_AVLtree) 和删除结点(del_AVLtree) (3)在 B-树上插入结点(Ins_BTree) 和 删除结点(Del_...
  • 算法导论(part2)

    2010-09-09 22:54:12
    、本书的内容 目前,市面上有关计算机算法的书...*12.4 随机构造的二叉查找 第13章 红黑 13.1 红黑的性质 13.2 旋转 13.3 插入 13.4 删除 第14章 数据结构的扩张 14.1 动态顺序统计 14.2 如何...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

一组关键字生成的二叉排序树