数据结构例题复习 张怀民

已于 2023-07-04 00:39:10 修改
阅读量32 收藏
点赞数
文章标签： 算法
于 2023-07-03 20:15:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TeAmo_Fa/article/details/131522916
版权 
//统计回文子串
#include <iostream>
#include <string>
using namespace std;

int countPalindromeSubstrings(const string& s) {
    int count = 0;
    int n = s.length();

    // 遍历字符串的每个字符作为回文中心
    for (int center = 0; center < n; center++) {
        // 情况1：以当前字符为回文中心的回文字符子串长度为奇数
        int left = center;
        int right = center;
        while (left >= 0 && right < n && s[left] == s[right]) {
            count++;
            left--;
            right++;
        }

        // 情况2：以当前字符及其右边字符为回文中心的回文字符子串长度为偶数
        left = center;
        right = center + 1;
        while (left >= 0 && right < n && s[left] == s[right]) {
            count++;
            left--;
            right++;
        }
    }

    return count;
}

int main() {
    string s;
    cout << "Enter a string: ";
    cin >> s;
    int count = countPalindromeSubstrings(s);
    cout << "Number of palindrome substrings: " << count << endl;
    system("pause");
    return 0;
}

//公约数
#include <iostream>
using namespace std;
int work(int a, int b)
{
    if (b == 0)
        return a;
    return work(b, a % b);
}
int process(int n)
{
    int count = 0;
    for (int i = 1; i < n; i++)
    {
        if (work(i, n) == 1)
            count++;
    }
    return count;
}
int main()
{
    int cn;
    cin >>cn;
    for (int i = 0; i < cn; i++)
    {
        int n;
        cin >> n;
        cout << process(n) << endl;
    }
    system("pause");
    return 0;
}
//约瑟夫
#include <iostream>
#include <queue>
using namespace std;

int main()
{
    int n, m;
    cin >> n >> m;
    queue<int> q;
    for (int i = 1; i <= n; i++)
    {
        q.push(i);
    }
    int c = 0;
    while (q.size()>1){
        c++;
        if(c%m==0)q.pop();
        else{
            q.push(q.front());
            q.pop();
        }
    }
    cout<<q.front();
        system("pause");
    return 0;
}
//进制
#include <iostream>
#include <stack>
#include<string>
using namespace std;
void work(int n,int r,stack<int>&s)
{
    while(n>0){
        s.push(n%r);
        n=n/r;
    }
}
int main()
{
    int n,r;
    cin>>n>>r;
    string letters = "ABCDEFGHIGKLMNOPQRSTUVWXYZ";
    stack<int> s;
    work(n,r,s);
    while(!s.empty()){
        if(s.top()<10)cout<<s.top();
        else cout<<letters[s.top()-10];
        s.pop();
    }

    system("pause");
    return 0;
}
//波兰
#include<iostream>
#include<string>
#include<vector>
using namespace std;
class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        string token = tokens.back();
        tokens.pop_back();
        
        if (token == "+" || token == "-" || token == "*" || token == "/") {
            int operand2 = evalRPN(tokens);
            int operand1 = evalRPN(tokens);
            
            if (token == "+") {
                return operand1 + operand2;
            } else if (token == "-") {
                return operand1 - operand2;
            } else if (token == "*") {
                return operand1 * operand2;
            } else if (token == "/") {
                return operand1 / operand2;
            }
        } else {
            return stoi(token);
        }
        
        return 0;
    }
};
int main(){
    vector<string> tokens = {"2", "1", "+", "3", "*"};
    Solution s;
    cout<<s.evalRPN(tokens)<<endl;
    system("pause");
    return 0;
}
//合并队列
#include <iostream>

using namespace std;

