有趣的图十字链表创建和遍历算法

最新推荐文章于 2023-01-13 19:20:22 发布
最新推荐文章于 2023-01-13 19:20:22 发布
阅读量386 收藏
点赞数
分类专栏： 算法 文章标签： 链表 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/benben_ho/article/details/121077722
版权

前言

十字链表是图结构数据算法比较好的操作形式，在此基础上可以实现很多有价值的算法。注意：此算法还并未进行完整性测试，同时提醒里边埋藏了典型的溢出漏洞，供对信息安全的朋友参考。

//
//  Gr.hpp
//  GR
//
//  Created by 韩立国 on 2021/10/31.
//

#ifndef Gr_hpp
#define Gr_hpp

#include <stdio.h>

struct Gr_Note{
    struct Gr_Arc*first_Arc;
    char Date[20];
    struct Gr_Arc*back_Arc;
    bool tag;
};

struct Gr_Arc{
    struct Gr_Note *Gr_Arc_Head;
    struct Gr_Note *Gr_Arc_Tail;
    struct Gr_Arc *Gr_head_N;
    struct Gr_Arc *Gr_tail_N;
    unsigned int info;
    bool tag;
};

extern bool Create_Gr(struct Gr_Note *Gr_Arry,struct Gr_Arc *Gr_Arc_arc ,int N,int M);
//extern int *create_Arc(struct Gr_Note *Gr_ArryT);

#endif /* Gr_hpp */

//
//  Gr.cpp
//  GR
//
//  Created by 韩立国 on 2021/10/31.
//
#include <iostream>
#include "Gr.hpp"
#include <string.h>
using namespace std;

struct Gr_Note Gr_ArrS[600000];
//Gr_Note HiNote={0,0,0};
//Gr_Arc  HiArc={0,0,0,0,0};

