使用c++定义一有n个结点的的以邻接矩阵为存储方式的网（有向或无向均可），并对其进行如下操作： 1.深度优先遍历，并输出遍历序列； 2.广度优先遍历，并输出遍历序列； 3.求源点到图中每个点的最短路径，并输出

以下是使用 C++ 定义一个邻接矩阵存储方式的有向网，并进行深度优先遍历、广度优先遍历以及求源点到图中每个点的最短路径的示例代码。示例代码中使用了邻接矩阵来存储网，网中每个结点的编号从 0 开始。

#include <iostream>
#include <queue>
#include <stack>
#include <cstring>
using namespace std;

const int MAXN = 100;

// 邻接矩阵存储方式的有向网
class Graph {
private:
    int n;  // 网中结点的个数
    int matrix[MAXN][MAXN];  // 邻接矩阵
public:
    Graph(int n) {
        this->n = n;
        memset(matrix, 0, sizeof(matrix));
    }

    void addEdge(int u, int v, int weight) {
        matrix[u][v] = weight;
    }

    // 深度优先遍历
    void dfs(int start) {
        bool visited[MAXN];  // 标记结点是否访问过
        memset(visited, false, sizeof(visited));
        stack<int> s;
        s.push(start);
        visited[start] = true;
        while (!s.empty()) {
            int cur = s.top();
            s.pop();
            cout << cur << " ";
            for (int i = 0; i < n; i++) {
                if (matrix[cur][i] != 0 && !visited[i]) {
                    s.push(i);
                    visited[i] = true;
                }
            }
        }
    }

    // 广度优先遍历
    void bfs(int start) {
        bool visited[MAXN];  // 标记结点是否访问过
        memset(visited, false, sizeof(visited));
        queue<int> q;
        q.push(start);
        visited[start] = true;
        while (!q.empty()) {
            int cur = q.front();
            q.pop();
            cout << cur << " ";
            for (int i = 0; i < n; i++) {
                if (matrix[cur][i] != 0 && !visited[i]) {
                    q.push(i);
                    visited[i] = true;
                }
            }
        }
    }

    // 求源点到图中每个点的最短路径
    void shortestPath(int start) {
        int dist[MAXN];  // 存储源点到各个结点的最短距离
        bool visited[MAXN];  // 标记结点是否访问过
        memset(dist, 0x3f, sizeof(dist));
        memset(visited, false, sizeof(visited));
        dist[start] = 0;
        visited[start] = true;
        for (int i = 0; i < n; i++) {
            if (matrix[start][i] != 0) {
                dist[i] = matrix[start][i];
            }
        }
        for (int i = 1; i < n; i++) {
            int minDist = 0x3f;
            int minIdx = -1;
            for (int j = 0; j < n; j++) {
                if (!visited[j] && dist[j] < minDist) {
                    minDist = dist[j];
                    minIdx = j;
                }
            }
            if (minIdx == -1) break;
            visited[minIdx] = true;
            for (int j = 0; j < n; j++) {
                if (matrix[minIdx][j] != 0 && dist[j] > dist[minIdx] + matrix[minIdx][j]) {
                    dist[j] = dist[minIdx] + matrix[minIdx][j];
                }
            }
        }
        for (int i = 0; i < n; i++) {
            cout << "源点到结点 " << i << " 的最短路径长度为：" << dist[i] << endl;
        }
    }
};

int main() {
    Graph g(5);
    g.addEdge(0, 1, 1);
    g.addEdge(0, 2, 3);
    g.addEdge(1, 2, 1);
    g.addEdge(1, 3, 2);
    g.addEdge(2, 3, 4);
    g.addEdge(2, 4, 1);
    g.addEdge(3, 4, 1);

    cout << "深度优先遍历结果为：";
    g.dfs(0);
    cout << endl;

    cout << "广度优先遍历结果为：";
    g.bfs(0);
    cout << endl;

    cout << "源点为 0，求最短路径结果为：" << endl;
    g.shortestPath(0);

    return 0;
}

输出结果为：

深度优先遍历结果为：0 2 4 3 1 
广度优先遍历结果为：0 1 2 3 4 
源点为 0，求最短路径结果为：
源点到结点 0 的最短路径长度为：0
源点到结点 1 的最短路径长度为：1
源点到结点 2 的最短路径长度为：2
源点到结点 3 的最短路径长度为：3
源点到结点 4 的最短路径长度为：3