int main() {
    int N;
    cin >> N;
    int a[20000], b[200000];
    for (int i = 0; i < N; i++) {
        cin >> a[i];
    }
    for (int i = 0; i < N; i++) {
        cin >> b[i];
    }
    int pa = 0, pb = 0;
    while (pa < N && pb < N) {
        if (a[pa] < b[pb]) {
            cout << a[pa++] << " ";
        } else {
            cout << b[pb++] << " ";
        }
    }
    if (pa + pb != 2 * N) {
        if (pa == N) {
            for (int i = pb; i < N; i++) {
                cout << b[i] << " ";
            }
        } else {
            for (int i = pa; i < N; i++) {
                cout << a[i] << " ";
            }
        }
    }

    return 0;
}
//子串个数
#include <iostream>
#include <string>

using namespace std;

int main() {
    string s;
    while (cin >> s) {
        int len = s.size();
        cout << len * (len + 1) / 2 + 1 << "\n";
    }

    return 0;
}
//模式串
#include <iostream>
#include <string>

using namespace std;

int findPattern(const string& target, const string& pattern) {
    int n = target.length();
    int m = pattern.length();

    for (int i = 0; i <= n - m; i++) {
        int j;
        for (j = 0; j < m; j++) {
            if (target[i + j] != pattern[j]) {
                break;
            }
        }
        if (j == m) {
            return i + 1;
        }
    }

    return 0;
}

int main() {
    string target, pattern;
    getline(cin, target);
    getline(cin, pattern);

    int position = findPattern(target, pattern);
    cout << position << endl;

    return 0;
}
//螺旋
#include <iostream>
#include <vector>

using namespace std;

void generateSpiralMatrix(int N) {
    vector<vector<int>> matrix(N, vector<int>(N));
    int num = 1;

    int topRow = 0, bottomRow = N - 1, leftCol = 0, rightCol = N - 1;

    while (num <= N * N) {
        for (int i = leftCol; i <= rightCol; i++) {
            matrix[topRow][i] = num++;
        }
        topRow++;

        for (int i = topRow; i <= bottomRow; i++) {
            matrix[i][rightCol] = num++;
        }
        rightCol--;

        for (int i = rightCol; i >= leftCol; i--) {
            matrix[bottomRow][i] = num++;
        }
        bottomRow--;

        for (int i = bottomRow; i >= topRow; i--) {
            matrix[i][leftCol] = num++;
        }
        leftCol++;
    }

    // Output the spiral matrix
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    int N;
    cin >> N;

    generateSpiralMatrix(N);

    return 0;
}
//汉诺塔
#include <iostream>
using namespace std;
void moveDisk(int n, char source, char destination)
{
    cout << "Move disk " << n << " from " << source << " to " << destination << endl;
}
void hanoi(int n, char source, char auxiliary, char destination)
{
    if (n == 1)
    {
        moveDisk(n, source, destination);
    }
    else
    {
        hanoi(n - 1, source, destination, auxiliary);
        moveDisk(n, source, destination);
        hanoi(n - 1, auxiliary, source, destination);
    }
}

