算法笔记 12-19

最新推荐文章于 2024-08-27 12:22:52 发布
最新推荐文章于 2024-08-27 12:22:52 发布
阅读量731 收藏
点赞数
文章标签： 算法 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kudo_chitose/article/details/122022142
版权

1.二叉树的构建、遍历和完全二叉树的判断

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MaxSize 100

using namespace std;


typedef char ElemType;

typedef struct node {
    ElemType data;
    struct node* lchild;
    struct node* rchild;
}BTNode;

//实例化二叉树
void BT_Create(BTNode*& b, const char* str) {
    BTNode* St[MaxSize], * p=NULL;
    int top = -1 , k , j = 0;
    char ch;
    b = NULL;
    ch = str[j];
    //str未结束时循环
    while (ch != '\0') {
        switch (ch) {
        case '(':top++; St[top] = p; k = 1; break;//处理左子树
        case ')':top--; break;//处理完毕一个子树
        case ',':k = 2; break;//开始处理右子树（括号中‘，’右边的是右子树，左边是左子树）
        default:p = (BTNode*)malloc(sizeof(BTNode));
            p->data = ch;
            p->lchild = p->rchild = NULL;//对该小枝叉进行初始化
            if (b == NULL)
                b = p;//若b树为空，则将p设为b的root节点
            else {
                switch (k) {
                case 1:St[top]->lchild = p; break;
                case 2:St[top]->rchild = p; break;
                }
            
            }
        }
        j++;
        ch = str[j];
    }
}

void BT_Destory(BTNode* &b) {
    if (b != NULL) {
        BT_Destory(b->lchild);
        BT_Destory(b->rchild);
        free(b);
    }
    
}

BTNode* BT_FindNode(BTNode* b, ElemType x) {
    BTNode* p;
    if (b == NULL) {
        return NULL;
    }
    else if (b->data == x)
        return b;
    else {
        p = BT_FindNode(b->lchild, x);
        if (p != NULL)
            return p;
        else 
            return BT_FindNode(b->rchild, x);
    }
}

BTNode* BT_LchildNode(BTNode* b) {

    return b->lchild;
}

BTNode* BT_RchildNode(BTNode* b) {

    return b->rchild;
}

int BT_Height(BTNode* b) {
    int lchildh, rchildh;
    if (b == NULL)
        return 0;
    else {
        lchildh = BT_Height(b->lchild);
        rchildh = BT_Height(b->rchild);
        return 1 + max(rchildh, lchildh);
    }
}

void BT_Display(BTNode* b) {
    
    if (b != NULL) {
        printf("%c", b->data);
        if (b->lchild != NULL || b->rchild != NULL) {
            printf("(");
            BT_Display(b->lchild);
            if (b->rchild != NULL)
                printf(",");
            BT_Display(b->rchild);
            printf(")");
        }
    }
}
//测试
/*
int main()
{
    BTNode* b, * p, * lp, * rp;
    printf("创建二叉树:\n");
    BT_Create(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
    printf("输出二叉树：\n");
    BT_Display(b);
    printf("\n");
    printf("H节点:\n");
    p = BT_FindNode(b, 'H');
    if (p != NULL) {
        lp = BT_LchildNode(p);
        if (lp != NULL)
            printf("lchild:%c", lp->data);
        else printf("lchild is NULL ");
        printf("\n");
        rp = BT_RchildNode(p);
        if (rp != NULL)
            printf("rchild:%c", rp->data);
        else printf("rchild is NULL ");

    }
    printf("\n");
    printf("the BT_Height is :%d\n", BT_Height(b));
    printf("free the BT\n");
    BT_Destory(b);
    return 0;
}


*/

//二叉树的几种遍历算法
//先序遍历递归
void PreOrder(BTNode* b) {

    if (b != NULL) {
        printf("%c", b->data);
        PreOrder(b->lchild);
        PreOrder(b->rchild);
    }
}

