public void Empilhar(Dado o)
{
NoLista <Dado> novoNo = new NoLista <Dado>(o, topo);
topo = novoNo;
tamanho++;
}
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--;
}
}
public void Empilhar(Dado o)
{
NoLista <Dado> novoNo = new NoLista <Dado>(o, topo);
topo = novoNo; // topo passa a apontar o novo nó
tamanho++; // atualiza número de elementos na pilha
}
} // 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
}
}
}
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)
}
public PilhaLista(PilhaLista <Dado> modelo)
{
if (modelo == null)
{
throw new Exception("Modelo ausente");
}
this.topo = (NoLista <Dado>)modelo.topo.Clone();
this.tamanho = modelo.tamanho;
}
public Dado Desempilhar()
{
if (EstaVazia())
{
throw new PilhaVaziaException("Underflow da pilha");
}
Dado o = topo.Info;
topo = topo.Prox;
tamanho--;
return(o);
}
// exercicio 3
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>();
}
public void Inverter()
{
PilhaLista <Dado> aux = new PilhaLista <Dado>();
while (!EstaVazia())
{
aux.Empilhar(Desempilhar());
}
this.topo = aux.topo;
this.tamanho = aux.tamanho;
}
public Tipo retirar()
{
if (!estaVazia())
{
Tipo elemento = base.Primeiro.Info;
NoLista <Tipo> pri = base.Primeiro;
NoLista <Tipo> ant = null;
base.RemoverNo(ref pri, ref ant);
return(elemento);
}
throw new FilaVaziaException("Fila vazia");
}
public Dado Desempilhar()
{
if (EstaVazia())
{
throw new Exception("Underflow da pilha");
}
Dado o = topo.Info; // obtém o objeto do topo
topo = topo.Prox; // avança topo para o nó seguinte
tamanho--; // atualiza número de elementos na pilha
return(o); // devolve o objeto que estava no topo
}
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 }
}
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
}
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);
}
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);
}
}
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;
}
}
}
public bool ExisteDado(Dado outroProcurado)
{
if (outroProcurado == null)
{
throw new Exception("Informação ausente");
}
NoLista <Dado> atual = this.primeiro;
while (atual != null)
{
if (atual.Info.Equals(outroProcurado))
{
return(true);
}
atual = atual.Prox;
}
return(false);
}
// exercício 4
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;
}
}
public bool Existe(Dado dado)
{
PilhaLista <Dado> pilhaAux = Clone();
while (!EstaVazia())
{
if (OTopo().CompareTo(dado) == 0)
{
this.topo = pilhaAux.topo;
this.tamanho = pilhaAux.tamanho;
return(true);
}
Desempilhar();
}
this.topo = pilhaAux.topo;
this.tamanho = pilhaAux.tamanho;
return(false);
}
public NoLista(Dado novaInfo, NoLista <Dado> proximo)
{
Info = novaInfo;
prox = proximo;
}
public void Empilhar(Dado o)
{
NoLista <Dado> novoNo = new NoLista <Dado>(o, null);
InserirAntesDoInicio(novoNo);
}
public Grafo(NoLista nos)
{
this.nos = nos;
}
public Grafo()
{
this.nos = new NoLista();
}
public void Enfileirar(Dado elemento) // inclui objeto “elemento”
{
NoLista <Dado> novoNo = new NoLista <Dado>(elemento, null);
base.InserirAposFim(novoNo);
}
public PilhaLista(PilhaLista <Dado> model)
{
this.topo = model.topo;
this.tamanho = model.tamanho;
}
public ListaSimples()
{
primeiro = ultimo = anterior = atual = null;
quantosNos = 0;
primeiroAcessoDoPercurso = false;
}
public PilhaLista()
{ // construtor
topo = null;
tamanho = 0;
}
public ListaSimples()
{
primeiro = ultimo = anterior = atual = null;
quantosNos = 0;
}
public NoLista(Dado info, NoLista <Dado> prox)
{
Info = info;
Prox = prox;
}
public void enfileirar(Tipo elemento)
{
NoLista <Tipo> novoNo = new NoLista <Tipo>(elemento, null);
base.InserirAposFim(novoNo); // inclui ao final da lista herdada
}
private No MenorCaminho(NoLista nos)
{
int menorDistancia = Int32.MaxValue;
No menorNo = null;
foreach(No n in nos)
{
if(((int) distancia[n.Chave])<=menorDistancia)
{
menorDistancia = (int)distancia[n.Chave];
menorNo = n;
}
}
return menorNo;
}
public PilhaLista()
{
topo = null;
tamanho = 0;
}
