2021秋季《数据结构》_第六章书面作业（基础练习）

最新推荐文章于 2024-10-31 16:14:37 发布
最新推荐文章于 2024-10-31 16:14:37 发布
阅读量716 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉查找树 平衡树 堆排序 平均比较次数 查找效率
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rd142857/article/details/121745640
版权

二叉查找树

  1. 输入为一组未排序的结点序列（类型为整数，用做结点的键值），生成由它们作结点键值
    的一棵查找树（结点未排序，依次插入树中）。
  2. 中序输出这棵查找树。
  3. 判断这棵查找树是否平衡。
  4. 计算这棵查找树查找结点的平均比较次数（假设每个结点的使用概率相同，且每次查找
    都是一次成功的查找）。
    参考公式：
    AVG（二叉查找法）= ∑树中的𝒌𝒑(𝒌)(𝟏 + 𝝀𝒌)
    输入格式：
    第一行输入一个正整数𝑛 (𝑛 ≤ 1000)表示结点数量。
    第二行输入 n 个整数表示未排序的结点序列，每个数之间用空格隔开。
    输出格式：
    第一行中序输出这棵查找树。
    第二行判断这棵查找树是否平衡，如果是输出“Yes”，否则输出“No”(不用输出引号)。
    第三行输出这颗查找树查找结点的平均比较次数，结果保留 6 位小数。
    示例： input 5
    3 5 1 2 4 output
    1 2 3 4 5
    Yes
    2.200000
#include <bits/stdc++.h>
using namespace std;

typedef struct binarySortTree {
    int data;
    struct binarySortTree* lchild;
    struct binarySortTree* rchild;
} BiNODE;

// 链式存储
typedef struct snode
{
    BiNODE* node;
    int lev;      //用于层次遍历中记录结点的层数
    struct snode* next;
}Snode;


// 将结点递归放入查找树
BiNODE* Insert(BiNODE* root, int x)
{
    if (!root)
    {
        BiNODE* t = new BiNODE;
        t->data = x;
        t->lchild = NULL;
        t->rchild = NULL;
        root = t;
    }
    else if (x < root->data)
    {
        root->lchild = Insert(root->lchild, x);

    }
    else if (x > root->data)
    {
        root->rchild = Insert(root->rchild, x);
    }
    return root;
}

/**
 * 建立一颗以nodeArr作为结点键值的一棵查找树
 * 数组下标从1开始
 * @param nodeArr   [大小为arrSize的数组]
 * @param arrSize   [数组大小]
 *
 * @return          [树的根节点root的指针]
 */
BiNODE* buildTree(int* nodeArr, int arrSize) 
{
    BiNODE* root = NULL;
    for (int i = 1; i <= arrSize; i++)
        root = Insert(root, nodeArr[i]);
    return root;
}

/**
 * 中序输出这棵查找树
 * 无返回值, 输出一行, 数与数之间有空格, 行末无多余空格
 * 具体参考文档上的样例
 * @param root      [树的根节点]
 */
void printInOrder(BiNODE* root) 
{
    if (!root) return;
    BiNODE* p = root;
    Snode* top = NULL;
    Snode* t = NULL;
    int flag = 1;
    // 用于判断当前结点是否为第一个输出的结点，
    // 第一个：空格+data
    // 非第一个：data
    while (p || top)
    {
        while (p)
        {
            t = new Snode;
            t->node = p;
            t->next = top;
            top = t;  // 更新栈顶为新压入的结点
            p = p->lchild;  // 直到找到最后一个左子树
        }
        if (top)
        {
            p = top->node;
            if (flag)  // 是第一个
            {
                printf("%d", p->data);
                flag = 0;
            }
            else
            {
                printf(" %d", p->data);
            }
            t = top;
            top = top->next;
            delete t;
            p = p->rchild;  // 处理右子树
        }
    }

    printf("\n");
}

