数据结构第八周 ：（ 数组循环右移K位 + 二叉树的创建及遍历 + 二叉树根据中序和后序求前序遍历 + 二叉树结点的共同祖先问题 + 二叉树左右子树交换操作 ）

最新推荐文章于 2023-04-11 14:44:49 发布
最新推荐文章于 2023-04-11 14:44:49 发布
阅读量908 收藏 6
点赞数 2
分类专栏： # 数据结构 文章标签： 数据结构 二叉树 遍历 共同祖先 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51800570/article/details/128873262
版权

目录

数组循环右移K位

【问题描述】将一个数组中的元素循环右移K位，要求只使用一个元素大小的附加存储空间，时间复杂度为O(n)。

【样例输入】

1 2 3 4 5 6 7 8 0

2

【样例输出】

7 8 1 2 3 4 5 6

【提示】0代表输入结束

#include<iostream>
#define N 1000
using namespace std;

void swap(int s[N], int front, int behind)
{
    int temp = 0;
    for( ; front < behind; front ++)
    {
        temp = s[front];
        s[front] = s[behind];
        s[behind] = temp;
        behind --;
    }
}
int main()
{
    int s[N];
    int i = 0;
    int num = 0;
    int len = 0;
    for(i = 0; ; i ++) // 输入数组
    {
        cin>>num;
        if(num == 0) break;
        else
        {
            len ++;
            s[i] = num;
        }
    }
    int k = 0;
    cin>>k;
    k = k % len;
    int j = len - k; //分割点
    swap(s, 0, j - 1 );
    swap(s, j, len - 1);
    swap(s, 0, len - 1);
    for(i = 0; i < len; i ++)
    {
        cout<<s[i]<<" ";
    }
    return 0;
}

二叉树的创建及遍历

【问题描述】

给出一个按照先序遍历得出的字符串，‘#’ 代表空的子节点，大写字母代表节点内容。请通过这个字符串建立二叉树，并分别采用“递归”和“非递归”的先序、中序、后序遍历的算法分别输出每一个非空节点。

【输入形式】
输入只有一行，包含一个字符串S，用来建立二叉树。保证S为合法的二叉树先序遍历字符串，节点内容只有大写字母，且S的长度不超过100。

【输出形式】
共有6行，每一行包含一串字符，表示分别按递归和非递归的先序、中序、后序遍历得出的节点内容，每个字母后输出一个空格。请注意行尾输出换行。

【样例输入】

ABC##DE#G##F###

【样例输出】

A B C D E G F

C B E G D F A

C G E F D B A

A B C D E G F

C B E G D F A

C G E F D B A

#include<iostream>
#include<stack>
#include<stdlib.h>
#include<stdio.h>
using namespace std;

typedef struct Bnode //定义二叉树节点
{
    char data;
    struct Bnode * LChild;
    struct Bnode * RChild;
}BiTreeNode,*BiTree;

void CreatBt(BiTree * root) //创建二叉树
{
    char s;
    s = getchar();
    if(s == '#')
    {
        *root = NULL;
    }
    else
    {
        *root = (BiTree)malloc(sizeof(BiTreeNode));
        (*root)->data = s;
        CreatBt(&(*root)->LChild);
        CreatBt(&(*root)->RChild);
    }
}

void RePreOder(BiTree root) //递归前序遍历
{
    if(root == NULL)
    {
        return ;
    }
    else
    {
        cout<<root->data<<" ";
        RePreOder(root->LChild);
        RePreOder(root->RChild);
    }
    return ;
}

void ReInOrder(BiTree root) //递归中序遍历
{
    if(root == NULL)
    {
        return ;
    }
    else
    {
        ReInOrder(root->LChild);
        cout<<root->data<<" ";
        ReInOrder(root->RChild);
    }
    return ;
}

void RePostOrder(BiTree root) //递归后序遍历
{
    if(root == NULL)
    {
        return ;
    }
    else
    {
        RePostOrder(root->LChild);
        RePostOrder(root->RChild);
        cout<<root->data<<" ";
    }
    return ;
}