bool Create_Gr(struct Gr_Note *Gr_ArrS,struct Gr_Arc *Gr_Arc_arc ,int N,int M)
{
    int i;
    char Dateee[20];
    bool Gatekeeper=false;
    cout<<"I will create a Cross linked list：  \n";

    for(i=0;i<N;i++)
    {
        cout<<"Plaase put the Head date :     "<<i<<"\n";
        cin>>Dateee;
        strcpy(Gr_ArrS[i].Date,Dateee);
        Gr_ArrS[i].first_Arc=NULL;
        cout<<"Head  first_Arc  is :"<<Gr_ArrS[i].first_Arc<<"\n";
        Gr_ArrS[i].back_Arc=NULL;
        cout<<"Head  Back_Arc  is :"<<Gr_ArrS[i].back_Arc<<"\n";
    }
    char note[20],note_one[20],note_two[20];
    Gr_Arc *Next_Arc=NULL;
    Gr_Arc *Midll_Arc=NULL;
    int j;
    for(j=0;j<M;j++)
    {
        Gr_Arc *Gr_Arc_arc_arc=new Gr_Arc;//Dyns request a Arc
        Gr_Arc_arc_arc->Gr_Arc_Tail=NULL;
        Gr_Arc_arc_arc->Gr_Arc_Head=NULL;
        Gr_Arc_arc_arc->Gr_head_N=NULL;
        Gr_Arc_arc_arc->Gr_tail_N=NULL;
        Gr_Arc_arc_arc->info=NULL;
       
//put in a head

        cout<<"Please put in the arc head-note  :\n";
        cin>>note;
        
        for(i=0;i<N;i++)                       //check you put is a exsit!
        {
            if(strcmp(note,Gr_ArrS[i].Date)==0)
            {cout<<"U Are  put a exsit char !\n";
                Gatekeeper=true;
                break;
            }else{Gatekeeper=false;}
        }
        if(Gatekeeper==false)
        {cout<<"You are an idiot, you typed it wrong！！！！！！\n";
            delete Gr_Arc_arc_arc;
            break;}
        strcpy(note_one,note);
                
            for(i=0;i<N;i++)
            {
            if(strcmp(note,Gr_ArrS[i].Date)==0)
            {
            if(Gr_ArrS[i].first_Arc==NULL)
            {
                Gr_ArrS[i].first_Arc=Gr_Arc_arc_arc;    //put the Arc address in the note
                Gr_Arc_arc_arc->Gr_Arc_Head=&Gr_ArrS[i]; //put the note address in the arc
                cout<<"Gr_ArrS.first_Arc is :"<<Gr_ArrS[i].first_Arc<<"\n";
                cout<<"note   is:"<<i<<"\n";
            }else
            {
                Gr_Arc_arc_arc->Gr_Arc_Head=&Gr_ArrS[i];
                cout<<"Gr_Arc_arc_arc->Gr_Arc_Head is :"<<Gr_Arc_arc_arc->Gr_Arc_Head<<"\n";
                Midll_Arc=Gr_ArrS[i].first_Arc;
                while(Midll_Arc->Gr_head_N!=NULL)
                {
                    Next_Arc=Midll_Arc->Gr_head_N;
                    Midll_Arc=Next_Arc->Gr_head_N;
                }
                Midll_Arc->Gr_head_N=Gr_Arc_arc_arc;
            }
            }
            }
        
//put in a tail

        cout<<"Please put in the arc tail-note  :\n";
        cin>>note;
        
        for(i=0;i<N;i++)                       //check you put is a exsit!
        {
            if(strcmp(note,Gr_ArrS[i].Date)==0)
            {
                cout<<"U Are  put a exsit char !\n";
                Gatekeeper=true;
                break;
            }else{Gatekeeper=false;}
        }
        if(Gatekeeper==false)
        {cout<<"You are an idiot, you typed it wrong！！！！！！\n";
            delete Gr_Arc_arc_arc;
            break;}
        
        strcpy(note_two,note);
                
            for(i=0;i<N;i++)
            {
                if(strcmp(note,Gr_ArrS[i].Date)==0)
                {

            if(Gr_ArrS[i].back_Arc==NULL)
            { Gr_ArrS[i].back_Arc=Gr_Arc_arc_arc;
                Gr_Arc_arc_arc->Gr_Arc_Tail=&Gr_ArrS[i];
                cout<<"Gr_ArrS.back_Arc is :"<<Gr_ArrS[i].back_Arc<<"\n";
                cout<<"note is :"<<i<<"\n";

            }else
            {
                Gr_Arc_arc_arc->Gr_Arc_Tail=&Gr_ArrS[i];
                cout<<"Gr_Arc_arc_arc->Gr_Arc_Tail    is:"<<Gr_Arc_arc_arc->Gr_Arc_Tail<<"\n";
                Midll_Arc=Gr_ArrS[i].back_Arc;
                while(Midll_Arc->Gr_tail_N!=NULL)
                {
                    Next_Arc=Midll_Arc->Gr_tail_N;
                    Midll_Arc=Next_Arc->Gr_tail_N;
                }
                Midll_Arc->Gr_tail_N=Gr_Arc_arc_arc;
            }
                }
            }
        
        cout<<"PUT IN the ARC INFO  !!!!!!:\n";
        cin>>Gr_Arc_arc_arc->info;
        cout<<"IS          :"<<Gr_Arc_arc_arc->info;
        cout<<"the arc is:       "<<note_one<<"---"<<Gr_Arc_arc_arc->info<<"--->"<<note_two<<"\n";
        cout<<"yes !  U are PUt in a ARc ,please next !"<<Gr_Arc_arc_arc->info<<"\n";
        memset(note_one,'\0',sizeof(note_one));
        memset(note_two,'\0',sizeof(note_two));
        //Next_Arc=Gr_Arc_arc_arc;
    }
    return Gatekeeper;
    //
}


//
//  main.cpp
//  GR
//
//  Created by 韩立国 on 2021/10/31.
//

#include <iostream>
#include "Gr.hpp"
using namespace std;

