数据结构部分题（b站印度老哥）

已于 2024-05-21 20:39:31 修改
阅读量742 收藏 19
点赞数 25
文章标签： 数据结构 算法 c++
于 2024-05-20 22:40:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ATRI3535444976/article/details/139076532
版权

因为跟完了才想补这个博客emm，就倒叙吧，而且估计前面的我也不一定还记得hh 。附个bv吧：

【【强烈推荐】深入浅出数据结构 - 顶尖程序员图文讲解 - UP主翻译校对 (已完结)】 https://www.bilibili.com/video/BV1Fv4y1f7T1/?share_source=copy_web&vd_source=91f3feb21aaf57583c0f398bc469d207

p37（二叉搜索树的中序后续节点）24.5.19

还是比较难的吧（，看图来理解会好点。如果没有右子树，就要遍历了，写一个祖先和后续，依次遍历下来，这种情况要画图好理解点，我也是边看边写的hh

#include <iostream>
#include<bits/stdc++.h>
using namespace std;

struct node
{
    int data;
    node* left;
    node* right;
};


node* find(node* root, int data)
{
    if (root == NULL) return NULL;
    else if (root->data == data) return root;
    else if (root->data < data) return find(root->right, data);
    else return find(root->left, data);
}

struct node* findmin(node* root)
{
    if (root == NULL) return NULL;
    while (root->left != NULL)
        root = root->left;
    return root;
}

struct node* gethouxu(node* root, int data)
{
    struct node* current = find(root, data);
    if (current == NULL) return current;
    if (current->right != NULL) return findmin(current->right);
    else {
        node* houxu = NULL;
        node* zu = root;
        while (zu != NULL)
        {
            if (current->data < zu->data) {
                houxu = zu;
                zu = zu->left;
            }
            else {
                zu = zu->right;
            }
            return houxu;
        }
    }
}

void inorder(node* root)
{
    if (root == NULL) return;
    inorder(root->left);
    cout << root->data << endl;
    inorder(root->right);
}

node* insert(node* root, int data)
{
    if (root == NULL)
    {
        root = new node();
        root->data = data;
        root->left = root->right = NULL;
    }
    else if (data < root->data) root->left = insert(root->left, data);
    else root->right = insert(root->right, data);
    return root;
}

int main()
{
    node* root = NULL;
    root = insert(root, 5);
    root = insert(root, 10);
    root = insert(root, 3);
    root = insert(root, 4);
    root = insert(root, 1);
    root = insert(root, 11);
    cout << "inorder:";
    inorder(root);
    cout << endl;
    node* houxu = gethouxu(root, 1);
    if (houxu == NULL) cout << "ji" << endl;
    else cout<< "win";
    return 0;
}

p36 （二叉搜索树的删除）24.5.19

这主要就是分有无右子树吧，如果有，就找右子树的min，就可以保证改后符合规则了。

        //p36 删除
struct node
{
    int data;
    struct node* left;
    struct node* right;
};

node* findmin(node* root)
{
    while (root->left != NULL) root = root->left;
    return root;
}

struct node* Delete(node* root, int data)
{
    if (root == NULL) return root;

    else if (data < root->data) root->left= Delete(root->left, data);
    else if (data > root->data) root->right= Delete(root->right, data);
    else {

        if (root->left == NULL && root->right == NULL)
        {
            delete root;
            root = NULL;
        }

        else if (root->left == NULL)
        {
            struct node* temp = root;
            root = root->right;
            delete temp;
        }
        else if (root->right == NULL)
        {
            struct node* temp = root;
            root = root->left;
            delete temp;
        }

        else {
            struct node* temp = findmin(root->right);
            root->data = temp->data;
            root->right = Delete(root->right,temp->data);
        }
        return root;

    }
}


void inorder(struct node* root)
{
    if (root == NULL) return;
    inorder(root->left);
    cout << root->data<<" ";
    inorder(root->right);

}

