/// <summary>
/// Localiza o Item passado por parâmetro e o remove da Lista
/// </summary>
/// <param name="ValorItem">Item a ser removido da lista.</param>
public void Remove(Object ValorItem)
{
if (Primeira != Ultima)
{
CCelula aux = Primeira;
bool achou = false;
while (aux.Prox != null && !achou)
{
achou = aux.Prox.Item.Equals(ValorItem);
if (!achou)
{
aux = aux.Prox;
}
}
if (achou) // achou o elemento
{
aux.Prox = aux.Prox.Prox;
if (aux.Prox == null)
{
Ultima = aux;
}
Qtde--;
}
}
}
/// <summary>
/// Torna possível iterar sobre a CPilha usando o comando foreach
/// </summary>
public IEnumerator GetEnumerator()
{
for (CCelula aux = Topo; aux != null; aux = aux.Prox)
{
yield return(aux.Item);
}
}
/// <summary>
/// Imprime todos os elementos da lista usando o comando for
/// </summary>
public void ImprimeFor()
{
for (CCelula aux = Primeira.Prox; aux != null; aux = aux.Prox)
{
Console.Write(aux.Item);
}
}
/// <summary>
/// Função construtora.
/// </summary>
public CPilha(int Tamanho)
{
for (int i = 0; i < Tamanho; i++)
{
this.Topo = new CCelula();
}
}
/// <summary>
/// Função construtora. Cria a célula cabeça e faz as referências Frente e Tras apontarem para ela.
/// </summary>
public CFila(int Tamanho)
{
for (int i = 0; i < Tamanho; i++)
{
Frente = new CCelula();
}
Tras = Frente;
}
/// <summary>
/// Função construtora. Aloca a célula cabeça e faz todas as referências apontarem para ela.
/// </summary>
public CLista(int Tamanho)
{
for (int i = 0; i < Tamanho; i++)
{
Primeira = new CCelula();
}
Ultima = Primeira;
}
/// <summary>
/// Remove o primeiro Item da lista fazendo com que a célula seguinte à célula cabeça se torne a nova célula cabeça. Não retorna o Item removido.
/// </summary>
public void RemoveComecoSemRetorno()
{
if (Primeira != Ultima)
{
Primeira = Primeira.Prox;
Qtde--;
}
}
/// <summary>
/// Imprime os elementos da fila.
/// </summary>
public void mostra()
{
Console.Write("[ ");
for (CCelula c = Frente.Prox; c != null; c = c.Prox)
{
Console.Write(c.Item + " ");
}
Console.WriteLine("] ");
}
/// <summary>
/// Imprime todos os elementos simulando formato de lista: [/]->[7]->[21]->[13]->null
/// </summary>
public void ImprimeFormatoLista()
{
Console.Write("[/]->");
for (CCelula aux = Primeira.Prox; aux != null; aux = aux.Prox)
{
Console.Write("[" + aux.Item.ToString() + "]->");
}
Console.WriteLine("null");
}
/// <summary>
/// Insere um novo Item no começo da lista.
/// </summary>
/// <param name="ValorItem">O Item a ser inserido.</param>
public void InsereComeco(Object ValorItem)
{
Primeira.Prox = new CCelula(ValorItem, Primeira.Prox);
if (Primeira.Prox.Prox == null)
{
Ultima = Primeira.Prox;
}
Qtde++;
}
/// <summary>
/// Imprime todos os elementos da lista usando o comando while
/// </summary>
public void Imprime(bool ItemPorLinha)
{
CCelula aux = Primeira.Prox;
while (aux != null)
{
Console.WriteLine(aux.Item);
aux = aux.Prox;
}
}
/// <summary>
/// Verifica se o Item passado como parâmetro está contido na lista. (Obs: usa o comando FOR)
/// </summary>
/// <param name="elemento">Um object contendo o Item a ser localiado.</param>
/// <returns>Retorna TRUE caso o Item esteja presente na lista.</returns>
public bool ContemFor(Object elemento)
{
bool achou = false;
for (CCelula aux = Topo; aux != null && !achou; aux = aux.Prox)
{
achou = aux.Item.Equals(elemento);
}
return(achou);
}
/// <summary>
/// Remove e retorna o primeiro Item da lista (remoção lógica, ou seja, remove a célula cabeça fazendo com que a célula seguinte ela se torne a nova célula cabeça).
/// </summary>
/// <returns>Um Object contendo o Item removido ou null caso a lista esteja vazia.</returns>
public Object RemoveRetornaComecoSimples()
{
// Verifica se há elementos na lista
if (Primeira != Ultima)
{
Primeira = Primeira.Prox;
Qtde--;
return(Primeira.Item);
}
return(null);
}
/// <summary>
/// Verifica se o Item passado como parâmetro está contido na lista.
/// </summary>
/// <param name="elemento">Um object contendo o Item a ser localiado.</param>
/// <returns>Retorna TRUE caso o Item esteja presente na lista.</returns>
public bool Contem(Object elemento)
{
bool achou = false;
CCelula aux = Topo;
while (aux != null && !achou)
{
achou = aux.Item.Equals(elemento);
aux = aux.Prox;
}
return(achou);
}
/// <summary>
/// Retira e retorna o Item do Topo da Pilha.
/// </summary>
/// <returns>Um Object contendo o Item retirado do Topo da Pilha. Caso a Pilha esteja vazia retorna null.</returns>
public Object Desempilha()
{
Object Item = null;
if (Topo != null)
{
Item = Topo.Item;
Topo = Topo.Prox;
Qtde--;
}
return(Item);
}
/// <summary>
/// Retira e retorna o primeiro elemento da fila.
/// </summary>
/// <returns>Um Object contendo o primeiro elemento da fila. Caso a fila esteja vazia retorna null.</returns>
public Object Desenfileira()
{
Object Item = null;
if (Frente != Tras)
{
Frente = Frente.Prox;
Item = Frente.Item;
Qtde--;
}
return(Item);
}
/// <summary>
/// Remove o último Item da lista sem retorná-lo.
/// </summary>
public void RemoveFimSemRetorno()
{
if (Primeira != Ultima)
{
CCelula aux = Primeira;
while (aux.Prox != Ultima)
{
aux = aux.Prox;
}
Ultima = aux;
Ultima.Prox = null;
Qtde--;
}
}
/// <summary>
/// Remove e retorna o primeiro Item da lista (remoção física, ou seja, elimina a célula que contém o elemento).
/// </summary>
/// <returns>Um Object contendo o Item removido ou null caso a lista esteja vazia.</returns>
public Object RemoveRetornaComeco()
{
// Verifica se há elementos na lista
if (Primeira != Ultima)
{
CCelula aux = Primeira.Prox;
Primeira.Prox = aux.Prox;
if (Primeira.Prox == null) // Se a célula cabeça está apontando para null, significa que o único elemento da lista foi removido
{
Ultima = Primeira;
}
Qtde--;
return(aux.Item);
}
return(null);
}
/// <summary>
/// Remove o último Item da lista.
/// </summary>
/// <returns>Um Object contendo o Item removido ou null caso a lista esteja vazia.</returns>
public Object RemoveRetornaFim()
{
if (Primeira != Ultima)
{
CCelula aux = Primeira;
while (aux.Prox != Ultima)
{
aux = aux.Prox;
}
CCelula aux2 = aux.Prox;
Ultima = aux;
Ultima.Prox = null;
Qtde--;
return(aux2.Item);
}
return(null);
}
/// <summary>
/// Retorna o Item contido na posição p da lista.
/// </summary>
/// <param name="p">A posição desejada. A primeira posição da lista é a posição 1.</param>
/// <returns>Um Object contendo o Item da posição p da lista.</returns>
public Object RetornaIndice(int Posicao)
{
// EXERCÍCIO : deve retornar o elemento da posição p passada por parâmetro
// [cabeça]->[7]->[21]->[13]->null
// retornaIndice(2) deve retornar o elemento 21. retornaIndice de uma posiçao inexistente deve retornar null.
// Se é uma posição válida e a lista possui elementos
if ((Posicao >= 1) && (Posicao <= Qtde) && (Primeira != Ultima))
{
int i = 1;
CCelula aux = Primeira.Prox;
// Procura a posição a ser inserido
while (i < Posicao)
{
aux = aux.Prox;
i++;
}
return(aux.Item);
}
return(null);
}
/// <summary>
/// Insere o Item passado por parâmetro na posição determinada.
/// </summary>
/// <param name="ValorItem">O Item a ser inserido na lista.</param>
/// <param name="Posicao">Posição na qual o elemento será inserido. O primeiro elemento está na posição 1, e assim por diante.</param>
/// <returns>Se a posição existir e o método conseguir inserir o elemento, retorna TRUE. Caso a posição não exista, retorna FALSE</returns>
public bool InsereIndice(Object ValorItem, int Posicao)
{
// Verifica se a posição passada por parâmetro é uma posição válida, ou seja, no intervalo entre 1 e Qtde+1
if (Posicao >= 1 && Posicao <= Qtde + 1)
{
int i = 0;
CCelula aux = Primeira;
// Procura a posição a ser inserido
while (i < Posicao - 1)
{
aux = aux.Prox;
i++;
}
aux.Prox = new CCelula(ValorItem, aux.Prox);
if (aux.Prox.Prox == null) // se a célula inserida está na última posição.
{
Ultima = aux.Prox;
}
Qtde++;
return(true);
}
return(false);
}
/// <summary>
/// Insere o novo Item no Topo da Pilha
/// </summary>
/// <param name="ValorItem">Um Object contendo o Item a ser inserido no Topo da Pilha.</param>
public void Empilha(Object ValorItem)
{
Topo = new CCelula(ValorItem, Topo);
Qtde++;
}
/// <summary>
/// Inicializa uma nova instância da classe CCelula atribuindo ValorItem ao atributo Item e ProxCelula ao atributo Prox.
/// </summary>
/// <param name="ValorItem">Valor a ser armazenado pela célula</param>
/// <param name="ProxCelula">Referência para a próxima célula.</param>
public CCelula(object ValorItem, CCelula ProxCelula)
{
Item = ValorItem;
Prox = ProxCelula;
}
/// <summary>
/// Insere um novo Item no fim da fila.
/// </summary>
/// <param name="ValorItem">Um Object contendo o elemento a ser inserido no final da fila.</param>
public void Enfileira(Object ValorItem)
{
Tras.Prox = new CCelula(ValorItem);
Tras = Tras.Prox;
Qtde++;
}
/// <summary>
/// Inicializa uma nova instância da classe CCelula atribuindo o valor passado por parâmetro ao atributo Item e null ao atributo Prox.
/// </summary>
/// <param name="ValorItem">Valor a ser armazenado pela célula.</param>
public CCelula(object ValorItem)
{
Item = ValorItem;
Prox = null;
}
/// <summary>
/// Insere um novo Item no fim da lista.
/// </summary>
/// <param name="ValorItem">O Item a ser inserido.</param>
public void InsereFim(Object ValorItem)
{
Ultima.Prox = new CCelula(ValorItem);
Ultima = Ultima.Prox;
Qtde++;
}
public CCelula Prox; // Referencia a próxima célula
/// <summary>
/// Inicializa uma nova instância da classe CCelula atribuindo null aos atributos Item e Prox.
/// </summary>
public CCelula()
{
Item = null;
Prox = null;
}
