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

1、 输入一系列不为零的正整数（最多不超过20个），遇到0代表输入结束（不包含0）。
2、 根据上面输入的数据序列，用初始化方法创建最大堆（不要用节点依次插入的办法创建最大堆），然后输出最大堆的层次序列。
3、 输出用堆排序后的排序结果。
4、 根据上面输入的数据，创建二叉搜索树（关键字不允许重复，如遇重复，则不重复插入该关键字），输出二叉搜索树的前序序列、中序序列（分行输出）。

#include <iostream>
using namespace std;

		void bigHeap(int* r,int n)
		{
			//从最后一个有孩家长开始遍历
			for (int i = n / 2; i > 0; i--)
			{
				//如果有左孩子（默认左孩子，但是其实路线是挑大孩子）
				while (2 * i <= n)
				{
					//j是左孩子的下标
					int j = 2 * i;
					//如果有右孩子并且左孩比右孩小
					if (j + 1 <= n && r[j] < r[j + 1])
						j++;//指向孩子中大的
					if (r[i] >= r[j])//爹比俩孩都大
					{
						break;
					}
					else {
						swap(r[i], r[j]);//较大的当爹
					}
					i = j;//一个下沉操作，因为交换完了下面可能又出幺蛾子了
				}
			}
		}


void HeapSort(int* r, int num)
{
	//堆排序，从末尾到头
	while (num > 1)
	{
		//老大哥已经在栈顶了，只要和参与排序的末尾换一下就可
		//>1因为只有一个节点的时候已经没有必要堆排序了
		int index = 1;
		swap(r[index], r[num--]);


		//这个代码和初始化bigHeap的一毛一样
		while (2 * index <= num)
		{
			//j是左孩子的下标
			int j = 2 * index;
			//如果有右孩子并且左孩比右孩小
			if (j + 1 <= num && r[j] < r[j + 1])
				j++;//指向孩子中大的
			if (r[index] >= r[j])//爹比俩孩都大
			{
				break;
			}
			else {
				swap(r[index], r[j]);//较大的当爹
			}
			index = j;//一个下沉操作，因为交换完了下面可能又出幺蛾子了
		}
	}
}
//a是能形成搜索树的数组，r是要插入的数，i是a中的数的下标
//这整个是个下沉操作
	void insert(int* a, int r,int i)
	{
		if (!a[i]||a[i]==r)
		{
			a[i] = r;
		
		}
		if (a[i] > r)
			insert(a, r, 2 * i);
		
		if (a[i] < r)
		{
			insert(a, r, 2 * i + 1);
                        
		}
	}
int* CreateTree(int *r,int num)
{
	int* a = new int[100];
	for (int i = 0; i < 100; i++)
	{
		a[i] = 0;
	}
	a[1] = r[1];
	for (int i = 2; i <= num; i++)
	{
		insert(a, r[i],1);
	}
	return a;
}
void prOrder(int* a, int index,bool flag)
{
	if (!a[index])return;

	if (flag)
	{
		cout << a[index];
		flag = false;
	}
	else {
		cout << "," << a[index];
	}


	prOrder(a, 2 * index,flag);

	prOrder(a, 2 * index+1,flag);
}
void midOrder(int* a, int index,bool flag)
{

	if (!a[index])return;
		midOrder(a, 2 * index,flag);

		if (a[2 * index])flag = false;

		if (flag)
		{
			cout << a[index];
			flag = false;
		}
		else {
			cout << "," << a[index] ;
		}
	

		midOrder(a,( 2 * index + 1),flag);
}
void print(int* r, int n)
{
	cout << r[1];
	for (int i = 2; i <=n; i++)
	{
		cout <<","<< r[i] ;
  }
}

int main()
{
	int index = 0;
	int num;
	int* a = new int[50];
	cout << "Input" << endl;
	cin >> num;
	a[0] = 0;
	while (num)
	{
		a[++index] = num;
		cin >> num;
	}
	//a的复制品
	int* a1 = new int[50];
	int index2 = index;
	for (int i = 1; i <= index; i++)
	{
		a1[i] = a[i];
	}

	bigHeap(a, index);
	cout << "Output" << endl;
	print(a, index );
	HeapSort(a, index);
	cout << endl;
	print(a, index);
	//到这里，都还很完美。。。
	int max = 0;
	
	int* m=CreateTree(a1, index);
	cout << endl;
	这里没啥毛病
	//print(m, 50);
	//cout << endl;
	bool flag = true;
	prOrder(m, 1,flag);
	cout << endl;
	flag = true;
	midOrder(m, 1,flag);
	cout << endl;
	cout << "End" << endl;

	return 0;
}