int main(int argc, const char * argv[])
{
    
    struct Gr_Note Gr_ArrS[100];
    struct Gr_Note *Note_Point=NULL;
    struct Gr_Arc  *Arc_Point=NULL;
    int q;
    
    if(bool Auditor=Create_Gr(Gr_ArrS,0 ,4,4))
    {
        cout<<"Great, you created a cross-linked list！\n";
        
    }else
    {
        cout<<"You failed hahahaha!!!!!!\n";
    }
  
    
    for(q=0;q<4;q++)    //Traverse the cross-linked list space！
    {
        cout<<Gr_ArrS[q].Date<<"\n";
           
        if(Gr_ArrS[q].first_Arc!=NULL&&Gr_ArrS[q].back_Arc!=NULL)
        {
 
            Arc_Point=Gr_ArrS[q].first_Arc;
            
            do{
                 if(Arc_Point->info!=0)
                 
                      Arc_Point->tag=true;
                      Note_Point=Arc_Point->Gr_Arc_Tail;
                         if(Note_Point->first_Arc!=NULL)
                         {
                          cout<<"next note is :"<<Note_Point->Date<<"\n";
                          cout<<"the arc info is :"<<Arc_Point->info<<"\n";
                          Arc_Point=Note_Point->first_Arc;
                          continue;
                         }else{break;}
            }while(Arc_Point->Gr_Arc_Tail!=NULL&&Note_Point->first_Arc!=NULL&&Arc_Point->tag==false);
        
            Arc_Point=NULL;
            Note_Point=NULL;
            Arc_Point=Gr_ArrS[q].first_Arc;
            
            do{
                  if(Arc_Point->info!=0)
                     
                      Arc_Point->tag=false;
                      Note_Point=Arc_Point->Gr_Arc_Tail;
                         if(Note_Point->first_Arc!=NULL)
                         {
                         Arc_Point=Note_Point->first_Arc;
                         continue;
                         }else{break;}
            }while(Arc_Point->Gr_Arc_Tail!=NULL&&Note_Point->first_Arc!=NULL&&Arc_Point->tag==true);
        
            Arc_Point=NULL;
            Note_Point=NULL;
            
          //if(Gr_ArrS[q].back_Arc!=NULL)
          //{
            
            Arc_Point=Gr_ArrS[q].back_Arc;
        
            do{
                 if(Arc_Point->info!=0)
                 
                 Arc_Point->tag=true;
                 Note_Point=Arc_Point->Gr_Arc_Head;
                     if(Note_Point->back_Arc!=NULL)
                     {
                     cout<<"front note is :"<<Note_Point->Date<<"\n";
                     cout<<"the arc info is :"<<Arc_Point->info<<"\n";
                     Arc_Point=Note_Point->back_Arc;
                     continue;
                     }else{break;}

             }while(Arc_Point->Gr_Arc_Head!=NULL&&Note_Point->back_Arc!=NULL&&Arc_Point->tag==false);

             Arc_Point=NULL;
             Note_Point=NULL;
             Arc_Point=Gr_ArrS[q].back_Arc;
            
             do{
                  if(Arc_Point->info!=0)
                  
                  Arc_Point->tag=false;
                  Note_Point=Arc_Point->Gr_Arc_Head;
                      if(Note_Point->back_Arc!=NULL)
                      {
                      Arc_Point=Note_Point->back_Arc;
                      continue;
                      }else{break;}
             }while(Arc_Point->Gr_Arc_Head!=NULL&&Note_Point->back_Arc!=NULL&&Arc_Point->tag==true);
            Arc_Point=NULL;
            Note_Point=NULL;
         // }
            
        }else if (Gr_ArrS[q].first_Arc==NULL&&Gr_ArrS[q].back_Arc!=NULL)
        {
            Arc_Point=Gr_ArrS[q].back_Arc;
        
            do{
                 if(Arc_Point->info!=0)
                 
                 Arc_Point->tag=true;
                 Note_Point=Arc_Point->Gr_Arc_Head;
                     if(Note_Point->back_Arc!=NULL)
                     {
                     cout<<"front note is :"<<Note_Point->Date<<"\n";
                     cout<<"the arc info is :"<<Arc_Point->info<<"\n";
                     Arc_Point=Note_Point->back_Arc;
                     continue;
                     }else{break;}

             }while(Arc_Point->Gr_Arc_Head!=NULL&&Note_Point->back_Arc!=NULL&&Arc_Point->tag==false);

             Arc_Point=NULL;
             Note_Point=NULL;
             Arc_Point=Gr_ArrS[q].back_Arc;
            
             do{
                  if(Arc_Point->info!=0)
                  
                  Arc_Point->tag=false;
                  Note_Point=Arc_Point->Gr_Arc_Head;
                      if(Note_Point->back_Arc!=NULL)
                      {
                      Arc_Point=Note_Point->back_Arc;
                      continue;
                      }else{break;}
             }while(Arc_Point->Gr_Arc_Head!=NULL&&Note_Point->back_Arc!=NULL&&Arc_Point->tag==true);
            Arc_Point=NULL;
            Note_Point=NULL;
            
        }else if(Gr_ArrS[q].first_Arc!=NULL&&Gr_ArrS[q].back_Arc==NULL){
            
                       Arc_Point=Gr_ArrS[q].first_Arc;
                       
                       do{
                            if(Arc_Point->info!=0)
                            
                                 Arc_Point->tag=true;
                                 Note_Point=Arc_Point->Gr_Arc_Tail;
                                    if(Note_Point->first_Arc!=NULL)
                                    {
                                     cout<<"next note is :"<<Note_Point->Date<<"\n";
                                     cout<<"the arc info is :"<<Arc_Point->info<<"\n";
                                     Arc_Point=Note_Point->first_Arc;
                                     continue;
                                    }else{break;}
                       }while(Arc_Point->Gr_Arc_Tail!=NULL&&Note_Point->first_Arc!=NULL&&Arc_Point->tag==false);
                   
                       Arc_Point=NULL;
                       Note_Point=NULL;
                       Arc_Point=Gr_ArrS[q].first_Arc;
                       
                       do{
                             if(Arc_Point->info!=0)
                                
                                 Arc_Point->tag=false;
                                 Note_Point=Arc_Point->Gr_Arc_Tail;
                                    if(Note_Point->first_Arc!=NULL)
                                    {
                                    Arc_Point=Note_Point->first_Arc;
                                    continue;
                                    }else{break;}
                       }while(Arc_Point->Gr_Arc_Tail!=NULL&&Note_Point->first_Arc!=NULL&&Arc_Point->tag==true);
                   
                       Arc_Point=NULL;
                       Note_Point=NULL;
        }else if ((Gr_ArrS[q].first_Arc==NULL&&Gr_ArrS[q].back_Arc==NULL))
            
        {
            Arc_Point=NULL;
            Note_Point=NULL;
            continue;}
    }
    
    return 0;
}

