public Celula(Celula outraDireita, Celula outraAbaixo, int outraLinha, int outraColuna, double outroValor)
{
if (outraAbaixo == null || outraColuna < 0 || outraDireita == null || outraLinha < 0)
{
throw new Exception("Um ou mais valores inválidos");
}
this.direita = outraDireita;
this.abaixo = outraAbaixo;
this.linha = outraLinha;
this.coluna = outraColuna;
this.valor = outroValor;
}
/// <summary>
/// Remove uma célula onde está linha/coluna.
/// </summary>
/// <param name="linha"></param>
/// <param name="coluna"></param>
public bool RemoverEm(int linha, int coluna)
{
if (linha < 0 || linha >= Linhas ||
coluna < 0 || coluna >= Colunas)
{
throw new ArgumentOutOfRangeException("Linha ou Coluna fora do intervalo de remoção");
}
if (ValorDe(linha, coluna) == ValorPadrao)
{
return(false); // não há nada para remover
}
Celula colunaCabeca = cabecaPrincipal;
Celula linhaCabeca = cabecaPrincipal;
for (int j = 0; j <= coluna; j++)
{
colunaCabeca = colunaCabeca.Direita;
}
for (int i = 0; i <= linha; i++)
{
linhaCabeca = linhaCabeca.Abaixo;
}
Celula anterior = linhaCabeca;
Celula atual = linhaCabeca.Direita; // atual posicionará na célula que será removida
while (atual.Coluna < coluna && atual.Coluna != -1)
{
anterior = atual;
atual = atual.Direita;
}
anterior.Direita = atual.Direita;
// percorre as colunas para acertar as ligações necessárias
Celula percursoColuna = colunaCabeca;
while (percursoColuna.Abaixo != atual)
{
percursoColuna = percursoColuna.Abaixo;
}
percursoColuna.Abaixo = atual.Abaixo;
return(true);
}
/// <summary>
/// Construtor da matriz esparsa. Recebe a quantidade de linhas e colunas que
/// a matriz deverá conter. Cria a estrutura da matriz esparsa (células cabeça).
/// </summary>
/// <param name="linhas"></param>
/// <param name="colunas"></param>
public ListaLigadaCruzada(int linhas, int colunas)
{
if (linhas <= 0 || colunas <= 0)
{
throw new ArgumentOutOfRangeException("Quantidade de linhas/colunas não podem ser 0 ou negativo.");
}
this.linhas = linhas;
this.colunas = colunas;
cabecaPrincipal = new Celula(null, -1, -1);
// inicia o percurso para criar as linhas da matriz
Celula percurso = cabecaPrincipal;
for (int i = 0; i < linhas; i++)
{
Celula linhaCabeca = new Celula(null, i, -1);
percurso.Abaixo = linhaCabeca;
percurso.Direita = percurso;
percurso = percurso.Abaixo;
}
percurso.Abaixo = cabecaPrincipal;
percurso.Direita = percurso;
// inicia outro percurso para criar as colunas da matriz
percurso = cabecaPrincipal;
for (int i = 0; i < colunas; i++)
{
Celula colunaCabeca = new Celula(null, -1, i);
// verifica se é a cabecaPrincipal para não perder
// a lista das linhas
if (percurso != cabecaPrincipal)
{
percurso.Abaixo = percurso;
}
percurso.Direita = colunaCabeca;
percurso = percurso.Direita;
}
percurso.Abaixo = percurso;
percurso.Direita = cabecaPrincipal;
}
/// <summary>
/// Faz a soma de duas matrizes esparsas.
/// </summary>
/// <param name="outraMatriz"></param>
/// <returns>Uma matriz esparsa representando a soma.</returns>
public ListaLigadaCruzada SomarMatrizes(ListaLigadaCruzada outraMatriz)
{
if (this.linhas != outraMatriz.linhas || this.colunas != outraMatriz.colunas)
{
throw new ArgumentException("As Matrizes dever ser de mesma dimensão!");
}
ListaLigadaCruzada soma = new ListaLigadaCruzada(this.linhas, this.colunas);
Celula atual = this.cabecaPrincipal.Abaixo.Direita;
// Copia a matriz this na matriz soma
for (int l = 0; l < this.linhas; l++)
{
for (int c = atual.Coluna; c >= 0; c = atual.Coluna)
{
if (atual.Valor != null)
{
atual = atual.Direita;
soma.InserirElemento(this.ValorDe(l, c), l, c);
}
}
atual = atual.Abaixo.Direita;
}
atual = outraMatriz.cabecaPrincipal.Abaixo.Direita;
for (int l = 0; l < outraMatriz.linhas; l++)
{
for (int c = atual.Coluna; c >= 0; c = atual.Coluna)
{
if (atual.Valor != null)
{
double elem = soma.ValorDe(l, c) != 0 ? soma.ValorDe(l, c) + outraMatriz.ValorDe(l, c)
: outraMatriz.ValorDe(l, c);
soma.InserirElemento(elem, l, c);
atual = atual.Direita;
}
}
atual = atual.Abaixo.Direita;
}
return(soma);
}
public void FazerLeitura(ref ListaCruzada matrizM)
{
string[] instanciacao; //variável que será utilizada para instanciar uma matriz com os respcetivos valores x e y
if (dlgAbrir.ShowDialog() == DialogResult.OK)
{
arquivoMatriz1 = dlgAbrir.FileName;
var arquivo = new StreamReader(arquivoMatriz1);
instanciacao = arquivo.ReadLine().Split(); //a primeira linha do arquivo nos indicará qual será o tamanho dessa matriz
matrizM = new ListaCruzada(Convert.ToInt32(instanciacao[0]), Convert.ToInt32(instanciacao[1])); //após ler a primeira linha, utilizamos os valores dela para instanciar a matriz
while (!arquivo.EndOfStream) //o arquivo será lido completamente e criaremos as células passadas pelo arquivo
{
Celula lido = Celula.LerRegistro(arquivo);
matrizM.Inserir(lido.Linha, lido.Coluna, lido.Valor);
}
arquivo.Close();
}
}
/// <summary>
/// Representa a matriz esparsa com as células que são diferentes de ValorPadrao.
/// </summary>
/// <returns>String com o valor e as coordenadas das células diferente de ValorPadrao.</returns>
public override string ToString()
{
String ret = "{ ";
Celula linhaCabeca = cabecaPrincipal.Abaixo;
while (linhaCabeca != cabecaPrincipal)
{
Celula percursoLinha = linhaCabeca.Direita;
while (percursoLinha != linhaCabeca)
{
ret += percursoLinha.ToString() + (percursoLinha.Direita != linhaCabeca ? ", " : " ");
percursoLinha = percursoLinha.Direita;
}
linhaCabeca = linhaCabeca.Abaixo;
}
return(ret + "}");
}
/// <summary>
/// Exclui a matriz e desaloca da memória as células.
/// </summary>
public void ApagarMatriz()
{
cabecaPrincipal = null;
linhas = 0;
colunas = 0;
}
public Celula()
{
direita = null;
abaixo = null;
valor = 0;
}
