山东大学 数据结构 实验6 堆和搜索树

最新推荐文章于 2023-04-25 19:16:25 发布
最新推荐文章于 2023-04-25 19:16:25 发布
阅读量3.9k 收藏 8
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 山东大学 最大堆 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42289906/article/details/84954246
版权

实验六  堆和搜索树

一、 要求完成时间

实验开始后的第七周之前完成

二、 实验目的

掌握堆和搜索树的基本概念，插入、删除方法。

三、 实验内容

1、 输入一系列不为零的正整数（最多不超过20个），遇到0代表输入结束（不包含0）。

2、 根据上面输入的数据序列，用初始化方法创建最大堆（不要用节点依次插入的办法创建最大堆），然后输出最大堆的层次序列。

3、 输出用堆排序后的排序结果。

4、 根据上面输入的数据，创建二叉搜索树（关键字不允许重复，如遇重复，则不重复插入该关键字），输出二叉搜索树的前序序列、中序序列（分行输出）。

四、 测试用例及答案

测试如下所有用例及答案，且确保运行后出现完全一样的输出，

（操作系统提示“请按任意键继续….”等，可以不一样。）

 

分析：

1.堆排序：借助最大堆的定义，返回的肯定是堆内最大的元素，将堆内的元素依次弹出，直到堆为空。这样就实现了排序。

 

2.BSTree继承自前面实验的BinaryTree以减少类方法的设计。只需根据二叉搜索树的定义，在插入、删除时，根据元素的大小遍历左子树或右子树。

 

以下是代码，有点略多，仅供参考，希望你写出更好的方法！

代码：

#include<iostream>
#include<string>
using namespace std;
class OutOfBounds {
public:
    OutOfBounds(){
        cout<<"Out of bounds!"<<endl;
    }
};
 
class NoMen{
public:
    NoMen(){
        cout<<"NoMen error!"<<endl;
    }
};

//处理数BadInput的报错
class BadInput{    
    public:    
        BadInput(){    
        	cout<<"BadInput!"<<endl;    
        }    
}; 
class NoElement{
	public:
		NoElement(){
			cout<<"NoElement!"<<endl;
		}
};
//类最大堆 
template<class T>
class MaxHeap{
	public:
		MaxHeap(int MaxHeapSize = 10);
		~MaxHeap(){delete [] heap;}
		int Size() const{return CurrentSize;}
		T Max(){if(CurrentSize == 0) throw OutOfBounds();
			return heap[1];}
		MaxHeap<T>& Insert(const T& x);
		MaxHeap<T>& DeleteMax(T& x);
		void Initialize(T a[],int size,int ArraySize);
		void Output(); 
	private:
		int CurrentSize,MaxSize;
		T *heap;//元素数组 
};
template<class T>
MaxHeap<T>::MaxHeap(int MaxHeapSize){
	MaxSize = MaxHeapSize;
	heap = new T[MaxSize+1];
	CurrentSize = 0;
} 
template<class T>
MaxHeap<T>& MaxHeap<T>::Insert(const T& x){
	//把x插入到最大堆中
	if(CurrentSize == MaxSize)
		throw NoMen();
		
	//为x寻找插入位置
	//i从新的叶节点开始，并沿着树上升
	int i = ++CurrentSize;
	while(i != 1 && x > heap[i/2]){
		//不能够把x放入heap[i]
		heap[i] = heap[i/2];//将元素下移
		i /= 2;//移向父节点 
	} 
	
	heap[i] = x;
	return *this; 
}
template<class T>
MaxHeap<T>& MaxHeap<T>::DeleteMax(T& x){
	//将最大元素放入x，并从堆中删除最大元素
	
	//检查堆是否为空
	if(CurrentSize == 0)
		throw OutOfBounds();
	
	x = heap[1];
	
	//重构堆
	T y = heap[CurrentSize--];
	//从根节点开始，为y寻找合适的位置
	int i = 1;//堆的当前节点
	int ci = 2;//i的孩子
	while(ci <= CurrentSize){
		//heap[ci]应是i的比较大的孩子
		if(ci < CurrentSize && heap[ci] < heap[ci+1])
			ci++;
			
		if(y >= heap[ci])
			break;
		
		heap[i] = heap[ci];
		i = ci;
		ci *= 2; 
	} 
	heap[i] = y;
	return *this;
}
template<class T>
void MaxHeap<T>::Initialize(T a[],int size,int ArraySize){
	//把最大堆初始化为数组a
	delete [] heap;
	heap = a;
	CurrentSize = size;
	MaxSize = ArraySize;
	
	//产生一个最大堆
	for(int i = CurrentSize/2;i >= 1;i--){
		T y = heap[i];//子树的根
		//寻找放置y的位置
		int c = 2*i;//c的父节点是y的目标位置
		while(c <= CurrentSize){
			if(c < CurrentSize && heap[c] < heap[c+1])
				c++;
				
			if(y >= heap[c])
				break;
			
			heap[c/2] = heap[c];
			c *= 2;
		} 
		heap[c/2] = y;
	} 
}
template<class T>
void MaxHeap<T>::Output(){
	for(int i = 1;i <= MaxSize;i++){
		cout<<heap[i];
		if(i != MaxSize)
			cout<<",";
	}
} 
//类BinaryTreeNode
template<class T>
class BinaryTreeNode {
                 public:
                            BinaryTreeNode() {LeftChild=RightChild=NULL;}
                            BinaryTreeNode(const T&e)
                              {
                                data=e;
                                LeftChild=RightChild=NULL;
                              }
                            BinaryTreeNode(const T&e, BinaryTreeNode *l,
                                                BinaryTreeNode *r)
                              {
                                 data=e;
                                 LeftChild=l;
                                 RightChild=r;
                              }

