Exemplo n.º 1
0
        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);
        }
Exemplo n.º 5
0
        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;
 }
Exemplo n.º 8
0
 public Celula()
 {
     direita = null;
     abaixo  = null;
     valor   = 0;
 }