예제 #1
0
        public void removerNo(NoLista <Tipo> qualNo, NoLista <Tipo> noAnterior)
        {
            if (!estaVazia())
            {
                if (qualNo == primeiro)
                {
                    primeiro = primeiro.prox;
                    if (primeiro == null) // só havia um único nó
                    {
                        ultimo = null;
                    }
                }
                else
                if (qualNo == ultimo)
                {
                    noAnterior.prox = null;
                    ultimo          = noAnterior;
                }
                else
                {
                    noAnterior.prox = qualNo.prox;
                    qualNo.prox     = null;
                }

                qualNo = null;
                --quantosNos;
            }
        }
예제 #2
0
        // exercício 2 : na aplicação

        // exercício 3 : casamento de listas

        public ListaSimples <Tipo> casamento(ListaSimples <Tipo> outra)
        {
            ListaSimples <Tipo> nova = new ListaSimples <Tipo>();

            iniciarPercursoSequencial();  // lista this
            outra.iniciarPercursoSequencial();

            while (!estaVazia() && !outra.estaVazia())
            {
                switch (outra.atual.info.CompareTo(this.atual.info))
                {
                case -1:
                    outra.primeiro   = outra.primeiro.prox;
                    outra.atual.prox = null;
                    nova.insereAposFim(outra.atual);
                    outra.atual = outra.primeiro;
                    outra.QtosNos--;
                    break;

                case 0:
                    outra.primeiro   = outra.primeiro.prox;
                    outra.atual.prox = null;
                    nova.insereAposFim(outra.atual);
                    outra.atual = outra.primeiro;
                    outra.QtosNos--;

                    this.primeiro   = this.primeiro.prox;
                    this.atual.prox = null;
                    this.atual      = this.primeiro;
                    this.QtosNos--;
                    break;

                case 1:
                    this.primeiro   = this.primeiro.prox;
                    this.atual.prox = null;
                    nova.insereAposFim(this.atual);
                    this.atual = this.primeiro;
                    this.QtosNos--;
                    break;
                }
            }

            if (this.estaVazia())
            {
                nova.ultimo.prox = outra.primeiro;
                nova.ultimo      = outra.ultimo;
                nova.QtosNos     = nova.QtosNos + outra.QtosNos;
            }
            else
            if (outra.estaVazia())
            {
                nova.ultimo.prox = this.primeiro;
                nova.ultimo      = this.ultimo;
                nova.QtosNos    += this.QtosNos;
            }

            return(nova);
        }
예제 #3
0
        public void insereAntesDoInicio(NoLista <Tipo> novoNo)
        {
            if (estaVazia())
            {
                ultimo = novoNo;
            }

            novoNo.prox = primeiro;
            primeiro    = novoNo;
            quantosNos++;
        }
예제 #4
0
        public void insereAposFim(NoLista <Tipo> novoNo)
        {
            if (estaVazia())
            {
                primeiro = novoNo;
            }
            else
            {
                ultimo.prox = novoNo;
            }

            novoNo.prox = null;
            ultimo      = novoNo;
            ++quantosNos;
        }
예제 #5
0
        public void ordenar()
        {
            NoLista <Tipo>      menor = null, antMenor = null;
            ListaSimples <Tipo> ordenada = new ListaSimples <Tipo>();

            while (!estaVazia())
            {
                encontrarMenor(ref antMenor, ref menor);
                removerMenorNo(antMenor, menor);
                ordenada.insereAposFim(menor);
            }
            primeiro = ordenada.primeiro;
            ultimo   = ordenada.ultimo;
            QtosNos  = ordenada.QtosNos;
        }
예제 #6
0
        public void insereAposNo(NoLista <Tipo> qualNo, NoLista <Tipo> novoNo)
        {
            if ((qualNo == null) || estaVazia())
            {
                throw new Exception("Local inválido para inserção");
            }

            novoNo.prox = qualNo.prox;
            qualNo.prox = novoNo;
            ++quantosNos;

            if (qualNo == ultimo)
            {
                ultimo = novoNo;
            }
        }
예제 #7
0
        private void encontrarMenor(ref NoLista <Tipo> oAntMenor,
                                    ref NoLista <Tipo> oMenor)
        {
            oMenor    = atual = primeiro;
            oAntMenor = anterior = null;

            while (atual != null)
            {
                if (atual.info.CompareTo(oMenor.info) < 0)
                {
                    oAntMenor = anterior;
                    oMenor    = atual;
                }
                anterior = atual;
                atual    = atual.prox;
            }
        }
예제 #8
0
        // exercício 4 : inversão de lista
        public void inverter()
        {
            if (!estaVazia())
            {
                NoLista <Tipo> um   = null,
                               dois = primeiro,
                               tres = primeiro.prox;
                while (um != ultimo)
                {
                    dois.prox = um;
                    um        = dois;
                    dois      = tres;
                    if (tres.prox != null)
                    {
                        tres = tres.prox;
                    }
                }

                tres     = primeiro;
                primeiro = um;
                ultimo   = tres;
            }
        }
예제 #9
0
 public void insereEmOrdem(NoLista <Tipo> novoNo)
 {
     if (estaVazia())
     {
         insereAntesDoInicio(novoNo);
     }
     else
     if (anterior == ultimo)
     {
         insereAposFim(novoNo);
     }
     else
     if (anterior == null)
     {
         insereAntesDoInicio(novoNo);
     }
     else
     {
         novoNo.prox   = atual;
         anterior.prox = novoNo;
         ++quantosNos;
     }
 }
예제 #10
0
 public void removerMenorNo(NoLista <Tipo> ant,
                            NoLista <Tipo> qual)
 {
     if (ant == null)  // ou atual == primeiro
     {
         primeiro = primeiro.prox;
         if (primeiro == null)
         {
             ultimo = null;  // estaziou a lista
         }
     }
     else
     if (qual == ultimo)      // vamos remover o menor nó
     {
         ultimo   = ant;
         ant.prox = null;
     }
     else
     {
         ant.prox  = qual.prox;
         qual.prox = null;
     }
     quantosNos--;
 }
예제 #11
0
 public ListaSimples()
 {
     primeiro   = ultimo = anterior = atual = null;
     quantosNos = 0;
     primeiroAcessoDoPercurso = false;
 }
예제 #12
0
 public NoLista(Tipo novaInfo,
                NoLista <Tipo> proximo)
 {
     info = novaInfo;
     prox = proximo;
 }