// 递归判断是否平衡树
bool isBalance(BiNODE* root, int& depth)
{
    // 检查子树的深度差是否小于1
    if (!root)  // 空树为平衡树
    {
        depth = 0;
        return true;
    }
    int ld = 0, rd = 0;
    // 子树中有不平衡树，那么本树不平衡
    if (!isBalance(root->lchild,ld) || !isBalance(root->rchild,rd))
        return false;
    // 子树深度差>1，那么本树不平衡
    if (abs(ld - rd) > 1)
        return false;
    // 本树的深度为子树中深度最大值+1
    depth = ld > rd ? ld + 1 : rd + 1;
    return true;
}

/**
 * 判断这棵查找树是否平衡
 * 如果是输出"Yes", 否则输出"No"(不用输出引号)
 * 具体参考文档上的样例
 * @param root      [树的根节点]
 */
void printIsBalance(BiNODE* root)
{
    int depth = 0;
    if (isBalance(root, depth))
        printf("Yes\n");
    else printf("No\n");
}

/**
 * 输出这颗查找树查找结点的平均比较次数, 结果保留6位小数
 * 具体参考文档上的样例
 * @param root      [树的根节点]
 */
void printAVG(BiNODE* root)
{
    if (!root)
        printf("0.000000\n");
    else
    {
        Snode* head = new Snode;
        head->lev = 1;  // 根结点层数为1
        head->node = root;
        head->next = NULL;
        Snode* tail = head;
        double sum = 0, num = 0;
        while (head!=NULL)
        {
            // 左右孩子入队
            if (head->node->lchild)
            {
                Snode* r = new Snode;
                r->node = head->node->lchild;
                r->next = NULL;
                r->lev = head->lev + 1;
                tail->next = r;  // 子结点进入队列尾部
                tail = r;
            }
            if (head->node->rchild)
            {
                Snode* r = new Snode;
                r->node = head->node->rchild;
                r->next = NULL;
                r->lev = head->lev + 1;
                tail->next = r;  // 子结点进入队列尾部
                tail = r;
            }
            // 出队
            Snode* r = head;
            sum += head->lev;
            num++;
            head = head->next;
            delete r;
        }
        printf("%.6f\n", sum / num);
    }
}

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

    int* nodeArr = (int*)malloc((n + 1) * sizeof(int));
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &nodeArr[i]);
    }

    BiNODE* root = buildTree(nodeArr, n);
    printInOrder(root);
    printIsBalance(root);
    printAVG(root);

    return 0;
}

堆排序

  1. 输入为一组未排序的结点（类型为整数）序列，建大顶堆。
  2. 通过交换及调整堆完成堆排序。输出排序后的结点序列。
  3. 分别输出“建堆”和“交换调整”过程中的交换次数。
    输入格式：
    第一行输入一个正整数𝑛 (𝑛 ≤ 1000)表示结点数量。
    第二行输入 n 个整数表示未排序的结点序列，数与数之间用空格隔开。
    输出格式：
    第一行输出 n 个整数表示排序后的结点序列。
    第二行输出 2 个整数，分别表示“建堆”和“交换调整”过程的交换次数。
    示例： Input 5
    3 5 1 2 4
    Output
    1 2 3 4 5
    2 7
#include <bits/stdc++.h>
using namespace std;

/**
 * 给定一组未排序的结点(类型为整数)序列, 建一个大顶堆
 * 同时计算建堆时的交换次数
 * 数组下标从0开始
 * @param arr   	[大小为arrSize的数组]
 * @param arrSize	[数组大小]
 *
 * @return          [建堆过程中的交换次数]
 */

int siftdown(int* a, int i, int n)
// 调整以a[i]为根的二叉树使之成为堆
// 堆的各子树也为堆
{
    int sum = 0;
    int j;
    int t = a[i];
    //int j = 2 * i + 1;
    while ((j=2*i+1)<n)
    {
        // 挑选左右孩子中更大的结点
        if (j < n - 1 && a[j] < a[j + 1])
            j++;
        if (t < a[j])  // 如果t比孩子小
        {
            a[i] = a[j];
            i = j;
            sum++;
        }
        else break;
    }
    a[i] = t;
    return sum;
}

