Exemple #1
0
        public void RemoverNo(ref NoLista <Dado> atual, ref NoLista <Dado> anterior)
        {
            if (!EstaVazia)
            {
                if (atual == primeiro)
                {
                    primeiro = primeiro.Prox;
                    if (EstaVazia)
                    {
                        ultimo = null;
                    }
                }
                else
                if (atual == ultimo)
                {
                    ultimo      = anterior;
                    ultimo.Prox = null;
                }
                else
                {
                    anterior.Prox = atual.Prox;
                }

                quantosNos--;
            }
        }
Exemple #2
0
        }                  // se a chave procurada foi ou não encontrado

        public void InserirEmOrdem(Dado dados)
        {
            if (!ExisteDado(dados))             // existeChave configura anterior e atual
            {                                   // aqui temos certeza de que a chave não existe
                                                // guarda dados no novo nó
                var novo = new NoLista <Dado>(dados, null);
                if (EstaVazia)                  // se a lista está vazia, então o
                {
                    InserirAntesDoInicio(novo); // novo nó é o primeiro da lista
                }
                else
                // testa se nova chave < primeira chave
                if (anterior == null && atual != null)
                {
                    InserirAntesDoInicio(novo); // liga novo antes do primeiro
                }
                else
                // testa se nova chave > última chave
                if (anterior != null && atual == null)
                {
                    InserirAposFim(novo);
                }
                else
                {
                    InserirNoMeio(novo);  // insere entre os nós anterior e atual
                }
            }
        }
Exemple #3
0
 public void InserirAntesDoInicio(NoLista <Dado> novoNo)
 {
     if (EstaVazia)          // se a lista está vazia, estamos
     {
         ultimo = novoNo;    // incluindo o 1o e o último nós!
     }
     novoNo.Prox = primeiro; // faz o novo nó apontar para o nó
     primeiro    = novoNo;   // atualmente no início da lista
     quantosNos++;           // (que pode ser null)
 }
Exemple #4
0
        public void CasamentoCom(ListaSimples <Dado> outra,
                                 ref ListaSimples <Dado> nova)
        {
            nova = new ListaSimples <Dado>();
            NoLista <Dado> a = null,
                           b = null;

            while (!this.EstaVazia && !outra.EstaVazia)
            {
                a = this.primeiro;
                b = outra.primeiro;

                if (a.Info.CompareTo(b.Info) < 0)
                {
                    this.quantosNos--;
                    this.primeiro = this.primeiro.Prox; // avança na lista 1
                    nova.InserirAposFim(a);
                }
                else
                if (b.Info.CompareTo(a.Info) < 0)
                {
                    outra.quantosNos--;
                    outra.primeiro = outra.primeiro.Prox; // avança na lista 2
                    nova.InserirAposFim(b);
                }
                else
                {
                    this.quantosNos--;
                    outra.quantosNos--;
                    this.primeiro  = this.primeiro.Prox;  // avança na lista 1
                    outra.primeiro = outra.primeiro.Prox; // avança na lista 2
                    nova.InserirAposFim(a);
                }
            }
            if (!this.EstaVazia)  // não acabou a lista 1
            {
                nova.ultimo.Prox = this.primeiro;
                nova.ultimo      = this.ultimo;
                nova.quantosNos += this.quantosNos;
            }

            if (!outra.EstaVazia)
            {
                nova.ultimo.Prox = outra.primeiro;
                nova.ultimo      = outra.ultimo;
                nova.quantosNos += outra.quantosNos;
            }

            this.primeiro   = this.ultimo = null;
            this.quantosNos = 0;

            outra = new ListaSimples <Dado>();
        }
Exemple #5
0
        private void InserirNoMeio(NoLista <Dado> novo)
        {
            // existeDado() 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        }
        }
Exemple #6
0
        public Dado Desempilhar()
        {
            if (EstaVazia)
            {
                throw new PilhaVaziaException("pilha vazia!");
            }

            Dado valor = base.Primeiro.Info;

            NoLista <Dado> pri = base.Primeiro;
            NoLista <Dado> ant = null;

            base.RemoverNo(ref pri, ref ant);
            return(valor);
        }
Exemple #7
0
        public void InserirAposFim(NoLista <Dado> novoNo)
        {
            if (EstaVazia)
            {
                primeiro = novoNo;
            }
            else
            {
                ultimo.Prox = novoNo;
            }

            quantosNos++;
            ultimo      = novoNo;
            ultimo.Prox = null; // garantimos final lógico da lista
        }
Exemple #8
0
        public void Ordenar()
        {
            ListaSimples <Dado> ordenada     = new ListaSimples <Dado>();
            NoLista <Dado>      menorDeTodos = null,
                                antesDoMenor = null;

            while (!this.EstaVazia)
            {
                ProcurarMenorDado(ref menorDeTodos, ref antesDoMenor);

                NoLista <Dado> novoNo = menorDeTodos;
                this.RemoverNo(ref menorDeTodos, ref antesDoMenor);

                ordenada.InserirAposFim(novoNo);
            }
        }
Exemple #9
0
        private void ProcurarMenorDado
            (ref NoLista <Dado> menorAteAgora,
            ref NoLista <Dado> anteriorAoMenor)
        {
            menorAteAgora   = primeiro;
            anteriorAoMenor = null;

            IniciarPercursoSequencial();
            while (PodePercorrer())
            {
                if (atual.Info.CompareTo(menorAteAgora.Info) < 0)
                {
                    anteriorAoMenor = anterior;
                    menorAteAgora   = atual;
                }
            }
        }
Exemple #10
0
 public void Inverter()
 {
     if (quantosNos > 1)
     {
         NoLista <Dado> um = primeiro;
         ultimo = primeiro;
         NoLista <Dado> dois = primeiro.Prox;
         NoLista <Dado> tres = null;
         while (dois != null)
         {
             tres      = dois.Prox;
             dois.Prox = um;
             um        = dois;
             dois      = tres;
         }
         primeiro    = um;
         ultimo.Prox = null;
     }
 }
Exemple #11
0
 public ListaSimples()
 {
     primeiro   = ultimo = anterior = atual = null;
     quantosNos = 0;
     primeiroAcessoDoPercurso = false;
 }
Exemple #12
0
 public NoLista(Dado novaInfo, NoLista <Dado> proximo)
 {
     Info = novaInfo;
     prox = proximo;
 }