                            BinaryTreeNode<T> *LeftChild;    //左子树
                            BinaryTreeNode<T> *RightChild;   //右子树
                            T data;
                            };

//类BinaryTree
template<class T>
class BinaryTree{
             public:
                      BinaryTree(){root=NULL;}

                      ~BinaryTree(){Delete();}

                      void Delete(){PostOrder(Free, root); root=0;}

                      static void Free(BinaryTreeNode<T>* t){delete t;}

                      int IsEmpty()const
                        {return ((root) ? 0 : 1);}

                      int Root(T& x)const;

                      void MakeTree(const T& element, BinaryTree<T>& left,
                                         BinaryTree<T>& right);

                      void BreakTree(T& element, BinaryTree<T>& left,
                                          BinaryTree<T>& right);

                      void PreOrder(void(*Visit)(BinaryTreeNode<T> *u))
                            {PreOrder(Visit, root);}

                      void InOrder(void(*Visit)(BinaryTreeNode<T> *u))
                            {InOrder(Visit, root);}

                      void PostOrder(void(*Visit)(BinaryTreeNode<T> *u))
                            {PostOrder(Visit, root);}

                      BinaryTreeNode<T>* root;  //根节点指针 

                    //遍历方法
                      void PreOrder(void(*Visit)
                          (BinaryTreeNode<T> *u), BinaryTreeNode<T> *t);

                      void InOrder(void(*Visit)
                          (BinaryTreeNode<T> *u), BinaryTreeNode<T> *t);

                      void PostOrder(void(*Visit)
                          (BinaryTreeNode<T> *u), BinaryTreeNode<T> *t);
					//为了输出， 
					  void PreOrder(void(*Visit)(BinaryTreeNode<T> *u,int i),BinaryTreeNode<T> *t,int i);
					  void InOrder(void(*Visit)(BinaryTreeNode<T> *u,int i),BinaryTreeNode<T> *t,int i);
					  void PostOrder(void(*Visit)(BinaryTreeNode<T> *u,int i),BinaryTreeNode<T> *t,int i);	
						
                      static void Output(BinaryTreeNode<T> *t)
                             {
                              cout << t->data << " ";
                             }
                      static void Output2(BinaryTreeNode<T> *t,int i)
					  		 {
							  if(i != 0)cout<<",";
						      cout<<t->data;
					  		 }

                      void PreOutput()
                        {
                          static int i = 0;PreOrder(Output2,root,i);
                          cout << endl;
                        }

                      void InOutput()
                         {
                          static int i = 0;InOrder(Output2,root,i);
                          cout << endl;
                         }

                      void PostOutput()
                         {
                          static int i = 0;PostOrder(Output2,root,i);
                          cout << endl;
                         }
                     };

//类BSTree
template<class E, class K>
class BSTree : public BinaryTree<E>{
         public:
                    int Search(const K& k, E& e)const;
                    BSTree<E,K>& Insert(const E& e);
                    BSTree<E,K>& Delete(const K& k, E& e);
                    //在e中存储树的最大元素
                    void MaxNode(E& e)const;
         };


