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

一、 要求完成时间

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

二、 实验目的

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

三、 实验内容

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

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

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

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

四、实现代码如下：

#include<iostream>

using namespace std;
void swap(int &a, int &b)
{
    int z;
    z = a;
    a = b;
    b = z;
}
void maxHeap(int* initial,int size)//初始化最大堆
{
    int index = size/2;
    for (index;index>0;index--)
    {
            if (initial[index] < initial[2 * index] || initial[index] < initial[2 * index + 1])
            {
                if (initial[2 * index] >= initial[2 * index + 1])
                {
                    swap(initial[index], initial[2 * index]);
                    for (int a = 2 * index; a <= size/2;)
                    {
                        if (initial[a] < initial[2 * a] || initial[a] < initial[2 * a + 1])
                        {
                            if (initial[2 * a] >= initial[2 * a + 1])
                            {
                                swap(initial[a], initial[2 * a]);
                            }
                            else
                            {
                                swap(initial[a], initial[2 * a + 1]);
                            }
                        }
                        a = a * 2;
                    }
                }
                else
                {
                    swap(initial[index], initial[2 * index + 1]);
                    for (int a = 2 * index + 1; a <= size / 2;)
                    {
                        if (initial[a] < initial[2 * a] || initial[a] < initial[2 * a + 1])
                        {
                            if (initial[2 * a] >= initial[2 * a + 1])
                            {
                                swap(initial[a], initial[2 * a]);
                            }
                            else
                            {
                                swap(initial[a], initial[2 * a + 1]);
                            }
                        }
                        a = a * 2;
                    }
                }
            }
    }
}
void levelOrder(int*initial, int size)//层次遍历输出
{
    for (int a = 1;a <= size; a++)
    {
        cout << initial[a];
        if (a != size) 
        {
            cout << ",";
        }
    }
    cout << endl;
}
void heapSort(int*initial, int size)//堆排序
{
    for (int a = 1, b = size;b>1; b--)
    {
        a = 1;
        swap(initial[b], initial[1]);
        if (b == 2)
        {
            if (initial[1] > initial[2])
            {
                swap(initial[1], initial[2]);
                continue;
            }
        }
        for (;a<b/2;)
        {
            if (initial[2 * a] > initial[a] || initial[2 * a + 1] > initial[a])
            {
                if (initial[2 * a] > initial[2 * a + 1])
                {
                    swap(initial[2 * a], initial[a]);
                    a = 2 * a;
                }
                else
                {
                    swap(initial[2 * a + 1], initial[a]);
                    a = 2 * a + 1;
                }
            }
            else break;
        }
        if (2 * a == b - 1)
        {
            if (initial[a] < initial[2 * a])
            {
                swap(initial[a], initial[2 * a]);
            }
        }
    }
}
class Node
{
public:
    int key;
    int ele;
    Node*left;
    Node*right;
};
Node* BinarySearchTree(Node*root,int key,int &size)//创建二叉搜素树
{
    Node*root1 = root;
    Node*preroot1 = NULL;
    if (root1 == NULL)
    {
        root = new Node;
        root->left = new Node;
        root1 = root->left;
        root1->ele = 0;
        root1->key = key;
        root1->left = root1->right = NULL;
        return root->left;
    }
    while (root1 != NULL)
    {
        if (key < root1->key)
        {
            preroot1 = root1;
            root1 = root1->left;
        }
        else
        {
            if (key > root1->key)
            {
                preroot1 = root1;
                root1 = root1->right;
            }
            else
            {
                root1->key = key;
                size--;
                return root;
            }
        }
    }
    Node*newNode = new Node;
    if (key < preroot1->key)
    {
         preroot1->left=newNode;
    }
    else
    {
          preroot1->right=newNode;
    }
    newNode->key = key;
    newNode->ele = 0;
    newNode->left = newNode->right = NULL;
    return root;
}
void preOrder(Node*root,int &size,int &a)
{
    if (root != NULL)
    {
        cout << root->key;
        if (a != size)
        {
            cout << ",";
            a++;
        }
        preOrder(root->left, size, a);
        preOrder(root->right, size, a);
    }
}
void inOrder(Node*root, int &size, int &b)
{
    if (root != NULL)
    {
        inOrder(root->left, size, b);
        cout << root->key;
        if (b != size)
        {
            cout << ",";
            b++;
        }
        inOrder(root->right, size, b);
    }
}
int main()
{
    cout << "Input" << endl;
    int size = 0;//数组中元素的个数
    int i = 1;//数组第一个位置不存数
    int initial[25];
    int initial2[25];
    for (size;; size++,i++)
    {
        cin >> initial[i];
        initial2[i]=initial[i];
        if (initial[i] == 0)break;
    }
    maxHeap(initial, size);
    cout << "Output" << endl;
    levelOrder(initial, size);
    heapSort(initial, size);
    levelOrder(initial, size);
    Node* root=NULL;
    
    for (int j = 1; j <= size; j++)
    {
       root=BinarySearchTree(root,initial2[j], size);
    }
    int a = 1;
    int b = 1;
    preOrder(root, size, a);
    cout << endl;
    inOrder(root, size, b);
    cout <<endl<< "End";
    return 0;
}