int main()
{
    int numDisks;
    cout << "Enter the number of disks: ";
    cin >> numDisks;

    hanoi(numDisks, 'A', 'B', 'C');

    return 0;
}
//dfs
#include<bits/stdc++.h>
using namespace std;
int mp[101][101];
bool f[101]={0};
int i,n,m; 
void dfs(int x)
{
    cout<<x<<" ";
    for(int i=1;i<=m;i++)
    {
        if(mp[x][i]&&f[i]==0)
        {
            f[i]=1;
            dfs(i);
             
        }
    }
}
int main()
{
//  int m,n;
    cin>>m>>n;
    int a,b;
    for(int i=1;i<=n;i++)
    {
        cin>>a>>b;
        mp[a][b]=1;
        mp[b][a]=1;
    }
    dfs(0);
}
//堆
#include<bits/stdc++.h>
using namespace std;
void xgd(int b[],int k,int x)
{
    b[0]=b[k];
    for(int i=2*k;i<=x;i=i*2)
    {
        if(i<x&&b[i]>b[i+1])
        {
            i++;
        }
        if(b[0]<=b[i]) break;
        else{
            b[k]=b[i];
            k=i;
        }}
        b[k]=b[0];
     
}
void creat(int b[],int l)
{
    for(int i=l/2;i>0;i--)
    {
        xgd(b,i,l);
    }
}
int main()
{
    int n;
    cin>>n;
    int l=0;
    int a[n];
    for(int i=1;i<=n;i++)
    {
      cin>>a[i];
    }
    creat(a,n);
    for(int i=1;i<=n;i++)
    {
        cout<<a[i]<<" ";
    }
     
}
// 查找次数
#include<bits/stdc++.h>
using namespace std;
int n;
int a[1001];
int f(int x)
{
    int t=n,m=0,r=1,sum=0,f=0;
    while(t>=r)
    {
        m=((t-r)/2)+r;
        if(a[m]>x)
        {
            t=m-1;
            if(t!=r)
            sum++;
        }
        else if(a[m]<x){
         
            r=m+1;
            if(t!=r)
            sum++;
        }
        else{
            sum++;
            return sum;
        }
    }
    return -1;
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    int x,p=0;
    cin>>x;
    p=f(x);
    if(p==-1) cout<<"NO";
    else    cout<<p;
}
//map
#include<vector>
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
struct stu
{
	int learn_num;
	string name;
	int seat_num;
};
int main()
{
	vector<stu>vec;
	stu a;
	int n, learn_num, seat_num, index;
	string name;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> learn_num;
		a.learn_num = learn_num;
		cin >> name;
		a.name = name;
		cin >> seat_num;
		a.seat_num = seat_num;
		vec.push_back(a);
	}
	cin >> index;
	for (int i = 0; i < n; i++)
	{
		if (vec[i].learn_num == index)
		{
			cout << vec[i].name << " ";
			cout << vec[i].seat_num << endl;
			break;
		}
	}
}
//最小生成树
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct edge
{
    int weight;
    edge(int weight) : weight(weight) {}
};
void PrimMST(vector<vector<edge>> &g)
{
    vector<int> distance(g.size(), INT_MAX);
    vector<bool> inMST(g.size(),0);
    for (int i = 1; i < g.size(); i++)
    {
        if (g[0][i].weight != 0)
            distance[i] = g[0][i].weight;
    }
    distance[0] = 0;  
    inMST[0]=true;
   for (int i = 1; i < g.size(); i++)
    {
        int mindis = INT_MAX;
        int minindex = -1;

        for (int j = 0; j < g.size(); j++)
        {
            if (!inMST[j] && distance[j] < mindis)
            {
                mindis = distance[j];
                minindex = j;
            }
        }

        inMST[minindex] = true;

        for (int j = 0; j < g.size(); j++)
        {
            if (!inMST[j] && g[minindex][j].weight != 0 && g[minindex][j].weight < distance[j])
                distance[j] = g[minindex][j].weight;
        }
    }

    int sum = 0;
    for (int i = 0; i < g.size(); i++)
    {
        sum += distance[i];
    }
    cout << sum <<endl;
}

int main()
{
    int n;
    cin >> n;
    vector<vector<edge>> graph(n);
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            int weight;
            cin >> weight;
            graph[i].push_back(edge(weight));
        }
    }
    PrimMST(graph);
    system("pause");
    return 0;
}
// 最短路径
#include <iostream>
using namespace std;

const int MAXV = 100; // 最大顶点数
const int INF = 9999; // 表示无穷大的值

class MatGraph {
public:
    int n; // 顶点数量
    int edges[MAXV][MAXV]; // 邻接矩阵

    MatGraph(int numVertices) {
        n = numVertices;
        initializeGraph();
    }

    void addEdge(int from, int to, int weight) {
        if (from >= 0 && from < n && to >= 0 && to < n) {
            edges[from][to] = weight;
        }
    }
private:
    void initializeGraph() {
        for (int i = 0; i < MAXV; i++) {
            for (int j = 0; j < MAXV; j++) {
                edges[i][j] = 0; // 初始化邻接矩阵，所有元素置为0
            }
        }
    }
};