//先序遍历非递归
void PreOrder1(BTNode* b) {
    BTNode* St[MaxSize], * p;
    int top = -1;
    if (b != NULL) {
        top++;
        St[top] = b;
        while (top > -1) {
            //中
            p = St[top];
            top--;
            printf("%c", p->data);
            //右
            if (p->rchild != NULL) {
                top ++ ;
                St[top] = p->rchild;
            }
            //左
            if (p->lchild != NULL) {
                top++;
                St[top] = p->lchild;

            }
        }
        printf("\n");
    }
    //用数组St[MaxSize]存遍历过的节点
    //因为是按顺序栈来存，因此进栈顺序为中->右->左，出栈后得正常的前序序列
}

//中序遍历递归
void InOrder(BTNode* b) {
    if (b != NULL) {
        //前->中->后
        InOrder(b->lchild);
        printf("%c", b->data);
        InOrder(b->rchild);
    }

}

//中序遍历非递归
void InOrder1(BTNode* b) {
    BTNode* St[MaxSize], * p;
    int top = -1;
    if (b != NULL) {
        p = b;
        while (top > -1 || p != NULL) {
            while (p != NULL) {
                top++;
                St[top] = p;
                p = p->lchild;
            }
            if (top > -1) {
                p = St[top];
                top--;
                printf(" % c", p->data);
                p = p->rchild;
            }
        }
        printf("\n");
    }

}

//后序遍历递归
void PostOrder(BTNode* b) {
    if (b != NULL) {
        PostOrder(b->lchild);
        PostOrder(b->rchild);
        printf("%c", b->data);
    }

}

//后序遍历非递归
void PostOrder1(BTNode* b) {
    BTNode* St[MaxSize],*p;
    int top = -1;
    bool flag;
    if (b != NULL) {
        do {
            while (b != NULL) {
                top++;
                St[top] = b;
                b = b->lchild;
            }
            p = NULL;
            flag = true;
            while (top != -1 && flag) {
                b = St[top];
                if (b->rchild == p) {
                    printf("%c", b->data);
                    top--;
                    p = b;
                }
                else {
                    b = b->rchild;
                    flag = false;

                }
            }
    }while (top != -1);
    printf("\n");
    }

}

//层序遍历

void TravLevel(BTNode* b) {
    BTNode* Qu[MaxSize];
    int front=0, rear=0;
    if (b != NULL)printf("%c", b->data);
    rear++;
    Qu[rear] = b;
    while(rear!=front){
        front = (front + 1) % MaxSize;
        b = Qu[front];
        if(b->lchild!=NULL){
            printf("%c", b->lchild->data);
            rear = (rear + 1) % MaxSize;
            Qu[rear] = b->rchild;
        } 
        if (b->rchild != NULL) {
            printf("%c", b->rchild->data);
            rear = (rear + 1) % MaxSize;
            Qu[rear] = b->rchild;
        }
    }
    printf("\n");
}
//测试
/*
int main()
{
    BTNode* b;
    BT_Create(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
    printf("二叉树b：\n");
    BT_Display(b);
    printf("\n");
    printf("层次遍历：\n");
    printf("先序遍历：\n");
    printf("递归算法：\n"); PreOrder(b); printf("\n");
    printf("非递归：\n"); PreOrder1(b); printf("\n");
    printf("中序遍历：\n"); 
    printf("递归算法：\n");InOrder(b); printf("\n");
    printf("非递归：\n"); InOrder1(b); printf("\n");
    printf("后序遍历：\n");
    printf("递归算法：\n"); PostOrder(b); printf("\n");
    printf("非递归：\n"); PostOrder1(b); printf("\n");
    BT_Destory(b);
    return 0;
}
*/
//判断二叉树是否为完全二叉树
bool Full_TravLevel(BTNode* b) {
    BTNode* Qu[MaxSize];
    int front = 0, rear = 0;
    int t = 0, depth = BT_Height(b);
    bool flag = true;
    if (b != NULL)printf("%c", b->data);
    rear++;
    Qu[rear] = b;
    t++;
    while (rear != front) {
        t++;
        front = (front + 1) % MaxSize;
        b = Qu[front];
        if (b->lchild != NULL) {
            printf("%c", b->lchild->data);
            rear = (rear + 1) % MaxSize;
            Qu[rear] = b->lchild;
            if ((b->rchild == NULL) && t < (int)pow(2, (depth - 1)))
                return false;
        }
        if (b->rchild != NULL) {
            printf("%c", b->rchild->data);
            rear = (rear + 1) % MaxSize;
            Qu[rear] = b->rchild;
        }

        if ((b->lchild == NULL || b->rchild == NULL) && t < depth - 1) {
            return false;
        }
        if (b->lchild == NULL && b->rchild != NULL)
            return false;
        
    }
    printf("\n");
    return flag;
}