I will create a Cross linked list：  
Plaase put the Head date :     0
guangzhou
Head  first_Arc  is :0x0
Head  Back_Arc  is :0x0
Plaase put the Head date :     1
beijing
Head  first_Arc  is :0x0
Head  Back_Arc  is :0x0
Plaase put the Head date :     2
shanghai
Head  first_Arc  is :0x0
Head  Back_Arc  is :0x0
Plaase put the Head date :     3
chengdu
Head  first_Arc  is :0x0
Head  Back_Arc  is :0x0
Please put in the arc head-note  :
beijing
U Are  put a exsit char !
U Are  put a exsit char !
Gr_ArrS.first_Arc is :0x108824a20
note   is:1
Please put in the arc tail-note  :
chengdu
U Are  put a exsit char !
Gr_ArrS.back_Arc is :0x108824a20
note is :3
PUT IN the ARC INFO  !!!!!!:
4000
IS          :4000the arc is:       beijing---4000--->chengdu
yes !  U are PUt in a ARc ,please next !4000
Please put in the arc head-note  :
shanghai
U Are  put a exsit char !
U Are  put a exsit char !
Gr_ArrS.first_Arc is :0x10262a960
note   is:2
Please put in the arc tail-note  :
guangzhou
U Are  put a exsit char !
Gr_ArrS.back_Arc is :0x10262a960
note is :0
PUT IN the ARC INFO  !!!!!!:
3000
IS          :3000the arc is:       shanghai---3000--->guangzhou
yes !  U are PUt in a ARc ,please next !3000
Please put in the arc head-note  :
chengdu
U Are  put a exsit char !
U Are  put a exsit char !
Gr_ArrS.first_Arc is :0x1022373d0
note   is:3
Please put in the arc tail-note  :
guangzhou
U Are  put a exsit char !
Gr_Arc_arc_arc->Gr_Arc_Tail    is:0x7ff7bfefe0f0
PUT IN the ARC INFO  !!!!!!:
2500
IS          :2500the arc is:       chengdu---2500--->guangzhou
yes !  U are PUt in a ARc ,please next !2500
Please put in the arc head-note  :
guangzhou
U Are  put a exsit char !
U Are  put a exsit char !
Gr_ArrS.first_Arc is :0x102237400
note   is:0
Please put in the arc tail-note  :
beijing
U Are  put a exsit char !
Gr_ArrS.back_Arc is :0x102237400
note is :1
PUT IN the ARC INFO  !!!!!!:
6000
IS          :6000the arc is:       guangzhou---6000--->beijing
yes !  U are PUt in a ARc ,please next !6000
Great, you created a cross-linked list！
guangzhou
next note is :beijing
the arc info is :6000
next note is :chengdu
the arc info is :4000
beijing
next note is :chengdu
the arc info is :4000
next note is :guangzhou
the arc info is :2500
next note is :beijing
the arc info is :6000
front note is :guangzhou
the arc info is :6000
shanghai
next note is :guangzhou
the arc info is :3000
next note is :beijing
the arc info is :6000
next note is :chengdu
the arc info is :4000
next note is :guangzhou
the arc info is :2500
chengdu
next note is :guangzhou
the arc info is :2500
next note is :beijing
the arc info is :6000
next note is :chengdu
the arc info is :4000
front note is :beijing
the arc info is :4000
front note is :guangzhou
the arc info is :6000
Program ended with exit code: 0