void Dijkstra(MatGraph& g, int v) {
    int dist[MAXV];
    int path[MAXV];
    int S[MAXV];
    for (int i = 0; i < g.n; i++) {
        dist[i] = g.edges[v][i]; // 距离初始化
        S[i] = 0; // 将S置空
        if (g.edges[v][i] != 0 && g.edges[v][i] < INF) {
            path[i] = v; // 当v到i有边时，置i的前驱顶点为v
        }
        else {
            path[i] = -1; // 当v到i没边时，置i的前驱顶点为-1
        }
    }
    S[v] = 1; // 将源点编号v放入S中
    int mindis, u = -1;
    for (int i = 0; i < g.n - 1; i++) {
        mindis = INF; // mindis置最小距离初值
        for (int j = 0; j < g.n; j++) {
            if (S[j] == 0 && dist[j] < mindis) {
                u = j;
                mindis = dist[j];
            }
        }
        S[u] = 1; // 将顶点u加入S中
        for (int j = 0; j < g.n; j++) {
            if (S[j] == 0) {
                if (g.edges[u][j] < INF && dist[u] + g.edges[u][j] < dist[j]) {
                    dist[j] = dist[u] + g.edges[u][j];
                    path[j] = u;
                }
            }
        }
    }
}

int main() {
    
    return 0;
}

//快速排序
#include<iostream>
#include<vector>
using namespace std;

void quicksort(vector<int> &v,int i,int j){
	if(i>=j)return;
	int left = i,right = j;
	int key = left;
	while(left<right){

		while(v[right]>=v[key]&&left<right){
			right--;
		}
		while(v[left]<=v[key]&&left<right){
			left++;
		}
		swap(v[left],v[right]);
	}
	swap(v[key],v[left]);
	quicksort(v,i,left-1);
	quicksort(v,left+1,j);
}

void quicksort1(vector<int> &v,int i,int j){
	if(i>=j)return;
	int left=i,right=j;
	int key=left;
	int tmp=v[key];
	while(left<right){
		while(v[right]>=tmp&&left<right){
			right--;
		}
		v[key]=v[right];
		key=right;
		while(v[left]<=tmp&&left<right){
			left++;
		}
		v[key]=v[left];
		key=left;
	}
	v[left]=tmp;
	quicksort1(v,i,left-1);
	quicksort(v,left+1,j);
}
int main(){
	vector<int> v = {5,6,3,5,8,9};
	quicksort1(v,0,v.size()-1);
	for(auto it:v){
		cout<<it<<" ";
	}
    system("pause");
	return 0;
}
//生成二叉树
#include<iostream>
#include<string>
using namespace std;
struct BTNode{
    char data;
    BTNode *lchild,*rchild;
    BTNode(char x):data(x),lchild(NULL),rchild(NULL){}
};
BTNode *build11(string pre, int i, string mid, int j, int n)
{
    if(n<=0)return NULL;
    char root_data = pre[i];
    BTNode *root = new BTNode(root_data);
    int p = j;
    while(mid[p]!=root_data)p++;
    int num = p-j;
    root->lchild = build11(pre, i+1, mid, j, num);
    root->rchild = build11(pre, i+num+1, mid, p+1, n-num-1);
    return root;
}

BTNode *build21(string &in,int i,string &post,int j,int n){
    if(n<=0)return NULL;
    char data = post[j+n-1];
    int p=i;
    while(in[p]!=data)p++;
    int num = p-i;
    BTNode *root = new BTNode(data);
    root->lchild = build21(in,i,post,j,num);
    root->rchild = build21(in,p+1,post,j+num,n-num-1);
    return root;
}
void display(BTNode *root){
    if(root==NULL)return;
    cout<<root->data;
    display(root->lchild);
    display(root->rchild);
}
int main(){
    string in,post;
    char order;
    cin>>in>>post>>order;
    BTNode *root=build21(in,0,post,0,in.size());
    display(root);
    system("pause");
    return 0;
}
// 根据前序和后序构建二叉树
#include <iostream>
#include <vector>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(NULL), right(NULL) {}
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};
void display(TreeNode *root)
{
    if (root == NULL)
        return;
    display(root->left);
    cout << root->val << ',';
    display(root->right);
}