2.图的基本算法和遍历(DFS/BFS)

#include <stdio.h>
#include <malloc.h>
#define INF 32767
#define MAXV 100
typedef char InfoType;

typedef struct {
    int no;//顶点编号
    InfoType info;//顶点其他信息
}VertexType;//顶点类型

typedef struct {
    int edges[MAXV][MAXV];//邻接矩阵数组
    int n, e;//顶点数，边数
    VertexType vexs[MAXV];//存放顶点信息
}MatGraph;//完整的图邻接矩阵类型

typedef struct ANode {
    int adjvex;//该边的邻接点编号
    struct ANode* nextarc;//指向下一条边的指针
    int weight;//该边的相关信息，如权值
}ArcNode;//边节点类型

typedef struct Vnode {
    InfoType info;//顶点其他信息
    int count;//存放顶点入度,仅仅用于拓扑排序
    ArcNode* firstarc;//指向第一条边
}VNode;//邻接表头节点类型

typedef struct {
    VNode* adjlist[MAXV];//邻接表头节点数组
    int n, e;//图中顶点数n和边数e
}AdjGraph;//完整的图邻接表类型

void G_CreateMat(MatGraph& g, int A[MAXV][MAXV], int n, int e) {

    int i, j;
    g.n = n; g.e = e;
    for (i = 0; i < g.n; i++)
        for (j = 0; j < g.e; j++)
            g.edges[i][j] = A[i][j];
}

void DispMat(MatGraph g) {
    int i, j;
    for ( i = 0; i < g.n; i++) {
        for (j = 0; j < g.e; j++) 
            if (g.edges[i][j] != INF)
                printf("%4d", g.edges[i][j]);
            else printf("%4s", "INF");
        printf("\n");

    }

}
//邻接表
void CreateAdj(AdjGraph*& G, int A[MAXV][MAXV], int n, int e) {
    int i, j;
    ArcNode* p;
    G = (AdjGraph *)malloc(sizeof(AdjGraph));
    for (i = 0; i < n; i++)
      G->adjlist[i]->firstarc = NULL;
    for (i = 0; i < n; i++) 
        for (j = n - 1; j >= 0; j--) 
            if (A[i][j] != 0 && A[i][j] != INF) {
                p = (ArcNode*)malloc(sizeof(ArcNode));
                p->adjvex = j;
                p->weight = A[i][j];
                p->nextarc = G->adjlist[i]->firstarc;
                G->adjlist[i]->firstarc = p;
            }
    G->n = n;
    G->e = e;
}

void DispAdj(AdjGraph* G) {
    ArcNode* p;
    for (int i = 0; i < G->n; i++) {
        p = G->adjlist[i]->firstarc;
        printf("%3d:", i);
        while (p != NULL) {
            printf("%3d[%d]->",p->adjvex,p->weight);
            p = p->nextarc;
        }
        printf("^\n");
    }

}

void DestoryAdj(AdjGraph*& G) {
    ArcNode* pre, * p;
    for(int i=0;i<G->n;i++){
        pre = G->adjlist[i]->firstarc;
        if (pre != NULL) {
            p = pre->nextarc;
            while (p != NULL) {
                free(pre);
                pre = p;
                p = p->nextarc;
            }
            free(pre);
        }
    }
    free(G);
}

int visited[MAXV];