int buildHeap(int* arr, int arrSize) 
{
    int sum = 0;
    for (int i = (arrSize - 2) / 2; i >= 0; i--)
        sum += siftdown(arr, i, arrSize);
    return sum;
}

/**
 * 给定一个大小为arrSize的未排序的堆, 输出堆排序后的序列
 * 同时计算堆排序过程中的交换次数
 * @param arr   	[大小为arrSize的堆]
 * @param arrSize	[堆的大小]
 *
 * @return          [堆排序过程中的交换次数]
 */
int heapSort(int* arr, int arrSize)
{
    if (arrSize == 0) return 0;
    int sum = 0;
    int sum1 = buildHeap(arr, arrSize);
    for (int m = arrSize - 1; m >= 1; m--)
    {
        int tmp = arr[0];
        arr[0] = arr[m];
        arr[m] = tmp;
        sum+=(1+siftdown(arr, 0, m));
    }
    for (int i = 0; i < arrSize; i++)
        printf("%d%c", arr[i], i == arrSize - 1 ? '\n' : ' ');
    return sum;
}

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

    int* arr = (int*)malloc((n) * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    int buildSwapCnt = buildHeap(arr, n);
    int sortSwapCnt = heapSort(arr, n);
    printf("%d %d\n", buildSwapCnt, sortSwapCnt);
    //输出排好序的序列

    return 0;
}

平衡查找树

用前序+中序的方法输入一棵二叉树，建树，树结点的结构包括：键值，平衡度和左右子树指针。

  1. 判断输入的二叉树是否为平衡的查找树（分别判断是否是平衡树，是否是查找树）。
    注：输出 Yes or No
  2. 二叉树建立完成后，编写函数，通过仅“跟踪”到叶子结点的一条路径，而不查看树中
    所有的结点，返回树的高度并输出这条路径。输出高度及路径
    例：输入
    前序：70 30 20 10 50 40 60 100 90 80 110 120
    中序：10 20 30 40 50 60 70 80 90 100 110 120
    struct node { //包括结点键值，结点的平衡度，左子结点指针，右子结点指针
    }
    输入格式：
    第一行输入一个正整数𝑛 (𝑛 ≤ 1000)表示二叉树的结点数量。
    第二行输入 n 个整数表示二叉树的前序遍历序列，数与数之间用空格隔开。
    第二行输入 n 个整数表示二叉树的中序遍历序列，数与数之间用空格隔开。
    输出格式：
    第一行判断输入的二叉树是否平衡，如果是输出“Yes”，否则输出“No”(不用输出引
    号)。
    第二行判断输入的二叉树是否是排序树，如果是输出“Yes”，否则输出“No”(不用输
    出引号)。
    第三行输出问题 2 中的路径，输出 n 个数，数与数之间用空格隔开。 第四行输出问题 2 中树的层数。
    示例： Input 12
    7 3 2 1 5 4 6 10 9 8 11 12
    1 2 3 4 5 6 7 8 9 10 11 12
    Output
    Yes
    Yes
    7 10 11 12 4
在这里插入代码片#include <bits/stdc++.h>
using namespace std;

typedef struct binarySortTree {
    int data;  //结点的数据
    int BF;   //结点的平衡因子
    struct binarySortTree* lchild;
    struct binarySortTree* rchild;
}BiNODE;

/**
 * 给定二叉树的前序和中序遍历序列, 建立一棵二叉树
 * 数组下标从1开始
 * @param preOrder	[大小为arrSize的前序遍历序列]
 * @param inOrder	[大小为arrSize的中序遍历序列]
 * @param arrSize	[序列的长度]
 *
 * @return          [树的根节点root]
 */