node* insert(node* root, int data)
{
    if (root == NULL)
    {
        root = new node();
        root->data = data;
        root->left = root->right = NULL;
    }
    else if (root->data > data) root->left= insert(root->left, data);
    else  root->right= insert(root->right, data);

    return root;
}

int main()
{
    node* root = NULL;
    root = insert(root, 5); root = insert(root, 10);

    root = insert(root, 3); root = insert(root, 4);

    root =insert(root, 1); root = insert(root, 11);
    root = Delete(root, 5);
    inorder(root);

}
 

p35 （判断是否为二叉搜索树）24.5.18

这个递归，蟀

 //          判断是否为二叉树
struct node
{
    int data;
    node* left;
    node* right;
    node(int x) : data(x), left(NULL), right(NULL) {}
};

bool pd(node*root,int min,int max)
{
    if (root == NULL) return true;
    if (root->data<max &&
        root->data>min &&
        pd(root->left, min, root->data) &&
        pd(root->right, root->data, max)) {
        return true;
    }
    else return false;
}

bool ispd(node*root)
{
    return pd(root, INT_MIN, INT_MAX);
}

int main() {
    node* root = new node(2);
    root->left = new node(1);
    root->right = new node(3);

    if (ispd(root))
        cout << "The tree is a valid Binary Search Tree.\n";
    else
        cout << "The tree is not a valid Binary Search Tree.\n";

    return 0;
}

p33，p34（二叉树层次遍历（广度优先,前中后序））24.5.18

//                 二叉树层次遍历（广度优先,前序，中序，后序）
struct node
{
    char data;
    struct node* left;
    struct node* right;
};

void levelorder(node* root)
{
    queue<node*>q;
    if (root == NULL)
    {
        return;
    }
    q.push(root);
    while (!q.empty())
    {
        node* temp = q.front();
        cout << temp->data << endl;
        if (temp->left != NULL) { q.push(temp->left); }
        if (temp->right != NULL) { q.push(temp->right); }
        q.pop();
    }
}

node* insert(node* root, char data)
{
    if (root == NULL)
    {

        root = new node();
        root->data = data;
        root->left = root->right = NULL;
    }
    else if (data <= root->data)
    {
        root->left = insert(root->left, data);

    }
    else {
        root->right = insert(root->right, data);
    }
    return root;
    delete(root);
}
void preorder(struct node*root)
{
    if (root == NULL) {
        return;
    }
    cout << root->data << endl;
    preorder(root->left);
    preorder(root->right);

}
void inorder(struct node* root)
{
    if (root == NULL) {
        return;
    }
    inorder(root->left);
    cout << root->data << endl;
    inorder(root->right);
}

void postorder(struct node* root)
{
    if (root == NULL) {
        return;
    }
    postorder(root->left);
    postorder(root->right);
    cout << root->data << endl;
}

/*
                 m
               /  \
              b    q
             /\     \
            a  c     z 

*/


int main()
{
    node* root = NULL;
    root = insert(root, 'M'); root = insert(root, 'B');
    root = insert(root, 'Q'); root = insert(root, 'Z');
    root = insert(root, 'A'); root = insert(root, 'C');
    cout << "pre:" << endl;
    preorder(root);
    cout << endl;
    cout << "in:" << endl;
    inorder(root);
    cout << endl;
    cout << "post:" << endl;
    postorder(root);
    cout << endl;
    return 0;
}

p30，31（二叉树的高度，最值，查找） 24.5.17

//findheight不算熟，用了max（高度从0开始，所以加一）

struct bstnode {
    int data;
    bstnode* left;
    bstnode* right;

};

bstnode* getnewnode(int data) {
    bstnode* newnode = new bstnode();
    newnode->data = data;
    newnode->left = newnode->right = NULL;
    return newnode;
}

