C/C++算法部分知识（数据结构笔记）

已于 2023-04-28 13:28:16 修改
阅读量122 收藏
点赞数
文章标签： 笔记
于 2023-04-27 16:42:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ztt19990421/article/details/130387305
版权

Catalan数

判断两棵二叉树是否相同

// 定义二叉树结构体
struct TreeNode {
    int val;           // 节点的值
    struct TreeNode *left;   // 左子节点指针
    struct TreeNode *right;  // 右子节点指针
};

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    // 判断两个节点是否同时为空，如果是，则相同
    if (p == NULL && q == NULL) {
        return true;
    }
    // 如果两个节点中有一个节点为空或节点的值不相等，则不相同
    if (p == NULL || q == NULL || p->val != q->val) {
        return false;
    }
    // 对两个节点的左右子树进行递归比较，如果都相同，则这两棵二叉树相同
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

求二叉树中结点的最大距离

  1. 首先定义了二叉树结构体，每个节点包含一个值和左右子节点的指针。
  2. 函数maxDepth用于求树的深度，传入根节点指针root。
  3. 如果根节点为空，深度为0。
  4. 分别递归求左子树和右子树的深度，然后返回左右子树深度的较大值加1，加1表示算上根节点的深度。
  5. 函数maxDistance用于求二叉树中结点的最大距离，传入根节点指针root。
  6. 如果根节点为空或根节点的左右子树均为空，最大距离为0。
  7. 分别递归求左子树和右子树的最大距离，并分别存储在left_distance和right_distance变量中。
  8. 最大距离可能有三种情况，先比较left_distance和right_distance的大小，然后再和通过根节点的最大距离比较：
    • 通过根节点的最大距离是左子树的深度加右子树的深度；
    • 根节点的最
// 定义二叉树结构体
struct TreeNode {
    int val;           // 节点的值
    struct TreeNode *left;   // 左子节点指针
    struct TreeNode *right;  // 右子节点指针
};

// 求树的深度
int maxDepth(struct TreeNode* root) {
    // 如果根节点为空，深度为0
    if (root == NULL) {
        return 0;
    }
    // 分别求左右子树的深度
    int left_depth = maxDepth(root->left);
    int right_depth = maxDepth(root->right);
    // 返回左右子树深度的较大值加1，加1表示算上根节点的深度
    return left_depth > right_depth ? left_depth + 1 : right_depth + 1;
}

// 求二叉树中结点的最大距离
int maxDistance(struct TreeNode* root) {
    // 如果根节点为空，最大距离为0
    if (root == NULL) {
        return 0;
    }
    // 如果根节点的左右子树均为空，最大距离为0
    if (root->left == NULL && root->right == NULL) {
        return 0;
    }
    // 分别求左子树和右子树的最大距离
    int left_distance = maxDistance(root->left);
    int right_distance = maxDistance(root->right);
    // 最大距离可能有三种情况：
    // 1. 通过根节点的最大距离是左子树的深度加右子树的深度；
    // 2. 根节点的最大距离在左子树中；
    // 3. 根节点的最大距离在右子树中。
    return fmax(fmax(left_distance, right_distance), maxDepth(root->left) + maxDepth(root->right));
}

通过前序遍历和中序遍历重建二叉树

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    char data;               // 结点存储的数据
    struct TreeNode *left;   // 左子结点指针
    struct TreeNode *right;  // 右子结点指针
}TreeNode;
//前序遍历：[1],[2,4,7],[3,5,6,8]
//中序遍历：[2,4,7],1,[3,5,6,8]
// 根据前序遍历序列preOrder和中序遍历序列inOrder重构二叉树
TreeNode *rebuildBinaryTree(char *preOrder, char *inOrder, int length) {
    // 如果序列长度为0，则直接返回空指针
    if (length == 0) {
        return NULL;
    }

    // 创建一个新的结点，并将前序遍历序列的第一个元素作为该结点的数据
    TreeNode *newNode = (TreeNode*)malloc(sizeof(TreeNode));
    newNode->data = *preOrder;

    int i;
    // 在中序遍历序列中查找该结点的位置
    for (i = 0; i < length; i++) {
        if (inOrder[i] == *preOrder) {
            break;
        }
    }

    // 递归构建左子树，左子树的长度为i
    newNode->left = rebuildBinaryTree(preOrder + 1, inOrder, i);//preOrder + 1就到了前序遍历中2的位置
    // 递归构建右子树，右子树的长度为length-i-1
    newNode->right = rebuildBinaryTree(preOrder + i + 1, inOrder + i + 1, length - i - 1);//preOrder + i + 1就到了前序遍历中3的位置；inOrder + i + 1也到了前序遍历中3的位置

    return newNode;
}

// 中序遍历输出二叉树
void inorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inorderTraversal(root->left);
    printf("%c ", root->data);
    inorderTraversal(root->right);
}