void DFS(AdjGraph* G, int v) {
    ArcNode* p;
    printf("%3d", v); visited[v] = 1;
    p = G->adjlist[v]->firstarc;
    while (p != NULL) {
        if (visited[p->adjvex] == 0)
            DFS(G, p->adjvex);
        p = p->nextarc;
    }
}
//测试
/*

int main()
{
    MatGraph g;
    AdjGraph* G;
    int A[MAXV][MAXV] = {
        {0,5,INF,7,INF,INF},{INF,0,4,INF,INF,INF},
        {8,INF,0,INF,INF,9},{INF,INF,5,0,INF,6},
        {INF,INF,INF,5,0,INF},{3,INF,INF,INF,1,0}
    };
    int n = 6, e = 10;
    G_CreateMat(g, A, n, e);
    printf("(1)图的邻接矩阵：\n"); DispMat(g);
    CreateAdj(G, A, n, e);
    printf("(2)图的邻接表：\n"); DispAdj(G);
    printf("(3销毁图的邻接表\n)");
    DestoryAdj(G);
    return 1;
}

*/

//DFS和BFS
int visited[MAXV];

void DFS(AdjGraph* G, int v) {
    ArcNode* p;
    printf("%3d", v); visited[v] = 1;
    p = G->adjlist[v]->firstarc;
    while (p != NULL) {
        if (visited[p->adjvex] == 0)
            DFS(G, p->adjvex);
        p = p->nextarc;
    }
}

void DFS1(AdjGraph* G, int v) {
    ArcNode* p;
    int St[MAXV];
    int top = -1,w,x,i;
    for (i = 0; i < G->n; i++)
        visited[i] = 0;
    printf("%3d", v);
    visited[v] = 1;
    top++; St[top] = v;
    while (top > -1) {
        x = St[top];
        p = G->adjlist[x]->firstarc;
        while (p != NULL) {
            w = p->adjvex;
            if(visited[w]==0){
                printf("%3d", w);
                visited[w] = 1;
                top++;
                St[top] = w;
                break;//退出循环处理栈顶的顶点
            }
            p = p->nextarc;
        }
        if (p == NULL)top--;

    }
    printf("\n");
}