class Solution
{
public:
    TreeNode *constructFromPrePost(vector<int> &preorder, vector<int> &postorder)
    {
        return helper(preorder, 0, postorder, 0, preorder.size());
    }
    TreeNode *helper(vector<int> &preorder, int i, vector<int> &postorder, int j, int n)
    {
        if (n <= 0)
            return NULL;
        TreeNode *node = new TreeNode(preorder[i]);
        int index = j;
        while (postorder[index] != preorder[i + 1])
        {
            index++;
        }
        node->left = helper(preorder, i + 1, postorder, j, index - j);
        node->right = helper(preorder, i + index - j + 1, postorder, index + 1, n - index- j - 1);
        return node;
    }   
};
int main()
{
    vector<int> preorder = {1, 2, 4, 5, 3, 6, 7};
    vector<int> postorder = {4, 5, 2, 6, 7, 3, 1};

    Solution s;
    TreeNode *root = s.constructFromPrePost(preorder, postorder);

    display(root);
    system("pause");
    return 0;
}

TeAmo_Fa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构最短路径例题_数据结构8——最短路径
weixin_33416900的博客
12-23 3122
一、最短路径最短路径：从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径。求最短路径的四个算法如下：二、算法概述【Dijkstra算法】单源最短路：从单个源点出发，到所有结点的最短路作用：计算正权图上的单源最短路。图类型：有向图、无向图。限制：边权为正。【Bellman-Ford算法】事实1：当负权存在时，连最短路都不一定存在。事实2：如果最短路存在，一定存在一个不含环的最短路...
数据结构期末复习例题
01-06
一共五页，包括数据结构总结，图的总结，以及(1)直接插入排序(2)希尔排序(3)冒泡排序(4)快速排序(5)简单选择排序(6)堆排序(7)归并排序(8)基数排序的例子。
数据结构期末复习（C语言版）
2301_77523019的博客
01-15 2749
线性表、栈和队列、串、数组和广义表、树、图的概念和常见题型，看完这篇文章，你的数据结构期末考试成绩必然在60往上，如果不够60分，你来找我补，我爱说实话。
专升本数据结构复习
emmmheng的博客
03-03 1万+
数据结构知识点总汇 主要参考书目： 程海英老师的《数据结构（C语言版）》教材 严蔚敏，李冬梅，吴伟民．《数据结构（C语言版）》 说明：这是本人专升本上岸一年后写的，本篇包含知识点和例题总结。因为是当时自己手码的，所以知识点有冗余和顺序错位。如果发现有错误之处，欢迎评论区留言，看到后及时改正，谢谢！最后祝大家好好学习，积极向上，早日上岸！ ① 数据结构(逻辑结构)其4类基本结构：集合、线性结构、树形结构、图状结构 和 网状结构。 ② 物理结构(存储结构)其4种存储结构：顺序存储结构、链式存储结构、索引存储
数据结构期末复习笔记
zyw2002的博客
11-28 4783
背景：2021春季期末与好友多喝岩浆xx共同整理的复习笔记。 主要参考了老师的课件, 还有一些博客。(万分感谢好友，老师，还有乐于分享的博主们！) github 下载地址：复习笔记pdf+图解数据结构doc 百度网盘下载地址：链接：复习笔记pdf 提取码：m6yn 感想：一般来说大学应试的数据结构考的都是基本的知识点，不会特别难，但真正的学习数据结构光靠应试的复习是远远不够的。说实话我第一遍听课的时候也觉的很多知识似懂非懂，但是在期末考试提前很久就开始自己复习了，通过画图把每一个算法都去弄懂，尤其像KMP.
数据结构（严蔚敏版）与算法的实现（含全部代码）
关注网络安全、云原生安全
09-13 13万+
目录 基础 c/c++ 代码优化及常见错误 c语言位运算的妙用-程序优化 c/c++进制转换方法汇总（含全部代码） 二进制数-北邮2012研究生复试 质因子分解 除树和图外的数据结构可以使用STL: C++ STL的使用 数据结构 线性表 顺序表 循环左移（2010联考真题） 单链表 单链表相邻结点逆置(2019北邮考研真...
【数据结构】 二叉树及其三种遍历
热门推荐
Hello World!
02-21 21万+
二叉树（Binary Tree）一种重要的树形结构，其每个节点最多只能有两棵子树，通常称为左子树和右子树，且子树有左右之分，其次序不能颠倒。二叉树是n个有限元素的集合，该集合或者为空（称为空二叉树），或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。
【2023考研】数据结构常考应用典型例题（含真题）
qq_34438969的博客
09-02 2万+
本文针对《数据结构》，博主花了几天时间列出了考研常考的应用题型，讲解详细，方便复习。各类题型所涉及的知识点包括但不限于队列、二叉排序树、平衡二叉树、哈夫曼树及哈夫曼编码、图的存储、最小生成树、关键路径、排序算法等等。（标题即为考点）。例题出自408真题，以及各高校的自主命题（含王道解析）。（后期会继续补充题目）目录前言一、队列二、树（一）二叉排序树（二）平衡二叉树（三）森林与二叉树的转换（四）哈夫曼树及哈夫曼编码三、图（一）邻接表及邻接矩阵、最小生成树（二）DFS和BFS（图的遍历）
数据结构——拓扑排序经典例题
aaHua_
07-21 4477
定义： 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排...
【数据结构】知识点总复习
karshey的博客
06-23 1万+
考试范围 重点：第2、5、6、7、8章。 略考：第1，3章。 第四章不考。 不考的其他内容： 广义表、KMP、线索化二叉树、十字链表、邻接多重表、拓扑排序、关键路径、平衡二叉树，B树，B+树，分块查找，希尔排序，折半插入，基数排序，外部排序。 复习指南：课件，PTA。PTA所有主观题和课本后的所有习题。 本篇是课件的总结。可能不全。 第一章（略考） 本章重点：数据结构相关名词术语的含义。难点：时间复杂度的估算。 数据：是客观事物的符号表示。能被输入到计算机中被程序处理的符号的总称。 数据元素：也称顶点，结点
数据结构期末复习-二叉排序树的构造
博客地址 www.sec0nd.top
06-20 1万+
二叉排序树 定义： 二叉排序树或者是一棵空树；或者是具有如下特性的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于根结点的值； 它的左、右子树也都分别是二叉排序树。 (左小右大) 存储结构 通常，取二叉链表作为二叉排序树的存储结构 typedef struct BiTNode { // 结点结构 TElemType data; struct BiTNode *lchild, *rchild; // 左右孩子指针 } BiTNode, *
数据结构例题及参考答案
02-15
本资料集“数据结构例题及参考答案”旨在帮助学习者深入理解并掌握各种数据结构及其应用。下面将详细阐述数据结构的主要类型、重要概念以及相关例题解题策略。 一、线性数据结构 1. 数组：数组是最基本的数据结构，...
数据结构1800道例题与答案
12-23
"数据结构1800道例题与答案"是一个宝贵的资源，包含了大量练习题和解决方案，可以帮助学习者深入理解和掌握数据结构的基本概念、算法和设计技巧。 首先，我们要明白数据结构主要分为四大类：线性结构（如数组、链表...
数据结构c语言期末复习资料.rar
12-21
这份“数据结构C语言期末复习资料”显然是为了帮助学生准备关于这个主题的期末考试而设计的。 在数据结构的学习中，主要会接触到以下关键概念： 1. **数组**：最基础的数据结构，可以看作是一系列相同类型元素的...
数据结构与算法概念和例题详解
03-30
本资料集《数据结构与算法概念和例题详解》专注于这两个核心概念，特别针对蓝桥杯竞赛进行了讲解，旨在帮助学习者掌握其精髓，并提升实际应用能力。 首先，我们来探讨数据结构。数据结构是组织和存储数据的方式，它...
【18】输出字符菱形
2301_78786609的博客
07-19 375
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 257
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 318
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
2024.7.19 刷题总结
最新发布
TheJustice_的博客
07-19 240
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值