/*---------------------BinaryTree Methods()-------------------------*/
template<class T>
int BinaryTree<T>::Root(T& x) const
  { //取根节点的data域，放入x 
    //如果没有根节点，则返回false 
    if(root)
      {
        x=root->data;
        return 1;
      }
    else return 0;  //没有根节点 
  }

template<class T>
void BinaryTree<T>::MakeTree(const T& element,
                      BinaryTree<T>& left, BinaryTree<T>& right)
  {//将left, right,和 element 合并成一棵新树 
    //left, right和 this必须是不同的树 
    //创建新树 

    root=new BinaryTreeNode<T>(element, left.root, right.root);

    //阻止访问left和right 
    left.root=right.root=0;
  }

template<class T>
void BinaryTree<T>::BreakTree(T& element,
                        BinaryTree<T>& left, BinaryTree<T>& right)
  {//left, right和 this必须是不同的树 
    //检查树是否为空 

    if(!root)  //空树
    	throw BadInput();

    //分解树 
    element=root->data;
    left.root=root->LeftChild;
    right.root=root->RightChild;

    delete root;
    root=0;
  }

template<class T>
void BinaryTree<T>::PreOrder(void(*Visit)
                        (BinaryTreeNode<T>* u), BinaryTreeNode<T>* t)
  {//前序遍历

     if(t)
      {
        Visit(t);
        PreOrder(Visit, t->LeftChild);
        PreOrder(Visit, t->RightChild);
      }
  }

template<class T>
void BinaryTree<T>::InOrder(void(*Visit)(BinaryTreeNode<T>* u),
                                     BinaryTreeNode<T>* t)
  {//中序遍历 

      if(t)
         {
          InOrder(Visit, t->LeftChild);
          Visit(t);
          InOrder(Visit, t->RightChild);
         }
  }

template<class T>
void BinaryTree<T>::PostOrder(void(*Visit)(BinaryTreeNode<T>* u),
                                        BinaryTreeNode<T>* t)
  {//后序遍历 

     if(t)
      {
        PostOrder(Visit, t->LeftChild);
        PostOrder(Visit, t->RightChild);
        Visit(t);
      }
  }
  
//为了输出，
template<class T>
void BinaryTree<T>::PreOrder(void(*Visit)(BinaryTreeNode<T> *u,int i),BinaryTreeNode<T> *t,int i){
	if(t){
		Visit(t,i);
		PreOrder(Visit,t->LeftChild,++i);
		PreOrder(Visit,t->RightChild,++i);
	}
} 
template<class T>
void BinaryTree<T>::InOrder(void(*Visit)(BinaryTreeNode<T> *u,int i),BinaryTreeNode<T> *t,int i){
	if(t){
		InOrder(Visit,t->LeftChild,i);
		if(t->LeftChild)i++;
		Visit(t,i++);
		InOrder(Visit,t->RightChild,i);
	}
} 
template<class T>
void BinaryTree<T>::PostOrder(void(*Visit)(BinaryTreeNode<T> *u,int i),BinaryTreeNode<T> *t,int i){
	if(t){
		PostOrder(Visit,t->LeftChild,i);
		PostOrder(Visit,t->RightChild,i);
		Visit(t,i++);
	}
} 
/*----------------------End of BinaryTree Methods()------------------*/

/*------------------------BSTree Methods()---------------------------*/

template<class E, class K>
int BSTree<E,K>::Search(const K& k, E& e) const
 {//搜索与k匹配的元素 
    //指针p从树根开始进行查找 
    
    BinaryTreeNode<E> *p=this->root;

     while(p) //检查p->data 
      {
        if(k<p->data)
          p=p->LeftChild;
        else if(k>p->data)
          p=p->RightChild;
        else{ //找到元素 
              e=p->data;
              return 1;
             }
      }
     return 0;
  }

