Ejemplo n.º 1
0
        public bool removerDado(Dado aExcluir)
        {
            if (existeDado(aExcluir)) // existeDado configurou
            {                         // atual e anterior
                quantosNos--;

                if (atual == primeiro)  // se vamos excluir o 1o nó
                {
                    primeiro = primeiro.Prox;
                    if (primeiro == null)  // esvaziou
                    {
                        ultimo = null;
                    }
                }
                else
                if (atual == ultimo)        // se vamos excluir o último nó
                {
                    ultimo      = anterior;
                    ultimo.Prox = null;
                }
                else
                {
                    anterior.Prox = atual.Prox;
                    atual.Prox    = null;
                }
                return(true);
            }
            return(false);
        }
Ejemplo n.º 2
0
        public void InserirAntesDoInicio(Dado novoDado)
        {
            var novoNo = new NoLista <Dado>(novoDado, primeiro);

            if (ultimo == null)
            {
                ultimo = novoNo;
            }

            primeiro = novoNo;
        }
Ejemplo n.º 3
0
 private void InserirAposFim(NoLista <Dado> noAntigo)
 {
     if (EstaVazia)
     {
         primeiro = noAntigo;
     }
     else
     {
         ultimo.Prox = noAntigo;
     }
     ultimo        = noAntigo;
     noAntigo.Prox = null;
     quantosNos++;
 }
Ejemplo n.º 4
0
        public void ordenar()
        {
            ListaSimples <Dado> ordenada = new ListaSimples <Dado>();

            while (!this.EstaVazia)
            {
                // achar o menor de todos
                // remover o menor de todos
                // incluir o menor de todos já removido na lista ordenada
            }
            this.primeiro   = ordenada.primeiro;
            this.ultimo     = ordenada.ultimo;
            this.quantosNos = ordenada.quantosNos;
        }
Ejemplo n.º 5
0
        private void InserirNoMeio(Dado dados)
        {
            var novo = new NoLista <Dado>(dados, null); // guarda dados no

            // novo nó
            // existeChave() encontrou intervalo de inclusão do novo nó
            anterior.Prox = novo;   // liga anterior ao novo
            novo.Prox     = atual;  // e novo no atual
            if (anterior == ultimo) // se incluiu ao final da lista,
            {
                ultimo = novo;      // atualiza o apontador ultimo
            }
            quantosNos++;           // incrementa número de nós da lista
        }
Ejemplo n.º 6
0
        public void InserirAposFim(Dado novoDado)
        {
            var novoNo = new NoLista <Dado>(novoDado, null);

            if (EstaVazia)
            {
                primeiro = novoNo;
            }
            else
            {
                ultimo.Prox = novoNo;
            }
            ultimo = novoNo;
            quantosNos++;
        }
Ejemplo n.º 7
0
        public Dado RemoverPrimeiro()
        {
            if (EstaVazia)
            {
                throw new Exception("Lista vazia!");
            }

            Dado o = primeiro.Info;

            primeiro = primeiro.Prox;
            if (primeiro == null)
            {
                ultimo = null;
            }
            quantosNos--;
            return(o);
        }
Ejemplo n.º 8
0
 public NoLista(Dado informacao, NoLista <Dado> ponteiro)
 {
     info = informacao;
     prox = ponteiro;
 }
Ejemplo n.º 9
0
 public ListaSimples()
 {
     primeiro   = ultimo = anterior = atual = null;
     quantosNos = 0;
     primeiroAcessoDoPercurso = false;
 }
Ejemplo n.º 10
0
        public bool existeDado(Dado outroProcurado)
        {
            anterior = null;
            atual    = primeiro;
            // Em seguida, é verificado se a lista está vazia. Caso esteja, é
            // retornado false ao local de chamada, indicando que a chave não foi
            // encontrada, e atual e anterior ficam valendo null
            if (EstaVazia)
            {
                return(false);
            }
            // a lista não está vazia, possui nós
            // dado procurado é menor que o primeiro dado da lista:
            // portanto, dado procurado não existe
            if (outroProcurado.CompareTo(primeiro.Info) < 0)
            {
                return(false);
            }
            // dado procurado é maior que o último dado da lista:
            // portanto, dado procurado não existe
            if (outroProcurado.CompareTo(ultimo.Info) > 0)
            {
                anterior = ultimo;
                atual    = null;
                return(false);
            }

// caso não tenha sido definido que a chave está fora dos limites de
// chaves da lista, vamos procurar no seu interior
// o apontador atual indica o primeiro nó da lista e consideraremos que
// ainda não achou a chave procurada nem chegamos ao final da lista
            bool achou = false;
            bool fim   = false;

            // repete os comandos abaixo enquanto não achou o RA nem chegou ao
            // final da lista
            while (!achou && !fim)
            {
                // se o apontador atual vale null, indica final da lista
                if (atual == null)
                {
                    fim = true;
                }
                // se não chegou ao final da lista, verifica o valor da chave atual
                else
                // verifica igualdade entre chave procurada e chave do nó atual
                if (outroProcurado.CompareTo(atual.Info) == 0)
                {
                    achou = true;
                }
                else
                // se chave atual é maior que a procurada, significa que
                // a chave procurada não existe na lista ordenada e, assim,
                // termina a pesquisa indicando que não achou. Anterior
                // aponta o anterior ao atual, que foi acessado por
                // último
                if (atual.Info.CompareTo(outroProcurado) > 0)
                {
                    fim = true;
                }
                else
                {
                    // se não achou a chave procurada nem uma chave > que ela,
                    // então a pesquisa continua, de maneira que o apontador
                    // anterior deve apontar o nó atual e o apontador atual
                    // deve seguir para o nó seguinte
                    anterior = atual;
                    atual    = atual.Prox;
                }
            }
            // por fim, caso a pesquisa tenha terminado, o apontador atual
            // aponta o nó onde está a chave procurada, caso ela tenha sido
            // encontrada, ou o nó onde ela deveria estar para manter a
            // ordenação da lista. O apontador anterior aponta o nó anterior
            // ao atual
            return(achou); // devolve o valor da variável achou, que indica
        } // se a chave procurada foi ou não encontrado