int main() {
    char preOrder[] = {'A','B','D','E','C','F','G'};
    char inOrder[] = {'D','B','E','A','F','C','G'};
    int length = sizeof(preOrder)/sizeof(char);

    // 重构二叉树
    TreeNode *root = rebuildBinaryTree(preOrder, inOrder, length);

    // 中序遍历输出二叉树
    printf("Inorder Traversal of the rebuilt binary tree: ");
    inorderTraversal(root);

    return 0;
}

判断一棵二叉树是不是二叉排序树

#include<stdio.h>
#include<stdlib.h>

//定义二叉树节点结构体
struct Node
{
    int data;
    struct Node *left, *right;
};

//新建节点函数
struct Node* newNode(int value)
{
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = value;
    node->left = node->right = NULL;
    return(node);
}

//判断一颗二叉树是否为排序树
int isBST(struct Node* node)
{
    if (node == NULL)
        return 1;

    //判断左子树
    if (node->left != NULL && node->left->data > node->data)
        return 0;

    //判断右子树
    if (node->right != NULL && node->right->data < node->data)
        return 0;

    //递归判断左右子树本身是否为排序树
    if (!isBST(node->left) || !isBST(node->right))
        return 0;

    //如果以上条件都满足，则返回1，即是排序树
    return 1;
}

//主函数
int main()
{
    //创建一颗二叉树，手动输入节点数据
    struct Node *root = newNode(25);
    root->left = newNode(15);
    root->right = newNode(30);
    root->left->left = newNode(10);
    root->left->right = newNode(20);
    root->right->left = newNode(28);
    root->right->right = newNode(35);
    
    //调用isBST函数判断是否为排序

使用快排一次排序将数组中的大写字母和小写字母分开

#include <stdio.h>
// 快排函数
void quicksort(char arr[], int left, int right) {
    // left和right分别代表数组的左右端点
    if (left >= right) {
        return; // 递归结束条件
    }  
    // 选取基准元素
    char pivot = arr[left];
    int i = left, j = right;    
    // 将数组分成两部分，小于等于基准元素的放在左边，大于基准元素的放在右边
    while (i < j) {
        while (i < j && arr[j] <= pivot) {
            j--;
        }
        arr[i] = arr[j];
        while (i < j && arr[i] >= pivot) {
            i++;
        }
        arr[j] = arr[i];
    }   
    // 将基准元素放在正确的位置，并递归处理左右两部分
    arr[i] = pivot;
    quicksort(arr, left, i-1);
    quicksort(arr, i+1, right);
}
int main() {
    char arr[] = {'B', 'A', 'c', 'D', 'e', 'f'};
    int len = sizeof(arr) / sizeof(char); 
    printf("排序前的数组： ");
    for (int i = 0; i < len; i++) {
        printf("%c ", arr[i]);
    }
    quicksort(arr, 0, len-1);
    printf("\n排序后的数组（小写字母在前，大写字母在后）： ");
    for (int i = 0; i < len; i++) {
        printf("%c ", arr[i]);
    }
    return 0;
}

使用快排一次排序将数组中的零元素排在前，非零元素排在后，且排序前后非零元素的相对位置不变

void Partition(int A[], int p, int r){ //定义函数 Partition，该函数会对数组 A 进行划分操作，p 和 r 分别指示数组的起始下标和结束下标（注意这里是左闭右闭区间）
    int i=r+1; //定义指针 i，并将其初始化为 r+1，用来指向数组中第一个值为 0 的元素
    for(int j=r; j >= p;--j){ //遍历数组 A
        if(A[j] == 0) { //如果当前元素值为 0
            --i; //指针 i 前移一位
            int temp=A[i] ; //将 A[i] 的值存入临时变量 temp 中
            A[i]=A[j]; //将当前元素值赋给 A[i]
            A[j]=temp; //将 A[i] 原来的值赋给当前元素
        }
    }
}

void main() {
    int a[7]={0, 3, 0, 2, 1, 0，0}; //定义长度为 7 的数组 a，并初始化其元素
    Partition(a, 0, 6) ; //调用函数 Partition，对数组 a 进行划分操作
}

                                       0，3，0，2，1，0，0                             1，3，5，0，7，0，8

调试结果：i=6，j=4       0，3，0，2，0，0，1         i=6，j=6       1，3，5，0，7，0，8

                  i=5，j=3       0，3，0，0，0，2，1         i=5，j=4       1，3，5，0，0，7，8      

                  i=4，j=1       0，0，0，0，3，2，1         i=4，j=2       1，3，0，0，5，7，8

                                                                                   i=3，j=1       1，0，0，3，5，7，8

                                                                                   i=2，j=0       0，0，1，3，5，7，8 

我不要麦克风
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值