GraphMatrix.cs

using System.Collections.Generic;
using System.Linq;

namespace Code.Graph;

/// <summary>
/// Graph represented as a matrix
/// </summary>
public class GraphMatrix<T>
{
    private readonly bool directed;
    private readonly bool weighted;
    private List<T> VertexList;
    private int[,] Matrix;

    /// <summary>
    /// Initialize graph with vertex list.
    /// </summary>
    /// <param name="vertexList"></param>
    /// <param name="directed"></param>
    /// <param name="weighted"></param>
    public GraphMatrix(T[] vertexList, bool directed = false, bool weighted = false)
    {
        this.directed = directed;
        this.weighted = weighted;
        VertexList = vertexList.ToList();
        Matrix = new int[vertexList.Length, vertexList.Length];
    }

    /// <summary>
    /// Add an edge to the graph.
    /// </summary>
    /// <param name="startIndex"></param>
    /// <param name="endIndex"></param>
    /// <param name="weight"></param>
    public void AddEdge(int startIndex, int endIndex, int weight = 1) {
        int edgeWeight = weighted ? weight : 1;
        Matrix[startIndex, endIndex] = edgeWeight;
        if (!directed) {
            Matrix[endIndex, startIndex] = edgeWeight;
        }
    }

    /// <summary>
    /// Remove an edge from the graph.
    /// </summary>
    /// <param name="startIndex"></param>
    /// <param name="endIndex"></param>
    public void RemoveEdge(int startIndex, int endIndex) {
        Matrix[startIndex, endIndex] = 0;
        if (!directed) {
            Matrix[endIndex, startIndex] = 0;
        }
    }

    /// <summary>
    /// Add a vertex to the graph.
    /// </summary>
    /// <param name="vertex"></param>
    public void AddVertex(T vertex) { 
        VertexList.Add(vertex); 

        int[,] newMatrix = new int[VertexList.Count, VertexList.Count];
        for (int i = 0; i < Matrix.GetLength(0); i++) {
            for (int j = 0; j < Matrix.GetLength(1); j++) {
                newMatrix[i, j] = Matrix[i, j];
            }
        }
        Matrix = newMatrix;
    }

    /// <summary>
    /// Remove a vertex from the graph.
    /// </summary>
    /// <param name="vertex"></param>
    public void RemoveVertex(T vertex) {
        int indexToRemove = VertexList.IndexOf(vertex);
        if(indexToRemove == -1) {
            return;
        }

        VertexList.RemoveAt(indexToRemove);

        int[,] newMatrix = new int[VertexList.Count, VertexList.Count];
        int newRow = 0, newCol;
        for (int i = 0; i < Matrix.GetLength(0); i++) {
            if( i == indexToRemove) continue;
            newCol = 0;
            for (int j = 0; j < Matrix.GetLength(1); j++) {
                if(j == indexToRemove) continue;
                newMatrix[newRow, newCol] = Matrix[i, j];
                newCol++;
            }
            newRow++;
        }
        Matrix = newMatrix;
    }

    public int[,] GetMatrix() 
    {
        return Matrix;
    }

    public List<T> GetVertexList() 
    {
        return VertexList;  
    }

    public bool Directed()
    {
        return directed;
    }

    public bool Weighted()
    {
        return weighted;
    }
}