void BFS(AdjGraph* G, int v) {
    ArcNode* p;
    int queue[MAXV], front = 0, rear = 0;//定义环形队列并进行初始化
    int visited[MAXV];//定义存放顶点的访问标志的数组
    int w,i;
    for (i = 0; i < G->n; i++) {
        visited[i] = 0;//访问数组标志初始化
    }
    printf(" % 3d", v);//输出被访问顶点的编号
    visited[v] = 1;//置已访问标记
    rear = (rear + 1) % MAXV;
    queue[rear] = v;//v进队
    while (front != rear) {
        front = (front + 1) % MAXV;
        w = queue[front];//出队并赋值给w
        p = G->adjlist[w]->firstarc;//找顶点w的第一个相邻点
        while (p != NULL) {
            if (visited[p->adjvex] == 0) {//若相邻点未被访问
                printf("%3d", p->adjvex);//访问该相邻点
                visited[p->adjvex] = 1;//置已访问标记
                rear = (rear + 1) % MAXV;//该顶点进队
                queue[rear] = p->adjvex;
            }
            p = p->nextarc;//找下一个相邻点
        }
    }
    printf("\n");
}
//测试
/*
int main() {
    AdjGraph* G;
    int A[MAXV][MAXV] = {
        {0,5,INF,7,INF,INF},{INF,0,4,INF,INF,INF},
        {8,INF,0,INF,INF,9},{INF,INF,5,0,INF,6},
        {INF,INF,INF,5,0,INF},{3,INF,INF,INF,1,0}
    };
    int n = 6, e = 10;
    CreateAdj(G, A, n, e);
    printf("图G的邻接表：\n");
    DispAdj(G);
    printf("从顶点0开始的DFS：\n");
    DFS(G, 0); printf("\n");//递归
    printf("从顶点0开始的DFS1：\n");
    DFS1(G, 0); printf("\n");//非递归
    printf("从顶点0开始的BFS:\n");
    BFS(G, 0);
    DestoryAdj(G);
    return 1;
}
*/
到底是啥
关注
算法笔记上机
且行的小博客
03-23 656
算法、编程笔记
数据结构（C语言）--栈和队列
d_eng_的博客
07-08 396
顺序栈 #include<stdio.h> #include<malloc.h> #define ERROR 0 #define OK 1 #define True 1 #define False 0 #define STACK_INT_SIZE 10 /存储空间初始分配量/ #define STACKINCREMENT 5 /存储空间分配增量/ typedef in...
DFS与BFS算法
qq_41816189的博客
02-06 2万+
深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。下面分别介绍两种基本的搜索算法。
如何通透理解：BFS和DFS优先搜索算法(23年修订版)
结构之法 算法之道
01-01 13万+
4、教你通透彻底理解：BFS和DFS优先搜索算法作者：July二零一一年一月一日---------------------------------本人参考：算法导论 本人声明：个人原创，转载请注明出处。ok，开始。翻遍网上，关于此类BFS和DFS算法的文章，很多。但，都说不出个所以然来。读完此文，我想，你对图的广度优先搜索和深度优先搜索定会有个通通透透，彻彻底底的认识。
图文详解 DFS 和 BFS
weixin_41385912的博客
04-15 8097
前言 深度优先遍历（Depth First Search, 简称 DFS） 与广度优先遍历（Breath First Search）是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻...
数据结构基础27: DFS和BFS算法总结
何哥的博客
02-16 6306
前言：图的遍历算法DFS和BFS是许多图算法的基础，所以有必要单独拎出来总结一下。DFS和BFS主要是运用于对于图和树的搜索，很多问题模型都是可以建模变成一个图或者树的，所以差不多不少问题都会涉及到这两个。比如求二叉树深度，可以是递归的方法，属于DFS（深度优先搜索）；另一种方法是按照层次遍历，属于BFS（广度优先搜索），想看代码的可以看《剑指Offer（三十八）：二叉树的深度》。再比如寻找一条路...
算法笔记
04-09
【标题】算法笔记 【描述】这是我多年总结而来的算法经验，变卖换积分，最近等着积分使用。而且如果想学习算法的话自己可以学习这本，我个人的笔记总结。 【标签】数据结构 图论 算法笔记 【部分内容解读】 1. ...
MATLAB智能优化算法-学习笔记（1）——遗传算法求解0-1背包问题【过程+代码】
最新发布
g1997c的博客
08-27 2185
遗传算法（Genetic Algorithm, GA）是一种基于自然选择和遗传机制的优化方法，广泛应用于求解复杂的优化问题。本文利用遗传算法求解0-1背包问题，探索其在求解组合优化问题中的有效性。0-1背包问题是一种经典的离散优化问题，其目标是选择一定数量的物品以最大化总价值，同时确保总质量不超过背包的容量限制。该问题在实际应用中涉及广泛，如资源分配、货物装载等领域。
阿龙的学习笔记---常用算法---递归，回溯法，动态规划，贪心
阿龙的博客
03-31 401
1. 递归 递归说白了就是程序是自身调用，通常情况下会让复杂的循环变的简单好理解，但由于会涉及到大量的函数调用，时间效率很低，容易造成栈的溢出。剑指说面试题中，在时间要求较低的情况下能用递归的可以用。很容易体现出思路。 数据结构中的树是最适合用递归的数据结构。 递归最重要的是设置好递归出口的条件。 递归算法的思路是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数（或过程）来表示问题的解...
机器学习笔记－－聚类算法 k-means－－31省市消费水平聚类
qq_39011567的博客
10-19 5737
参考文章：https://blog.csdn.net/rankiy/article/details/99843363 1.数据集 数据介绍： 现有1999年全国31个省份城镇居民家庭平均每月全年消费性支出 的八个主要变量数据，这八个变量分别是 食品、衣着、家庭设备用品、服务、医疗保健、交通、通讯、娱乐教育文化服务、居住以及杂项商品和服务。 利用已有数据，对31个省份进行聚类。 北京,2959...
一文带你了解dfs和bfs算法
Twinkle_sone的博客
01-21 1万+
一文带你了解dfs和bfs算法 如上图，dfs和bfs算法通常会用来解决迷宫问题，两种算法都可以找到一条通往重点的路，但又有不一样的地方。 体验地址：http://120.79.163.94/demo/寻路算法.html 可以自己定义迷宫是否可走，及起始点和终点。 深度优先算法（dfs） 简介 dfs算法又称深度优先搜索，是计算机术语。 1、dfs是一种在开发爬虫早期使用较多的方法，是搜索算法的一种。 2、dfs的目的是要达到被搜索结构的叶结点，即那些不包含任何超链的HTML文件。 3、dfs根据已有的邻
熬夜怒肝，图解算法！BFS和DFS的直观解释
Jack-Cui
05-27 1万+
动图图解！
dfs和bfs算法详解
编程小弟的博客
04-17 1435
DFS和BFS是两种基础且强大的图遍历算法，它们在解决各种实际问题时发挥着重要作用。通过了解它们的原理、实现细节以及变种和优化策略，我们可以更加灵活地运用这些算法来解决实际问题。同时，在选择使用DFS还是BFS时，我们需要根据问题的特点、图的性质以及时间和空间复杂度的要求来进行权衡和选择。
BFS算法和DFS算法（含图解：简单易懂）
qian_yu_的博客
08-30 4万+
图解BFS算法和DFS算法BFS算法算法思路实现过程Python代码实现DFS算法算法思路实现过程Python代码实现 BFS算法 BFS类似于树的层次遍历过程,从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。 舍去空间换时间。 算法思路 队列（先进先出） 1、创建一个空队列queue（用来存放节点）和一个空列表visit（用来存放已访问的节点） 2、依次将起始点及邻接点加入queue和visit中 3、poo出队
深度优先遍历(DFS)和广度优先遍历(BFS)
weixin_45666566的博客
06-02 4498
深度优先遍历和广度优先遍历1.深度优先遍历(DFS)2.广度优先遍历(BFS)3.DFS与BFS算法比较 深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。 1.深度优先遍历(DFS) 深度优先遍历顾名思义就是一条路走到黑，再寻其他未走过的路。其类似于树的先序遍历。 思想： 假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优
深度优先搜索（DFS）与广度优先搜索（BFS）详解
jasean_的博客
11-07 3万+
深度优先搜索与宽度优先搜索详解 深度优先搜索（DFS）和宽度优先搜索（BFS）都是常见的搜索算法。在学习DFS和BFS之前，我们首先得知道递归函数的概念。 1. 递归函数 通俗地讲，一个函数自己调用自己的行为就叫递归，该函数就叫递归函数。如计算一个数的阶乘，就可以利用递归来实现。 我们知道一个数的阶乘可以等于这个数乘上这个数减1的阶乘，如3!=3×2!3!=3\times2!3!=3×2!，便有递推式： n!=n×(n−1)! n!=n\times(n-1)! n!=n×(n−1)! 规定0!=10!=10
图的广度优先搜索（BFS）和深度优先搜索（DFS）算法解析
weixin_40953222的博客
06-02 16万+
BFS/DFS算法解析【算法入门]2018/6/21.前言和树的遍历类似，图的遍历也是从图中某点出发，然后按照某种方法对图中所有顶点进行访问，且仅访问一次。但是图的遍历相对树而言要更为复杂。因为图中的任意顶点都可能与其他顶点相邻，所以在图的遍历中必须记录已被访问的顶点，避免重复访问。根据搜索路径的不同，我们可以将遍历图的方法分为两种：广度优先搜索和深度优先搜索。2.图的基本概念2.1.无向图和无向...
【C/C++面试必备】bfs和dfs的区别
Linux猿
07-30 9389
???? 作者：Linux猿 ???? 简介：CSDN博客专家????，C/C++、面试、刷题、算法尽管咨询我，关注我，有问题私聊！ ???? 关注专栏：C/C++面试通关集锦（优质好文持续更新中……）???? 目录 一、什么是 bfs ? 1.1 搜索方式 二、什么是 dfs ? 2.1 搜索方式 三、bfs 和 dfs 的区别 3.1数据结构 3.2 访问节点的方式 3.3 应用 大家对 bfs 和 dfs 应该都有了解，都是很常用的搜索算法，本文结合实例来讲解下这两者的不同。
BFS和DFS算法原理（通俗易懂版）
热门推荐
尚小馨的博客
11-16 18万+
DFS 算法 思想：一直往深处走，直到找到解或者走不下去为止 BFS算法 DFS：使用栈保存未被检测的结点，结点按照深度优先的次序被访问并依次被压入栈中，并以相反的次序出栈进行新的检测。 BFS：使用队列保存未被检测的结点。结点按照宽度优先的次序被访问和进出队列。 框架： BFS: #include #include #include #include
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值