void PreOrder(BiTree root) //前序遍历
{
    stack<BiTree> S; //元素定义为指针类型
    while(root != NULL)
    {
        cout<<root->data<<" ";
        S.push(root);
        if(root->LChild != NULL)
        {
            root = root->LChild;
        }
        else if(!S.empty())
        {
            while(!S.empty())
            {
                root = S.top(); //无参有返回值
                S.pop(); //无参无返回值
                root = root->RChild;
                if(root != NULL) break;
            }
        }
        else
        {
            root = NULL;
        }
    }
}

void InOrder(BiTree root) //中序遍历
{
    stack<BiTree> S;
    while(root != NULL)
    {
        S.push(root);
        if(root->LChild != NULL)
        {
            root = root->LChild;
        }
        else if(!S.empty())
        {
            while(!S.empty())
            {
                root = S.top();
                S.pop();
                cout<<root->data<<" "; //出栈顺序左根右
                root = root->RChild;
                if(root != NULL) break;
            }
        }
        else
        {
            root = NULL;
        }
    }
}

void PostOrder(BiTree root) //后序遍历
{
    stack<BiTree> S;
    BiTree p = root;
    BiTree q = NULL;
    while(p != NULL || !S.empty())
    {
        while(p != NULL)
        {
            S.push(p);
            p = p->LChild;
        }
        BiTree t = S.top();
        if(t->RChild == NULL || t->RChild == q)
        {
            cout<<t->data<<" ";
            S.pop();
            q = t;
        }
        else
        {
            p = t->RChild;
        }
    }
}

int main()
{
    BiTree root = NULL;
    CreatBt(&root); //创建二叉树

    RePreOder(root); //sting类传值，原string类不改变
    cout<<endl;
    ReInOrder(root);
    cout<<endl;
    RePostOrder(root);
    cout<<endl;

    PreOrder(root);
    cout<<endl;
    InOrder(root);
    cout<<endl;
    PostOrder(root);
    return 0;
}
//总结：string类初始状态无空间，不可以s[0]这样使用

二叉树根据中序和后序求前序遍历

【问题描述】 根据一棵二叉树的中序遍历序列和后序遍历序列，求这棵树的前序遍历序列。

【输入形式】 一棵树的中序遍历序列和该树后序遍历序列。输入序列中仅含有小写字母，且没有重复的字母

【输出形式】 一棵树的前序遍历序列

【样例输入】
dbeafcg

debfgca

【样例输出】

abdecfg

#include<iostream>
#include<cstring>
#include<stdlib.h>
using namespace std;
typedef struct Bnode
{
    char data;
    struct Bnode * LChild;
    struct Bnode * RChild;
}BtNode,*BTree;
void CreatBt(BTree * root, string post, string in, int postleft, int postright, int inleft, int inright)
{
    if(postleft > postright)
    {
        *root = NULL;
    }
    else
    {
        *root = (BTree)malloc(sizeof(BtNode));
        (*root)->data = post[postright];
        //cout<<(*root)->data<<" ";
        int mid = 0;
        while(in[mid] != post[postright])
        {
            mid ++;
        }
        CreatBt(&((*root)->LChild), post, in, postleft, postleft + mid - inleft - 1, inleft, mid -1);
        CreatBt(&((*root)->RChild), post, in, postleft + mid - inleft, postright - 1, mid + 1, inright);
    }
}

void PreOrder(BTree root)
{
    if(root == NULL)
    {
        return ;
    }
    else
    {
        cout<<root->data;//root不为空才能输出
        PreOrder(root->LChild);
        PreOrder(root->RChild);
    }
}
int main()
{
    string post;
    string in;
    cin>>in;
    cin>>post;
    int len = post.length();
    BtNode * root = NULL;
    CreatBt(&root, post, in, 0, len - 1, 0, len - 1);
    PreOrder(root);
}

二叉树结点的共同祖先问题

【问题描述】假设二叉树采用二叉链表方式存储，root指向根结点，p所指结点和q所指结点为二叉树中的两个不同结点，且互不成为根到该结点的路径上的点，编程求解距离它们最近的共同祖先。