template<class E, class K>
BSTree<E,K>& BSTree<E,K>::Insert(const E& e)
 { //如果不出现重复，则插入e 

  BinaryTreeNode<E> *p=NULL;   //搜索指针 
  BinaryTreeNode<E> *pp=NULL;     //p的父节点指针 

  //寻找插入点 
  p=this->root;       //p is now the root

  while(p)
    {
     pp=p;
     //将p移向孩子节点 

     if(e<p->data)
      p=p->LeftChild;

     else if(e>p->data)
      p=p->RightChild;

     else
      return *this; //出现重复,不插入，直接返回 
     }

    //为e建立一个节点，并将该节点连接至to pp 
    BinaryTreeNode<E> *r=new BinaryTreeNode<E>(e);

     if(this->root)
      {//树非空 

        if(e<pp->data)
         pp->LeftChild=r;

        else if(e>pp->data)
         pp->RightChild=r;
      }

     else //插入到空树中 
        this->root=r;

    return *this;
  }

template<class E, class K>
BSTree<E,K>& BSTree<E,K>:: Delete(const K& k, E& e)
 {//删除关键值为k的元素，并将其放入e 
 
  //将p指向关键值为k的节点 
  BinaryTreeNode<E> *p=NULL;  //搜索指针 
  BinaryTreeNode<E> *pp=NULL;  //p的父节点指针 

  p=this->root;

  while(p && p->data != k)
    {//移动到p的孩子 

     pp=p;

      if(k < p->data)
        p=p->LeftChild;

      else
        p=p->RightChild;
    }

  if(!p)               //没有关键值为k的元素 
    throw NoElement();

  e=p->data;    //保存欲删除的元素 

  //对树进重构 
    if(p->LeftChild && p->RightChild) //处理p有两个孩子的情形 
      {//转换成有0或1个孩子的情形 
        //在p的左子树中寻找最大元素 

        BinaryTreeNode<E> *s=p->LeftChild; 
        BinaryTreeNode<E> *ps=p;  //s的父节点 

        while(s->RightChild)
         {//移动到较大的元素 
          ps=s;
          s=s->RightChild;
         }

        //将最大元素从s移动到p 
        p->data=s->data;
        p=s;
        pp=ps;
      }//end all if

    //p最多有一个孩子 
    //在c中保存孩子节点 
    BinaryTreeNode<E> *c;

    if(p->LeftChild)
     c=p->LeftChild;

    else
     c=p->RightChild;
    //删除p 

    if(p==this->root)
      this->root=c;

    else{
          //p是pp的左孩子还是pp的右孩子？ 
             if(p==pp->LeftChild)
              pp->LeftChild=c;

             else
              pp->RightChild=c;
         }
    delete p;
    return *this;
 }

template<class E, class K>
void BSTree<E,K>::MaxNode(E &e)const
 {//function returns max. value of tree (rightmost value)

  BinaryTreeNode<E>* p=NULL;  //root node
  BinaryTreeNode<E>* pp=NULL; //parent of p

  p=this->root;

  while(p)
    {
     pp=p;
     p=p->RightChild;
    }
     //p points to NULL, pp points to node before NULL
 e=pp->data; //max. value stored
 }

int main(){
	//最大堆部分 
	BSTree<int,int> abst;
	
	int a [22];
	int length = 0;
	cout<<"Input"<<endl;
	for(int i = 0;i < 21;i++){
		cin>>a[i+1];
		if(a[i+1] != 0)
			abst.Insert(a[i+1]);
		if(a[i+1] == 0)break;
		length++;
	}
	cout<<"Output"<<endl;
	//初始化最大堆
	MaxHeap<int> oneMaxHeap;
	oneMaxHeap.Insert(0);
	oneMaxHeap.Initialize(a,length,length);
	oneMaxHeap.Output();
	cout<<endl;
	//堆排序
	int array[length];
	for(int i = 0;i < length;i++){
		oneMaxHeap.DeleteMax(array[length-1-i]);
	}
	for(int i = 0;i < length;i++){
		cout<<array[i];
		if(i != length-1)
			cout<<",";
	}
	cout<<endl;
	
	//二叉搜索树部分 
 	abst.PreOutput();
 	abst.InOutput();
 	cout<<"End"<<endl;
	return 0; 
}

运行截图：

ps:本人开通了个人的微信公众号，希望大家能关注一下，

我会将资源、文章优先推送到公众号上。

推送自己的一些学习笔记，实验源代码等，

欢迎大家互相交流学习。