bstnode* insert(bstnode*root,int data)
{
    if (root == NULL) {
        root = getnewnode(data);

    }
    else if (data <= root->data)
    {
        root->left = insert(root->left, data);

    }
    else {
        root->right = insert(root->right, data);
    }
    return root;
    delete(root);
}

bool search(bstnode* root, int data)
{
    if (root == NULL)
    {
        return false;
    }
    else if (root->data == data)
    {
        return true;
    }
    else if (data <= root->data)
    {
        return search(root->left, data);
    }
    else
    {
        return search(root->right, data);
    }
}

//                               迭代版本
int max_a(struct bstnode* root)
{
    struct bstnode* temp = root;
    if (temp == NULL)
    {
        cout << "kong" << endl;
        return -1;
    }
    while (temp->right != NULL)
    {
        temp = temp->right;
    }
    return temp->data;
}

//                                     递归版本
int max_b(struct bstnode* root)
{
    struct bstnode* temp = root;
    if (temp == NULL)
    {
        cout << "ji" << endl;
        return -1;
    }
    else if (temp->right == NULL)
    {
        return temp->data;
    }
    return max_b(temp->right);
}

int findheight(struct bstnode* root)
{
    if (root == NULL)
    {
        return -1;
    }
    return max(findheight(root->left), findheight(root->right)) + 1;

}


int main()
{
    bstnode* root = NULL;
    root = insert(root, 10);
    root = insert(root, 20);
    root = insert(root, 30);
    root = insert(root, 40);
    root = insert(root, 50);
    root = insert(root, 60);
    cout << "max:"<<max_b(root) << endl;
    cout << "高度是" << findheight(root) << endl;
    if (search(root,10) == true)
    {
        cout << "找到10咯" << endl;
    }
    else
        cout << "没找到。。" << endl;
    return 0;
}

ps:到此二叉树就没了，然后是队列和栈了

p24（用链表实现队列） 24.5.16

实现也不算难吧，还是不熟练，多看看

#include <iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};

struct node* front = NULL;
struct node* rear = NULL;
void enqueue(int x)
{
    struct node* temp = (struct node*)malloc(sizeof(struct node));
    temp->data = x;
    temp->next = NULL;

    if (front ==NULL && rear == NULL)
    {
        front = rear = temp;
        return;
    }
    rear->next = temp;
    rear = temp;
}

void dequeue()
{
    if (front == NULL)
    {
        printf("queue is empty\n");
            return;
    }
    struct node* temp = front;
    if (front == rear)
    {
        front = rear = NULL;

    }
    else {
        front = front->next;
    }
    free(temp);
}

int Front()
{
    if (front == NULL)
    {
        printf("queue is empty\n");
        return -1;
    }
    return front->data;

}