【输入形式】二叉树的前序和中序遍历序列，用以创建该二叉树的链式存储结构；以及二叉树的两个结点数据 x 和 y

【输出形式】结点数据值为 x 和结点数据值为 y 的最近的共同祖先，若没有共同祖先则输出NULL，请注意一个结点本身不能成为另一个结点的共同祖先。

【样例输入】

GABDCEF

BDAEFCG

DF

【样例输出】

A

#include<iostream>
#include<cstring>
#include<stdlib.h>
using namespace std;

typedef struct node
{
    char data;
    struct node * LChild;
    struct node * RChild;
}BtNode, *BTree;

void Creat(BTree * root, string Pre, string In, int preleft, int preright, int inleft, int inright)
{
    if(inleft > inright)
    {
        *root = NULL;//此时二叉树没有节点，应该让指针为空
    }
    else
    {
        int mid = 0;
        while(In[mid] != Pre[preleft])
        {
            mid ++;
        }
        *root = (BTree)malloc(sizeof(BtNode));
        (*root)->data = Pre[preleft];
        Creat(&((*root)->LChild), Pre, In, preleft + 1, preleft + mid - inleft, inleft, mid - 1);
        Creat(&((*root)->RChild), Pre, In, preleft + mid - inleft + 1, preright, mid + 1, inright);
    }
}

BTree Find(BTree root, BTree p, BTree q)
{
    if(root == NULL) return NULL;
    if(root->data == p->data || root->data == q->data) //NULL为假
    {
        return root;
    }
    BtNode * left = Find(root->LChild, p, q);
    BtNode * right = Find(root->RChild, p, q);
    if(!left && !right) return NULL;
    else if(!left && right) return right;
    else if(left && !right) return left;

    return root;
}

void PreOrder(BTree root)
{
    if(root == NULL)
    {
        return ;
    }
    else
    {
        cout<<root->data;
        PreOrder(root->LChild);
        PreOrder(root->RChild);
    }
}
int main()
{
    string Pre;
    string In;
    cin>>Pre;
    cin>>In;
    BtNode * root = NULL;
    int len = Pre.length();
    Creat(&root, Pre, In, 0, len - 1, 0, len - 1);
    BtNode * p = (BTree)malloc(sizeof(BtNode));
    BtNode * q = (BTree)malloc(sizeof(BtNode));
    //PreOrder(root);
    cout<<endl;
    string s;
    cin>>s;
    p->data = s[0];
    q->data = s[1];
    //cout<<p->data<<q->data;
    BtNode * res = Find(root, p, q);
    if(res == NULL || res->data == root->data) cout<<"NULL";
    else cout<<res->data;
    return 0;
}

二叉树左右子树交换操作

【问题描述】二叉树按照二叉链表的方式存储。编写程序，计算二叉树中叶子结点的数目并输出；编写程序，将二叉树的每个结点的左、右子树进行交换，请注意不是只交换结点的data值，而是左、右孩子指针指向的交换，最后输出交换后的二叉树的后序遍历序列。

【输入形式】二叉树的前序遍历序列，空指针的位置输入字符#

【输出形式】叶子结点的数目；左右子树交换后，后序遍历的序列，空子树的位置输出字符#

【样例输入】

ABE##F##CG###

【样例输出】

3

###GC##F##EBA

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;

typedef struct node //建立二叉树节点
{
    char data;
    struct node * LChild;
    struct node * RChild;
}BtNode, *BTree;

void CreatBt(BTree * root) //创建二叉树
{
    char c;
    c = getchar();
    if(c == '#')
    {
        *root = NULL;
    }
    else
    {
        *root = (BTree)malloc(sizeof(BtNode)); //要申请空间的
        (*root)->data = c;
        CreatBt(&((*root)->LChild));
        CreatBt(&((*root)->RChild));
    }
}

int CountLeave(BTree root) //分治法求叶子数
{
    int leave = 0;
    if(root == NULL)
        return 0;
    else
    {
        if(root->LChild == NULL && root->RChild == NULL)
            return 1;
        else
            return CountLeave(root->LChild) + CountLeave(root->RChild);
    }
    return leave;
}