benben_ho
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
创建十字链表
huhubbdd的博客
06-14 537
邻接表虽然可以很容易地求出顶点的出度，但是求入度的时候，却非常麻烦，需要遍历整个邻接表。使用十字链表，就可以快速求入度和出度。实际上十字链表就是邻接表的改进
图的存储结构——十字链表
m0_72579201的博客
02-07 5536
回忆邻接矩阵与邻接表的存储结构，它们都不便于求顶点的出度与入度。为了解决上述两者求出入度的局限性，在此引入十字链表，它可以看成邻接表与逆邻接表的结合，方便求解顶点出入度与获取顶点的出入度边。
数据结构及算法基础 之图（三）十字链表
qigaohua的博客
10-31 457
文章目录一、十字链表二、代码示例     一、十字链表   邻接表在某种程度上是有缺陷的，它表示了出度就表示不了入度。所以出现了十字链表，它既能表示入度也能表示出度。   说通俗点，十字链表也就是邻接表的改进，顶点集包含两个指针，firstIn和firstOut, firstIn指向入边表（逆邻接表）， firstOut表示出边表（也就是邻接表）。（需要先理解上面代码中顶点集...
图的十字链表存储结构的实现及其图的遍历
bobopeng
10-25 4420
图的十字链表存储结构是将图的邻接表和逆邻接表组合起来的一个新的存储结构。因为邻接表只能方便计算出图中顶点的出度，而在计算顶点的入度问题时就不太方便了，必须遍历所有的顶点才能知道图中某个顶点的入度。而逆邻接表刚好和邻接表相反，所以组合他们就能够方便计算出图中任意顶点的入度和出度问题。 那么，十字链表很复杂吗？其实假如你的链表学到很好的话，那么可以说图的十字链表存储结构的实现是不难理解的。现在我们就
使用十字链表结构 实现深度优先遍历
weixin_42601134的博客
01-13 89
使用十字链表结构实现深度优先遍历的方法如下: 从根节点开始遍历 如果当前节点有左子节点，则遍历左子节点 如果当前节点有右子节点，则遍历右子节点 如果当前节点没有左右子节点，则回溯到父节点继续遍历 重复步骤2-4,直到遍历完整棵树。 ...
1、 掌握图的结构特征以及四种存储结构（数组表示法、邻接表、十字链表和邻接多重表）的特点和程序设计方法
10-29
1、 掌握图的结构特征以及四种存储结构（数组表示法、邻接表、十字链表和邻接多重表）的特点和程序设计方法。 2、 掌握在邻接矩阵或邻接表存储结构下图的深度优先和广度优先遍历算法的设计方法。 3、 进一步掌握递归...
图形数据结构实验.doc
07-11
2）掌握图的深度优先搜索遍历算法和图的广度优先搜索遍历算法及C语言实现； 3）按照实验题目要求独立正确地完成实验内容（提交程序清单及相关实验数据与 运行结果）； 4）认真书写实验报告,并按时提交（第12周周三...
十字链表的创建和遍历（数据结构） C语言
qq_52683550的博客
10-14 2096
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 一、十字链表是什么？ 十字链表常用于表示稀疏矩阵，可视作稀疏矩阵的一种链式表示，因此，这里以稀疏矩阵为背景介绍十字链表。不过，十字链表的应用远不止稀疏矩阵，一切具有正交关系的结构，都可用十字链表存储。 二、十字链表的存储结构 1.用于总结点的存储结构 m:总行数 n:总列数 len:总元素个数 ro.
图：十字链表的构造以及遍历
双鱼座boyy的博客
05-18 1210
图形样式： 十字链表是有向图的另一种链式储存结构，每一条弧有一个结点，每一个顶点也有一个结点 邻接表法创建无向图过程： 一，输入总顶点数和边数 eg:如图所示即为4点，7边。 二，依次输入点的信息存入顶点表中，并将每个结点的两个指针域都初始化为NULL（每个点一个名字） （十字链表相对于邻表法，有两个指针域，相当于有两个头结点，相对应两串链表，一串代表入，一串出） eg:如图即可以写为ABCD。 三，构造邻接矩阵。 依次输入每条弧的两个顶点，确定这两个顶点的...
数据结构-图(有向图的十字链表法和深度搜索遍历)
sin++
03-27 362
#pragma once #include "pch.h" namespace map { typedef class map10listarc { public: int tail, head;//弧尾节点序号，头节点序号 int info;//权重 map10listarc *h; map10listarc *t;//相同头，尾节点的弧链域 }arc; typedef cl...
经典算法题每日演练——第二十一题 十字链表
weixin_34087301的博客
04-02 1325
       上一篇我们看了矩阵的顺序存储，这篇我们再看看一种链式存储方法“十字链表”，当然目的都是一样，压缩空间。 一：概念     既然要用链表节点来模拟矩阵中的非零元素，肯定需要如下5个元素(row,col,val,down,right)，其中： row:矩阵中的行。 col:矩阵中的列。 val:矩阵中的值。 right:指向右侧的一个非零元素。 down：指向下侧的一个非...