// 递归获得结点的平衡度
// 与获得树深度函数非常类似
int getBF(BiNODE* root)
{
    if (!root)  // 仅根节点时高度为0
        return -1;
    int rd = getBF(root->rchild);
    int ld = getBF(root->lchild);
    root->BF = rd - ld;
    int depth = rd > ld ? rd + 1 : ld + 1;
    return depth;
}

// 递归调用
BiNODE* buildTreePreInRe(int pre[], int head1, int tail1, 
    int in[], int head2, int tail2)
{
    if (tail2 < head2)
        return NULL;
    int i = head2;
    for (; i <= tail2; i++)
    {
        if (in[i] == pre[head1])
            break;
    }
    BiNODE* root = new BiNODE;
    root->data = pre[head1];
    root->lchild = buildTreePreInRe(pre, head1 + 1, head1 + i - head2, in, head2, i - 1);
    root->rchild = buildTreePreInRe(pre, head1 + i - head2 + 1, tail1, in, i + 1, tail2);
    return root;
}

BiNODE* buildBTree(int* preOrder, int* inOrder, int arrSize)
{
    if (arrSize == 0) return NULL;
    BiNODE* root = buildTreePreInRe(preOrder, 1, arrSize, inOrder, 1, arrSize);
    int depth = getBF(root);  // root->BF已在getBF中改变
    return root;
}


/**
 * 给定二叉树的根节点, 判断该树是否平衡
 * 如果是输出“Yes”，否则输出“No”(不用输出引号)
 * @param root		[二叉树的根节点]
 */

bool isBalance(BiNODE* root)
{
    if (!root) 
        return true;
    if (root->BF > 1 || root->BF < -1)
        return false;
    if (!isBalance(root->lchild) || !isBalance(root->rchild))
        return false;
    return true;
}

void printIsBalance(BiNODE* root) 
{
    if (isBalance(root))
        printf("Yes\n");
    else printf("No\n");
}

/**
 * 给定二叉树的根节点, 判断该树是否为搜索树
 * 如果是输出“Yes”，否则输出“No”(不用输出引号)
 * @param root		[二叉树的根节点]
 */

int former = -1;
bool isSearchTree(BiNODE* root)
{
    if (!root)
            return true;
    if (!isSearchTree(root->lchild))
        return false;
    if (root->data < former)
        return false;
    former = root->data;
    if (!isSearchTree(root->rchild))
        return false;
    return true;
}

void printIsSearchTree(BiNODE* root) 
{
    if (isSearchTree(root))
        printf("Yes\n");
    else printf("No\n");
}


/**
 * 给定二叉树的根节点, 通过仅“跟踪”到叶子结点的一条路径
 * 而不查看树中所有的结点, 返回树的高度并输出这条路径。
 * @param root		[二叉树的根节点]
 *
 * @return			[树的高度]
 */