山东大学-苏苏
关注
专栏目录
山东大学软件学院数据结构实验六堆和搜索树
12-28
1、 输入一系列不为零的正整数（最多不超过20个），遇到0代表输入结束（不包含0）。 2、 根据上面输入的数据序列，用初始化方法创建最大堆（不要用节点依次插入的办法创建最大堆），然后输出最大堆的层次序列。 3、 输出用堆排序后的排序结果。 4、 根据上面输入的数据，创建二叉搜索树，输出二叉搜索树的前序序列、中序序列（分行输出）。
山东大学数据结构实验6-堆和搜索树（c++实现）（超详细注释）
weixin_47373497的博客
11-20 855
山东大学数据结构实验6-堆和搜索树（c++实现） 内含方法：下沉操作，创建最大堆，堆排序，插入法创建搜索树，前序遍历，中序遍历 #include<iostream> #include<vector> int count1=0; int count2=0;//用count2记录数组中有几个重复的值 bool flag=true;//使用flag判断数组中是否有重复的值 using namespace std; typedef struct Bnode { int data;
山东大学《数据结构》实验六：堆和搜索树
1个胖墩的课后笔记
01-14 1270
实验六 堆和搜索树 一、 实验目的 掌握堆和搜索树的基本概念，插入、删除方法。 二、 实验内容 1、输入一系列不为零的正整数（最多不超过 20 个），遇到 0 代表输入结 束（不包含 0）。 2、根据上面输入的数据序列，用初始化方法创建最大堆（不要用节点依 次插入的办法创建最大堆），然后输出最大堆的层次序列。 3、输出用堆排序后的排序结果。 4、根据上面输入的数据，创建二叉搜索树（关键字不允许重复...
山东大学数据结构试验六
weixin_63137680的博客
11-26 510
实验要求： 1、 输入一个完全二叉树的层次遍历字符串，创建这个二叉树，输出这个二叉树的前序遍历字符串、中序遍历字符串、后序遍历字符串、结点数目、二叉树高度(上述每一个结果独立一行显示)。 2、 输入二叉树前序序列和中序序列(各元素各不相同)，创建这个二叉树，输出该二叉树的后序序列、层次遍历。 代码实现： #include<iostream> #include<string> #include<queue> using namespace std; class No
山东大学数据结构实验六
最新发布
qq_62819443的博客
04-25 306
接下来n行，每行一个表达式，保证表达式内的数字为单个整数，表达式内各运算符和数字间没有空格，且表达式的长度不超过2000。每行表达式输出一个浮点数，要求保留两位小数，保证输入表达式合法。第一行一个整数n(1<=n<=100)，代表表达式的个数。因为精度问题，请使用double存数据。
山东大学大二上数据结构实验搜索树实验报告（含源码）
11-23
在“山东大学大二上数据结构实验搜索树实验报告”中，主要涉及了以下几个知识点： 1. **链表存储结构**：链表是一种线性数据结构，它通过指针链接各个节点，而不是像数组那样通过物理位置相邻。在二叉搜索树的实现...
山东大学数据结构实验报告
12-28
本实验报告聚焦于山东大学的数据结构课程，涵盖了矩阵、算法、递归、二叉树、搜索树、图以及堆栈等多个关键主题。这些主题都是构建高效软件系统的基础，对理解和解决问题具有深远的影响。 首先，让我们深入了解矩阵...
山东大学《数据结构》实验指导04树和二叉树.docx
12-17
"山东大学《数据结构》实验指导04树和二叉树" 二叉树是数据结构中的一种重要类型，广泛应用于计算机科学和信息技术领域。本文将详细介绍二叉树的定义、结构特点、链式存储表示和遍历算法。 一、 二叉树的定义 ...
山东大学2020数据结构实验报告
01-12
数据结构是计算机科学中的核心...以上知识点是数据结构实验报告可能涵盖的内容，通过实际编程和运行，可以更深入地理解这些概念，提高编程和算法设计能力。对于山东大学的学生而言，这份报告将是一个宝贵的参考资料。
山东大学数据结构实验六_实验室系列冷冻干燥机
weixin_39656853的博客
11-11 196
一、应用领域CTFD实验室系列冻干机是专门为实验室用户小批试验而开发的冻干设备。二、冻干原理冷冻干燥就是将含水物质，先冻结成固态，而后使其中的水分从固态升华成气态，以除去水分而保存物质的方法。三、特点1、许多热敏性的物质不会发生变性或失活。2、在低温下干燥时，物质中的一些挥发性成分损失很小。3、在冻干过程中，微生物的生长和酶的作用无法进行，因此能保持原来的性状。4、由于在冻结的状态下进行...
山东大学数据结构实验一
05-12
山东大学 数据结构 实验一 C++，实验一递归练习是以后所用到的各种数据结构经常使用的，请同学们一定要熟练掌握。
山东大学数据结构课程设计—AVL搜索树
11-24
这是去年做的一份课程设计，用c++,visual studio6.0做的，希望对大家有用处
山东大学软件学院数据结构实验七图的操作
12-28
1、 创建图类，存储结构使用邻接矩阵。 2、 输入图的节点数n（不超过10个）、边数m，节点分别用1-n代表。 3、 采用“起始节点，终止节点，权值”输入图的m条边，创建图。 4、 输出从节点1开始的BFS遍历，要求小的节点在前大的在后。 5、 输出从节点1开始的DFS遍历，要求小的节点在前大的在后。 6、 输出从第1节点到第n节点最短路径的长度，如果没有路经，输出0。
2017--山东大学数据结构实验代码
01-18
2017--山东大学数据结构实验代码，包括实验1-实验8，利用codeblocks编译运行。代码有详细的注释，是辅助学习的好资源。 配套的实验报告在上一个的上传资源里面。 2017--山东大学数据结构实验代码，包括实验1-实验8，利用codeblocks编译运行。代码有详细的注释，是辅助学习的好资源。 配套的实验报告在上一个的上传资源里面。 2017--山东大学数据结构实验代码，包括实验1-实验8，利用codeblocks编译运行。代码有详细的注释，是辅助学习的好资源。 配套的实验报告在上一个的上传资源里面。
山东大学数据结构实验六二叉树操作
weixin_52099599的博客
12-12 1114
1、 输入一个完全二叉树的层次遍历字符串，创建这个二叉树，输出这个二叉树的前序遍历字符串、中序遍历字符串、后序遍历字符串、结点数目、二叉树高度(上述每一个结果独立一行显示)。 2、 输入二叉树前序序列和中序序列(各元素各不相同)，创建这个二叉树，输出该二叉树的后序序列、层次遍历。 #include<iostream>队列头文件 #include<queue>//引入 using namespace std; char* shuzu=new char [100]; int shu=0
树的遍历方式总结(山东大学数据结构2016级实验6)
陈迹·清欢的博客
02-08 258
#include <iostream> #include <stdlib.h> #include <stack> #include <string.h> #include <sstream> #include <queue> using namespace std; //提前声明类 template<class T&g...
山东大学 数据结构 实验2 排序算法
不服输的苏大叔的博客
11-19 1608
实验二 排序算法 一、 要求完成时间 实验开始后的第三周之前完成 二、 实验目的 掌握各种排序方法的实现思想。 三、 实验内容   1、 输入2-20个不为零的正整数，遇到0代表输入结束，0不参与排序。   2、 数字选择排序方法，1-冒泡排序,2-插入排序,3-基数排序   3、 基数排序能够实现小于10的正整数的排序。   4、 使用所选排序方法的排序，结果输出所用方法以及结...
山东大学软件学院2017-18学年大二数据结构实验五、六、七
谦虚勤奋诚实感恩
10-01 2180
注：实验代码均为自己编写，均能满足实验要求，但实现方法不唯一仅供参考。 实验五 二叉树操作 1.实验内容（题目内容，输入要求，输出要求） 输入一个完全二叉树的层次遍历字符串，创建这个二叉树，输出这个二叉树的前序遍历字符串、中序遍历字符串、后序遍历字符串、结点数目、二叉树高度(上述每一个结果独立一行显示)。 输入二叉树前序序列和中序序列(各元素各不相同)，创建这个二叉树，输出该二叉树的后序序...
山东大学数据结构实验七堆和搜索树
weixin_52099599的博客
12-12 835
1、 输入一系列不为零的正整数（最多不超过20个），遇到0代表输入结束（不包含0）。 2、 根据上面输入的数据序列，用初始化方法创建最大堆（不要用节点依次插入的办法创建最大堆），然后输出最大堆的层次序列。 3、 输出用堆排序后的排序结果。 4、 根据上面输入的数据，创建二叉搜索树（关键字不允许重复，如遇重复，则不重复插入该关键字），输出二叉搜索树的前序序列、中序序列（分行输出）。 #include <iostream> using namespace std; void bigHeap(i
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值