有向图遍历，十字链表存储，深度遍历，广度遍历。
丶拾慌
12-31 2393
有向图遍历，十字链表存储，深度遍历，广度遍历。
数据结构——十字链表
RX_beginner的博客
09-22 9679
十字链表(Orthogonal List)是有向图的另一种链式存储结构。该结构可以看成是将有向图的邻接表和逆邻接表结合起来得到的。用十字链表来存储有向图，可以达到高效的存取效果。同时，代码的可读性也会得到提升。主要难点是理解到储存线信息的结构体中，连着和被连着必然只能与一个元素绑定，理解好这个就很容易写出。
十字链表的创建与遍历
Zyong139064359的博客
05-08 627
添加链接描述 运行了一下上面博客中的代码 ,也对其进行了标注.在运行代码的时候出现了一些错误 ,在代码中标注了 也进行了改正.下面附上代码: #include<stdio.h> #include<stdlib.h> #include<malloc.h> #define MaxVex 20 typedef int EdgeType;//定义弧信息的类型 typed...
C语言数据结构、十字链表的分析及实现
ZER00000001的博客
06-16 4451
结在上篇文章的最后，我们分析了邻接表的优劣，邻接表本身并没有什么大的缺陷，如果说有缺点，那么是对于有向图而言对同时表示一个顶点的出度和入度麻烦，因为需要有邻接表和逆邻接表同时表示，而且这种应用场景是存在的。十字链表就是为了使这个问题得到解决而出现的。所以十字链表就是一种将邻接表和逆邻接表结合在一起的一种图的存储结构，它针对的就是有向图中出度和入度一起使用的情况，并且大大节省了内存。十字链表是由数............
链表中遍历算法的流程图
最新发布
06-03
好的，我来为您解答。以下是链表遍历算法的流程图： ![链表遍历算法流程图](https://img-blog.csdnimg.cn/20211020144354360.png) 解释如下： 1. 从链表的头节点开始遍历。 2. 如果当前节点不为空，输出当前节点的值，并将当前节点指向下一个节点。 3. 如果当前节点为空，表示已经到达链表的尾部，遍历结束。 希望这个流程图能够帮助您更好地理解链表的遍历算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值