void print()
{
    struct node* temp = front;
    while (temp != NULL)
    {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

int main() {
    enqueue(2); print();

    enqueue(4);print();

    enqueue(6); print();

    dequeue(); print();

    enqueue(8); print();

} 

p23 （用循环数组实现队列） 24.5.16
 

还是挺难的，用max_size的时机，对于没用过循环数组来说，还是多看看

#include <iostream>
using namespace std;

#define MAX_SIZE 101 

class Queue {
private:
    int A[MAX_SIZE];
    int front, rear;

public:
    Queue() {
        front = -1;
        rear = -1;
    }

    bool IsEmpty() {
        return (front == -1 && rear == -1);
    }

    bool IsFull() {
        return (rear + 1) % MAX_SIZE == front;
    }

    void Enqueue(int x) {
        cout << "Enqueuing " << x << " \n";
        if (IsFull()) {
            cout << "Error: Queue is Full\n";
            return;
        }
        if (IsEmpty()) {
            front = rear = 0;
        }
        else {
            rear = (rear + 1) % MAX_SIZE;
        }
        A[rear] = x;
    }

    void Dequeue() {
        cout << "Dequeuing \n";
        if (IsEmpty()) {
            cout << "Error: Queue is Empty\n";
            return;
        }

        else if (front == rear) {
            rear = front = -1;
        }

        else {
            front = (front + 1) % MAX_SIZE;
        }
    }

    void Print() {
        int count = (rear + MAX_SIZE - front) % MAX_SIZE ;
        cout << "Queue: ";
        for (int i = 0; i <= count; i++) {
            int index = (front + i) % MAX_SIZE;
            cout << A[index] << " ";
        }
        cout << "\n";
    }
};

int main() {
    Queue Q;
    Q.Enqueue(2); Q.Print();
    Q.Enqueue(4); Q.Print();
    Q.Enqueue(6); Q.Print();
    Q.Dequeue(); Q.Print();
    Q.Enqueue(8); Q.Print();
    return 0;
}

p20，21用栈表示前缀后缀表达式（当时没写，水过去吧...

p18 (栈：检查括号的匹配性） 24.5.14

//数据结构p18 符号匹配
bool A(char a, char b)
{
    if (a == '(' && b==')') return true;
    if (a == '[' && b == ']') return true;
    if (a == '{' && b == '}') return true;
    return false;
}

bool B(string a)
{
    stack<char>s;
    for (int i = 0; i < a.size(); i++)
    {
        if (a[i] == '(' || a[i] == '[' || a[i] == '{')
        {
            s.push(a[i]);

        }
        if (a[i] == ')' || a[i] == ']' || a[i] == '}')
        {
            if (A(s.top(), a[i]))
            {
                s.pop();
                return true;
            }

        }
    }
    if (s.empty())
    {
        return false;
}
    return false;
}

int main()

{
    string expression;
    cout << "Enter an expression:  "; 
    cin >> expression;
    if (B(expression))
        cout << "Balanced\n";
    else
        cout << "Not Balanced\n";

}

p17（双链表实现，反转链表） 24.5.13

//                  双链表实现
struct node {
    int data;
    struct node* next;
    struct node* prev;
};

struct node* head;

struct node* getnewnode(int x) {
    struct node* newnode = new node;
    newnode->data = x;
    newnode->prev = NULL;
    newnode->next = NULL;
    return newnode;
}


void  insertathead(int x)
{
    struct node * newnode = getnewnode(x);
    if (head == NULL)
    {
        head = newnode;
        return;
    }
    head->prev = newnode;
    newnode->next = head;
    head = newnode;

}

void insertatTail(int x)
{
    struct node* newnode = getnewnode(x);
    struct node* temp = head;

    if (head == NULL)
    {
        head = newnode;
        return;
    }

    while (temp->next != NULL)
    {
        temp = temp->next;
    }

 
    temp->next = newnode;
    newnode->prev = temp;
}


void print() {
    struct node* temp = head;
    cout << "forward: ";
    while (temp != NULL) {
        cout << temp->data << " ";
        temp = temp->next;
    }
    cout << endl;
}

void reverprint() {
    struct node* temp = head;
    if (temp == NULL) return;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    cout << "reverse: ";
    while (temp != NULL) {
        cout << temp->data << " ";
        temp = temp->prev;
    }
    cout << endl;
}

void fanzhuan()
{
    if (head == NULL)
    {
        return;
    }
    stack<struct node*>s;
    node* temp = head;
    while (temp!=NULL)
    {
        s.push(temp);
        temp = temp->next;
    }
    temp = s.top();
    head = temp;
    s.pop();
    while(!s.empty())
    {
        temp->next = s.top();
        s.pop();
        temp = temp->next;
    }
}
int main() {
    head = NULL;
    insertathead(2);
    print();
    reverprint();

    insertathead(4);
    print();
    reverprint();

    insertathead(6);
    print();
    reverprint();

    return 0;
}

尾声：

剩下的就是链表基础了，就不赘述了，写出来的都要多看看hh，这套大概跟了2个月吧，还是坚持跟完了，虽然后面图的部分没练习吧hh，接下来就是慢慢刷算法题了

ATRI3535444976
关注
  • 25
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
印度小哥数据结构视频代码测试笔记
gzc0319的博客
02-27 947
看完发现没看懂，于是就去B站找文中提到的【如果要我说计算机专业最重要的三门课，我会说是《数据结构》、《算法》和《编译原理》。在我看来，能不能理解“递归”像是程序员的第一道门槛，而会不会写编译器则是第二道。我没翻墙，就用了评论里的别人整理的代码，修改了一点小错误，加了缩进，把部分C++代码改写为C代码。看完了咖喱味的数据结构，感觉很有收获，于是决定把视频中的代码也测试下，就有了这篇笔记。代码参考《计算机软件技术基础》徐士良 算法2.29和2.30。核心思想：从队头取出一个节点访问，将节点的子节点加入队尾。
（ 从零开始的数据结构生活）一、链表
m0_71432177的博客
08-25 725
现在，程序已经到达第n-1个节点，我们需要将 temp1 插入到第n个位置，只需要断开原来第n-1个节点至第n个节点的位置，然后将第n-1个节点连接 temp1 ，将 temp1 连接原来的第n个节点，现在我们的新链表诞生了， temp1 也在第n个节点上了。现在，程序已经到最后一个节点了，假设有n个节点，我们对其进行打印，然后返回第n-1个节点，打印，再返回第n-2个节点，打印，如此循环直至打印完第一个节点。接下来，我们需要让这个链表从 temp2 开始循环，循环(（n-2)-0)+1次,即n-1次；
（ 从零开始的数据结构生活 ）三、队列
m0_71432177的博客
08-30 385
定义：和栈大差不差，但也具有一定的限制——插入元素只能从队尾进行，而删除从另一端进行，即队头。操作：（1）Push/EnQueue：从队尾插入一个元素。（2）PoP/DeQueue :从队头删除一个元素。（3）Peek/front：简单地查看（返回）队列的头部元素。（4）IsEmpty：判断队列是否为空。（5）IsFull：如果队列有大小，检查队列是否已满。以上操作的时间复杂度都 为O(1)。......
（ 从零开始的数据结构生活 ）四、树
m0_71432177的博客
09-02 286
（1）树的定义：n=0时，为空树；n=1时，只有一个节点，称之为根；n>=2时，可以理解为含有 n 个节点 n−1 条边的连通图。
超级震撼！印度小哥总结的算法登顶GitHub热榜，已经刷爆10w星！
GitHub爱好者社区
07-20 435
点击上方“Github爱好者社区”，选择星标回复“资料”，获取小编整理的一份资料作者：GG哥来源：GitHub爱好者社区（github_shequ）这是GitHub爱好者社区第39篇...
印度小哥总结的算法登顶GitHub热榜
07-22 204
算法和数据结构是每个程序员必备的基础技能，也是面试必考的内容。几乎大厂在面试时，都会考察，比如下面这些常规操作 栈、队列、链表、数组、哈希表、 树 二叉树、字典树、平衡树、排序树、B树、B+树、R树、多路树、红黑树 排序算法 各种排序算法和时间复杂度 深度优先和广度优先搜索 全排列、贪心算法、KMP算法、hash算法、海量数据处理 今天为大家推荐的这两个项目，来自印度的一个老哥，他分别用Python和Java来实现了常用的所有算法，总星数加起来超10万星了！可以说在GitHub上非常受欢迎。 ——————
由浅入深理解C/C++指针-《4小时彻底掌握C指针》笔记
weixin_50640987的博客
01-10 2600
由浅入深理解C/C++指针-《4小时彻底掌握C指针》笔记 本文主要是笔者整理《4小时彻底掌握C指针》系列视频的笔记，该视频是印度人Harsha Suryanarayana（可惜老哥英年早逝）图文并茂讲解的指针教程，已被好心人翻译为中文视频。不同于一般的笔记，笔者希望本文能够独立成文，以便读者未看过视频也可以顺畅阅读。同时在文中已经添加本人的注解“笔者注”，作为本人理解方便大家阅读。 笔者C++功底有限，如有错误，欢迎指正。 第一节：指针基本介绍 变量在内存的存储 如图中右侧图形表示计算机内存（memory）
超级震撼！印度小哥总结的算法登顶GitHub热榜
07-22 274
算法和数据结构是每个程序员必备的基础技能，也是面试必考的内容。几乎大厂在面试时，都会考察，比如下面这些常规操作 栈、队列、链表、数组、哈希表、 树 二叉树、字典树、平衡树、排序树、B树、B+树、R树、多路树、红黑树 排序算法 各种排序算法和时间复杂度 深度优先和广度优先搜索 全排列、贪心算法、KMP算法、hash算法、海量数据处理 今天为大家推荐的这两个项目，来自印度的一个老哥，他分别用Python和Java来实现了常用的所有算法，总星数加起来超10万星了！可以说在GitHub上非常受欢迎。 比如你想了
邮件门的迷宫 希拉里邮件数据探索
weixin_33859844的博客
11-29 956
11月9日中午，不关心也不懂政治的我忽然非常感动，多少，我们在朋友圈的直播里见证了一个以一敌万的故事，这不是武侠小说，也不是好莱坞电影，而是2016年美国大选，几个黑客掀起的希拉里邮件门，多少让川普弯道超车，让看起来稳赢的希拉里最后黯然退场，黑客应该争取了关键的, 超过两位数的的支持率。 11月10日，美国著名的黑客Kim Dotcom在Twitter如...
印度小哥数据结构视频代码
02-27
本资源“印度小哥数据结构视频代码”聚焦于数据结构的实践应用，通过编程示例帮助学习者深入理解这些概念。UP主对内容进行了翻译和校对，确保了内容的准确性和易懂性。 首先，我们看到一个关于中缀表达式转后缀...
数据结构实验代码汉诺塔.rar
05-01
《数据结构实验：汉诺塔问题的代码实现》 数据结构是计算机科学中的核心课程，它探讨了如何高效地组织和操作数据。在本实验中，我们将深入探讨一个经典问题——汉诺塔（Hanoi Tower），并通过编程实现来加深对递归...
数据结构 汉诺塔问题课程设计.docx
12-05
汉诺塔问题是数据结构中一个经典的问题，本课程设计旨在解决汉诺塔问题，通过递归算法和栈的应用来实现盘子的移动。 汉诺塔问题的定义 汉诺塔问题是一个古老的印度传说，游戏规则是将大小不同的金盘按照由下至上由...
印度货币识别数据集每类100-300张图片不等
11-15
该数据集是一个专门针对印度货币的图像识别训练资源，包含了印度流通中的不同面值的纸币图片。数据集的构建旨在帮助开发和训练计算机视觉算法，特别是深度学习模型，以实现自动识别印度货币的能力。这样的技术在金融...
印度肝病患者记录数据集，从印度安得拉邦东北部收集的患者记录。.zip
02-26
标题中的“印度肝病患者记录数据集”表明这是一个与医疗领域相关的数据集，具体是关于印度，特别是安得拉邦东北部地区的肝病患者的临床记录。这个数据集可能包含了多种类型的肝病患者的信息，比如肝炎、脂肪肝、肝...
数据结构--树和二叉树的一些知识点总结
最新发布
weixin_68489989的博客
07-09 302
数据结构--树和二叉树的一些知识点总结
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 261
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
Redis教程(二十三)：Redis的底层数据结构
十三月的博客
07-09 27
Redis是一种高性能的key-value数据库，广泛用于缓存、消息队列、应用程序会话管理等领域。它之所以能提供高效的数据操作性能，很大程度上归功于其底层使用了多种优化过的数据结构来存储数据。
825 真题手写答案1
08-04
825 真题手写答案1

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值