int getTreeHeight(BiNODE* root) 
{
    if (!root)
    {
        cout << endl;
        return -1;
    }
    printf("%d ", root->data);
    int ld = 0, rd = 0;
    if (root->BF >= 0)  // （靠右策略）右子树更深
    {
        rd = getTreeHeight(root->rchild);
    }
    else  // 左子树更深
    {
        ld = getTreeHeight(root->lchild);
    }
    int depth = rd > ld ? rd + 1 : ld + 1;
    return depth;
}

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

    int* preOrder = (int*)malloc((n + 1) * sizeof(int));
    int* inOrder = (int*)malloc((n + 1) * sizeof(int));
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &preOrder[i]);
    }
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &inOrder[i]);
    }

    BiNODE* root = buildBTree(preOrder, inOrder, n);
    printIsBalance(root);
    printIsSearchTree(root);
    int treeHeight = getTreeHeight(root);
    printf("%d\n", treeHeight);

    return 0;
}
rd142857
关注
专栏目录
数据结构书面作业1
12-07
一、选择题 1. 在线性结构中，第一个结点没有前驱结点，其余每个结点有且只有 （ ） 个前驱结点；最后一个结点没有后继结点，其余每个结点有且只有（ ）个后继结点。 A. 1 , 1 B. 1 , 2 C. 2 , 1 D. 2 , 2 2. 线性表若采用链式存储结构时，要求内存中可用存储单元的地址___。 A. 必须是连续的 B. 部分地址必须是连续的 C. 一定是不连续的 D. 连续或不连续都可以
2021秋季《数据结构》_第六章书面作业（应用）
rd142857的博客
12-11 1072
题目 假设结点序列 F=(60,30,90,50,120,70,40,80),试用查找树的插入算法，用 F 中的结点依次进行插入，画出每一步插入后的查找树**。**再用查找树的删除算法，从查找树中依次删除40,70,60，画出删除后的查找树。 插入 删除 试用 Adelson 插入方法依次把结点 50,20,10,100,120,30,110,60,70...
2021秋季《数据结构》_第一章书面作业
rd142857的博客
10-13 393
代码 编写一个将给定的线性单链表逆转的函数，只允许改变结点的指针值，不允许移动结点值，返回逆转后的链表的头指针。 Node* reverse_Linklist(Node* head) // 带头结点 { // 空表返回头结点 if(!head->next) return head; else { Node* p = head->next; Node* tmp = NULL; // 待修改指针的结点 N
2021秋季《数据结构》_第三章书面作业
rd142857的博客
11-03 322
测试代码见附录 题目 对于给定的线性表，A=(12,2,16,30,8,28,4,10,20)，分别写出用下列排序方法对 A 进行排序时，每一趟处理后的结果。 插入排序 2 12 16 30 8 28 4 10 20 2 12 16 30 8 28 4 10 20 2 12 16 30 8 28 4 10 20 2 8 12 16 30 28 4 10 20 2 8 12 16 28 30 4 10 20 2 4 8 12 16 28 30 10 20 2 4 8 10 12 16 28 30 .
luogu P1428 小鱼比可爱 x
anjian3128的专栏
06-15 109
P1428 小鱼比可爱 题目描述 人比人，气死人；鱼比鱼，难死鱼。小鱼最近参加了一个“比可爱”比赛，比的是每只鱼的可爱程度。参赛的鱼被从左到右排成一排，头都朝向左边，然后每只鱼会得到一个整数数值，表示这只鱼的可爱程度，很显然整数越大，表示这只鱼越可爱，而且任意两只鱼的可爱程度[color=red]可能一样[/color]。由于所有的鱼头都朝向左边，所以每只鱼只能看见在它左边的鱼的可爱...
西南交通大学2020秋季_数据结构第5次作业
12-30
在这个西南交通大学2020秋季学期的数据结构第5次作业中，主要涵盖了查找和内部排序两大主题。 一、查找 1. 对分查找算法：这是一种在有序数组中查找特定元素的高效方法。在已知n元顺序表（数组）按关键字递增有序...
修井工程2021年秋_第一阶段在线作业全对答案.docx
10-15
这份2021年秋季第一阶段的在线作业提供了关于这些关键知识点的解答。 首先，井身结构中的第一层套管被称为导管，它的主要作用是引导钻具进入井眼，并保护井壁。最常用的完井方法是射孔完井，包括套管射孔和尾管射孔...
浙江大学--数据结构各章答案.pdf
08-17
- 加强对数据结构和算法题目的练习，通过解决具体问题来提升对理论知识的理解和应用能力。 以上知识点涵盖了《数据结构与STL》一书的多个方面，包括数据结构的基本概念、STL的使用方法和算法的效率分析等。掌握这些...
东北大学21秋季 《数据结构ⅱ》在线平时作业1 参考答案.pdf
04-17
数据结构是计算机科学中至关重要的一个分支，它研究如何在计算机中有效地组织和存储数据，以便于高效地访问和操作。本题涉及的数据结构相关知识点包括图的存储、排序算法、数据结构的基本概念以及特定操作的实现。 ...
数据结构复习笔记(西南交通大学2020秋季学期数据结构A)-Keller_Wang.pdf
01-09
写这个笔记的初衷是因为老师发的ppt中并没有对于各个例题的过多解答，而且考察的很多知识点其实不需要对算法和数据结构本身有很深入的了解就可以解决，因此就考虑写这么一篇笔记，主要希望能够帮助大家快速并全面的...
Leetcode 257 二叉树的所有路径（给定一个二叉树，返回所有从根节点到叶子节点的路径）
wwxy1995的博客
09-04 981
搜索到叶子节点时往答案中添加。标准的DFS class Solution { public: vector<string> res; vector<string> binaryTreePaths(TreeNode* root) { string s; dfs(root,s); return res; } void dfs(TreeNode* root, string s){ ...
数据结构 作业答案 第6章 图
HKD_WCY的博客
06-14 1万+
第6章 图 1．选择题 （1）在一个图中，所有顶点的度数之和等于图的边数的（ ）倍。 A．1/2 B．1 C．2 D．4 答案：C （2）在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的（ ）倍。 A．1/2 B．1 C．2 D．4 答案：B 解释：有向图所有顶点入度之和等于所有顶点出度之和。 （3）具有n个顶点的有向图最多有（ ）条边。 A．n
二叉树根节点到叶子节点的所有路径和
yangyangcome的博客
07-27 1332
描述 给定一个仅包含数字0−9 的二叉树，每一条从根节点到叶子节点的路径都可以用一个数字表示。例如根节点到叶子节点的一条路径是1→2→3,那么这条路径就用123 来代替。找出根节点到叶子节点的所有路径表示的数字之和 例如： 这颗二叉树一共有两条路径，根节点到叶子节点的路径 1→2 用数字 12 代替,根节点到叶子节点的路径 1→3 用数字13 代替 所以答案为+13=25 12+13=25 示例1 输入：{1,0} 返回值：10 示例2 输入：{1,#,9} 返回值：19 在遍历的过程中计算根节点到叶节点的
二叉树根节点到叶子节点和为指定
weixin_37841366的博客
12-13 157
牛客地址 解题思路 深搜+回溯 实现代码 import java.util.*; /* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */ public class Solution { /** * * @param root TreeNode类 * @param sum int整型
二叉树根节点到叶子节点路径问题
Mr_Liuzhongbin的博客
05-19 2679
前言 最近在刷leetcode的关于二叉树的题目，碰到几题关于二叉树节点的问题。在这里做一个小结记录自己的理解和知识的长进。 leetcode问题 路径总和 路径总和Ⅱ 思路总结 前序 关于二叉树根节点到叶子节点路径问题，最容易想到的就是打印二叉树所有根节点到叶子节点的路径。这个很容易，就是以二叉树的前序遍历为基础，在遍历过程中记录遍历的节点然后碰到叶子节点就输出结果。代码如下： public static void printAllPath(TreeNode root,String s) {
关于ASL(平均查找长度)的简单总结
热门推荐
weixin_34184561的博客
01-08 1万+
ASL（Average Search Length），即平均查找长度，在查找运算中，由于所费时间在关键字的比较上，所以把平均需要和待查找值比较的关键字次数成为平均查找长度。 它的定义是这样的： 其中n为查找表中元素个数，Pi为查找第i个元素的概率，通常假设每个元素查找概率相同，...
Redis的数据结构
最新发布
2302_81083129的博客
10-31 998
缓存穿透、缓存雪崩、缓存击穿、Redis的数据结构及常用命令
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 327
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
数据结构作业：查找与排序算法挑战
"西南交通大学2020秋季的数据结构第5次作业，涉及查找和排序相关的知识点，包括对分查找、平衡二叉排序树、B-树、哈希表、内部排序（插入排序、冒泡排序的递归实现）以及链式基数排序。" 在本次数据结构作业中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值