void ChangeLR(BTree root)
{
    if(root == NULL)
    {
        return ;
    }
    else
    {
        BTree temp = root->LChild;
        root->LChild = root->RChild;
        root->RChild = temp;
        ChangeLR(root->LChild);
        ChangeLR(root->RChild);
    }
    return ;
}

/*void Addheight(BTree * root)
{
    if(*root == NULL)
    {
        *root = (BTree)malloc(sizeof(BtNode));
        (*root)->data = '#';
        (*root)->LChild = NULL;
        (*root)->RChild = NULL;
        return ;
    }
    else
    {
        Addheight(&((*root)->LChild));
        Addheight(&((*root)->RChild));
    }
}*/

void PostOrder(BTree root)
{
    if(root == NULL)
    {
        cout<<'#';
        return ;
    }
    else
    {
        PostOrder(root->LChild);
        PostOrder(root->RChild);
        cout<<root->data;
    }
    return ;
}

int main()
{
    BtNode * root;
    CreatBt(&root);//传指针的地址
    cout<<CountLeave(root)<<endl;
    ChangeLR(root);
    //Addheight(&root);
    PostOrder(root);
    return 0;
}
一只可爱的小猴子
关注
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
给定二叉树前序遍历和后序遍历，求任一中序遍历
m0_48024615的博客
02-11 1277
给定二叉树前序遍历和后序遍历，求任一中序遍历
循环遍历二叉树
weixin_30258027的博客
02-13 55
前序遍历 struct Node { Node*left; Node*right; int data; Node(){ func; } }; Node* create(Node*p, int depth) { if (p && depth) { p->left = new Node; p->right ...
2022-03-21：循环右移二叉树。 现有一棵个节点构成的二叉树，请你将每一层的节点向右循环位移位。某层向右位移一位(即)的含义为
福大大架构师每日一题
03-21 5399
2022-03-21：循环右移二叉树。 现有一棵个节点构成的二叉树，请你将每一层的节点向右循环位移位。某层向右位移一位(即)的含义为： 1.若当前节点为左孩子节点，会变成当前节点的双亲节点的右孩子节点。 2.若当前节点为右儿子，会变成当前节点的双亲节点的右边相邻兄弟节点的左孩子节点。(如果当前节点的双亲节点已经是最右边的节点了，则会变成双亲节点同级的最左边的节点的左孩子节点) 3.该层的每一个节点同时进行一次位移。 4.是从最下面的层开始位移，位移完每一层之后，再向上，直到根节点，位移完毕。 腾讯音乐202
9.16 腾讯音乐 二叉树右移
进阶之路
09-16 793
20% 没有OC，当时没时间了， 中间有一个小地方错了(已发现) struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} }; class Solution { public: /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * *
树-二叉循环树
weixin_30724853的博客
12-04 95
什么是二叉搜索树 二叉搜索树(Binary Search Tree)，是最基础，且相对简单的一种数据结构，支持Insert，Delete，Search，Min，Max，Successor，Predecessor等操作。最大的特点是每一个节点有不超过两个子节点，并且左子节点小于或者等于父节点，而右节点大于或者等于父节点。说它基础，是因为很多其它树形数据结构以它为原型而扩展，比如红黑树，...
二叉树的遍历- 递归法 与 循环法
Peace
09-19 237
递归方法-前序遍历(先访问根节点，然后左侧，然后右侧) void preOrderTraverse(Node* root) { if (root) { cout << root->val<<" "; preOrderTraverse(root->left); preOrderTraverse(root->right); } } 循环方法-前序遍历(先访问根节点，然后左侧，...
数据结构实验报告8-树-求二叉树先序、中序、后序遍历次序的第k个访问结点-实验内容与要求.docx
07-06
根据给定文件的信息，本次实验的主要目标是通过编程来实现对二叉树的先序、中序、后序遍历，并找到这些遍历次序下的第k个访问节点。接下来，我们将详细介绍实验的要求、设计思路、算法实现以及部分关键代码。 ### ...
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
01-20
二叉树是有限个元素的集合，该集合或者为空、或者有一个称为根节点（root）的元素及两个互不相交的、分别被称为左子树和右子树的二叉树组成。 1 二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的...
C语言二叉树常见操作详解【前序,中序,后序,层次遍历及非递归查找,统计个数,比较,求深度】
08-27
在本文中，我们将详细介绍C语言二叉树的基本概念、存储结构、遍历方法、非递归查找、统计个数、比较和求深度等操作技巧。 一、基本概念 二叉树是一种树形结构，每个结点最多有两棵子树，左子树和右子树，次序不...
数组循环左移K位
02-11
编程珠玑上第二章问题A的实现，杂技法，3次反转法
C语言的循环移位操作
01-26
移位操作移位操作移位操作移位操作移位操作移位操作移位操作移位操作移位操作移位操作移位操作移位操作移位操作移位操作移位操作移位操作
java中循环右移两位_1008 数组元素循环右移问题 (20分)【java题解】
weixin_39986466的博客
02-25 379
剑指offer第56题 数组中数字出现的次数(位运算)剑指offer第56题 数组中数字出现的次数(位运算) 文章目录 问题一：两个只出现一次的数 问题描述： 解题思路： 代码实现： 问题二：一个只出现一次的数 问题描述： 解题思路： 代码实现： 问题描述： 一个整型数组 nums 里除两个数字之外，其他数字都出现了java 堆排序java 堆排序 java堆排序 ****************...
算法:Morries法遍历二叉树
长舒的博客
06-13 544
今天看了下左神讲的有关morries遍历二叉树的视频(morries遍历，学术上就是线索化遍历二叉树)，这种遍历方法没有用到其他辅助数据结构，只使用了叶子结点的空闲指针，节省了许多不必要的开销，同时也加快了遍历的时间效率，下面我来总结 核心要点(步骤) 初始化线索结点，名字叫做cur，指向树的根结点 如果cur没有左孩子，cur右移，cur指向cur的右孩子结点(cur = cur->ri...
循环右移(耿5.2)
zhao2018的博客
04-13 599
Description编写程序，将一维数组A（下标从1开始）中的元素循环右移k位，要求只用一个元素大小的附加存储。Input第一行输入一维数组A的长度n和循环位移位数k(0&lt;n&lt;100;0&lt;k&lt;100)，用空格分开。第二行输入n个元素。Output输出循环右移k位后的一维数组。Sample Input 6 3 1 2 3 4 5 6 Sample Output4 5 6 1...
【数据结构】NOJ011 循环右移（耿5.2）
weixin_45932570的博客
04-11 292
1.题目 2. 代码 快速完成任务的方法 #include <iostream> using namespace std; int main(int argc, char** argv) { int a[100], n, k; cin >> n >> k; k = k%n; for(int i=0; i<n; i++){ cin >> a[i]; } //直接输出 for(int i=n-k; i<n; i++){
LeetCode-102. 二叉树的层序遍历
weixin_43183328的博客
04-15 116
给你一个二叉树，请你返回其按层序遍历得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层序遍历结果： [ [3], [9,20], [15,7] ] 方法一：广度优先搜索（BFS） 思路和算法： 我们可以想到最朴素的方法是用一个二元组（node，level）来表示状态，它表示某个节点和它所在的层数，每个新进对列的节点level...
数据结构与算法
a1058420631的博客
01-07 364
1.将一个含有n个元素的数组向右循环移动k位，要求时间复杂度是O(n)，且只能使用两个额外的变量。 右移K位的过程就是按后K位和剩余位分成两部分，分别逆序排列，然后把整个数组逆序排列。 变换过程通过以下步骤完成： 1.逆序排列 abcd: abcd1234 -&gt; dcba1234; 2.逆序排列 1234: dcba1234-&gt; dcba4321; 3.全部逆序 dcba43...
简单易懂——轮转数组：将数组中的元素向右轮转 k 个位置（c语言实现LeeCode.189：中等）
最新发布
GONGTEach的博客
04-11 1082
针对，如何将数组中的前m个元素移动到数组末尾。列举了两种可行的方法，和一种直觉算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一只可爱的小猴子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值