代码：

版本一：邻接矩阵

#include <iostream>
#include <memory.h>
#define max_n 1005
using namespace std;
int DFN[max_n];//记录dfs访问次序
int low[max_n];//记录节点最早可追溯到的祖先
int cnt = 0;//时间戳
int Stack[max_n];//模拟栈
int top = -1;//栈顶
int flag[max_n];//记录节点是否入栈
int number = 0;//强连通分量的个数
int j;//栈弹出节点
int G[max_n][max_n];//图的邻接矩阵
int n;//图的节点数目
void tarjan(int u)
{
    DFN[u] = low[u] = cnt++;//访问到这个节点打上时间戳
    Stack[++top] = u;//节点入栈
    flag[u] = 1;//节点已在栈内
    for(int i = 0;i<n;i++)
    {
        if(G[u][i])//如果u与i相连
        {
            if(!DFN[i])//如果i节点未被访问过
            {
                tarjan(u);//继续遍历
                low[u] = min(low[u],low[i]);//回溯时更新u点的最早祖先值
            }
            else if(flag[i]&&low[u]<DFN[i])//如果i被访问过，并且在栈内
            {
                low[u] = DFN[i];//更新u点的最早祖先值
            }
        }
        if(DFN[u]==low[u])//如果节点之后全访问完了以后，并且DFN值与最早公共祖先值相等，说明已经得到了一个强连通分量
        {
            number++;//强连通分量个数加一
            do
            {
                j = Stack[top--];//弹出栈中比该点后入栈的所有点
                cout << j << " ";
                flag[j] = 0;//节点不在栈中
            }while(j!=u);//直到把节点u也弹出
            cout << endl;
        }
    }
}

int main()
{
    memset(DFN,0,sizeof(DFN));
    memset(flag,0,sizeof(flag));
    memset(Stack,0,sizeof(Stack));
    for(int i = 1;i<=n;i++)//遍历多遍求出所有的强连通分量
    {
        if(DFN[i])
        {
            tarjan(i);
        }
    }
    return 0;
}

版本二：链式前向星

#include <iostream>
#include <cstring>
#include <stack>
#include <memory.h>
#define max_n 1005
using namespace std;
int n,m;//n为节点个数,m为边的数目
int idx=0;//时间戳
int Bcnt=0;//强连通分量的个数
int instack[max_n];//记录节点是否在栈内
int dfn[max_n];//dfs访问顺序标号
int low[max_n];//节点的最早公共祖先
int Belong[max_n];//存储节点属于哪一个强连通分量
stack<int> s;//dfs访问时的栈
//链式前向星结构
int head[max_n];
int cnt = 0;
struct
{
    int v;
    int next;
}e[max_n<<1];
void add(int u,int v)
{
    ++cnt;
    e[cnt].v = v;
    e[cnt].next = head[u];
    head[u] = cnt;
}
//读入数据
void readdata()
{
    int a,b;
    memset(head,0,sizeof(head));
    cin >> n >> m;
    for(int i = 0;i<m;i++)
    {
        cin >> a >> b;
        add(a,b);
    }
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++idx;
    s.push(u);
    instack[u] = 1;
    int v;
    for(int i = head[u];i;i=e[i].next)//遍历u的相连节点
    {
        v = e[i].v;
        if(!dfn[v])//如果未访问过
        {
            tarjan(v);
            low[u] = min(low[u],low[v]);//尝试更新u的low值
        }
        else if(instack[v])//如果被访问过且在栈中
        {
            low[u] = min(low[u],dfn[v]);//尝试更新u的low值
        }
    }
    if(low[u]==dfn[u])//找到一个联通分量
    {
        Bcnt++;
        do
        {
            v = s.top();
            s.pop();
            instack[v] = 0;
            Belong[v] = Bcnt;
        }while(u!=v);
    }
}
//结果处理
void solve()
{
    for(int i = 1;i<=n;i++)
    {
        if(!dfn[i])
        {
            tarjan(i);
        }
    }
    for(int i = 1;i<=n;i++)
    {
        cout << "d " << dfn[i] << " l " << low[i] << endl;
    }
    cout << Bcnt << "个强连通分量" << endl;
    for(int i = 1;i<=Bcnt;i++)
    {
        cout << "第 " << i << " 个" << endl;
        for(int j = 1;j<=n;j++)
        {
            if(Belong[j]==i)
            {
                cout << j << " ";
            }
        }
        cout << endl;
    }
}
int main()
{
    readdata();
    solve();
    return 0;
}

参考文章：

我大概整理了一下，这些博客会很有帮助

键盘里的青春，全网最!详!细!tarjan算法讲解，https://blog.csdn.net/qq_34374664/article/details/77488976（主要是原理，实例，我之前看了很多博客云里雾里的，这篇看懂了）