/// <summary>
/// Torna possível iterar sobre a CListaDup usando o comando foreach
/// </summary>
public IEnumerator GetEnumerator()
{
for (CCelulaDup aux = Primeira.Prox; aux != null; aux = aux.Prox)
{
yield return(aux.Item);
}
}
/// <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, 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)
{
CCelulaDup aux = Primeira;
// Procura a posição a ser inserido
for (int i = 0; i < Posicao - 1; aux = aux.Prox, i++)
{
;
}
aux.Prox = new CCelulaDup(ValorItem, aux, aux.Prox);
if (aux.Prox.Prox != null) // se a célula inserida não é a última
{
aux.Prox.Prox.Ant = aux.Prox;
}
else // se a célula é a última
{
Ultima = aux.Prox;
}
Qtde++;
return(true);
}
return(false);
}
/// <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)
{
CCelulaDup aux = Primeira.Prox;
bool achou = false;
while (aux != null && !achou)
{
achou = aux.Item.Equals(ValorItem);
if (!achou)
{
aux = aux.Prox;
}
}
if (achou) // achou o elemento
{
CCelulaDup anterior = aux.Ant;
CCelulaDup proximo = aux.Prox;
anterior.Prox = proximo;
if (proximo != null)
{
proximo.Ant = anterior;
}
else
{
Ultima = anterior;
}
Qtde--;
}
}
}
/// <summary>
/// Imprime todos os elementos da lista duplamente encadeada usando o comando for.
/// </summary>
public void ImprimeFor()
{
for (CCelulaDup aux = Primeira.Prox; aux != null; aux = aux.Prox)
{
Console.WriteLine(aux.Item);
}
}
/// <summary>
/// Imprime todos os elementos da lista duplamente encadeada em sentido inverso usando o comando for.
/// </summary>
public void ImprimeInvFor()
{
for (CCelulaDup aux = Ultima; aux.Ant != null; aux = aux.Ant)
{
Console.WriteLine(aux.Item);
}
}
/// <summary>
/// Inicializa uma nova instância da classe CCelula atribuindo ValorItem ao atributo Item e ProxCelular ao atributo Prox.
/// </summary>
/// <param name="ValorItem">Valor a ser armazenado pela célula.</param>
/// <param name="celulaAnt">Referência para a célula anterior.</param>
/// <param name="ProxCelula">Referência para a próxima célula.</param>
public CCelulaDup(object ValorItem,
CCelulaDup celulaAnt,
CCelulaDup proxCelula)
{
Item = ValorItem;
Ant = celulaAnt;
Prox = proxCelula;
}
/// <summary>
/// Remove o primeiro elemento da lista. Na verdade, remove a referência para a célula cabeça, e torna a primeira célula na nova célula cabeça
/// </summary>
public void RemoveComecoSemRetorno()
{
if (Primeira != Ultima)
{
Primeira = Primeira.Prox;
Primeira.Ant = null;
Qtde--;
}
}
/// <summary>
/// Remove o último elemento da lista. Na verdade, remove as referências para a última célula, forçando que o Garbage Collector desaloque a última célula
/// </summary>
public void RemoveFimSemRetorno()
{
if (Primeira != Ultima)
{
Ultima = Ultima.Ant;
Ultima.Prox = null;
Qtde--;
}
}
/// <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 (CCelulaDup aux = Primeira.Prox; aux != null && !achou; aux = aux.Prox)
{
achou = aux.Item.Equals(elemento);
}
return(achou);
}
/// <summary>
/// Imprime todos os elementos da lista duplamente encadeada em sentido inverso usando o comando while.
/// </summary>
public void ImprimeInv()
{
CCelulaDup aux = Ultima;
while (aux.Ant != null)
{
Console.WriteLine(aux.Item);
aux = aux.Ant;
}
}
/// <summary>
/// Imprime todos os elementos da lista duplamente encadeada usando o comando while.
/// </summary>
public void Imprime()
{
CCelulaDup aux = Primeira.Prox;
while (aux != null)
{
Console.WriteLine(aux.Item);
aux = aux.Prox;
}
}
public void Limpa()
{
CCelulaDup aux = Primeira;
while (Qtde != 0)
{
aux.Prox = null;
Qtde--;
}
Ultima = Primeira;
}
/// <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;
CCelulaDup aux = Primeira.Prox;
while (aux != null && !achou)
{
achou = aux.Item.Equals(elemento);
aux = aux.Prox;
}
return(achou);
}
/// <summary>
/// Insere um novo elemento no começo da lista.
/// </summary>
/// <param name="ValorItem">O Item a ser inserido no começo da lista.</param>
public void InsereComeco(Object ValorItem)
{
if (Primeira == Ultima) // Se a lista estiver vazia insere no fim
{
Ultima.Prox = new CCelulaDup(ValorItem, Ultima, null);
Ultima = Ultima.Prox;
}
else // senão insere no começo
{
Primeira.Prox = new CCelulaDup(ValorItem, Primeira, Primeira.Prox);
Primeira.Prox.Prox.Ant = Primeira.Prox;
}
Qtde++;
}
/// <summary>
/// Remove e retorna o último elemento da lista.
/// </summary>
/// <returns>Um object contendo o último elemento da lista.</returns>
public Object RemoveRetornaFim()
{
if (Primeira != Ultima)
{
CCelulaDup aux = Ultima;
Ultima = Ultima.Ant;
Ultima.Prox = null;
Qtde--;
return(aux.Item);
}
else
{
return(null);
}
}
/// <summary>
/// Remove e retorna o primeiro elemento da lista.
/// </summary>
/// <returns>Um object contendo o primeiro elemento da lista.</returns>
public Object RemoveRetornaComeco()
{
if (Primeira != Ultima)
{
CCelulaDup aux = Primeira.Prox;
Primeira = Primeira.Prox;
Primeira.Ant = null;
Qtde--;
return(aux.Item);
}
else
{
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))
{
CCelulaDup aux = Primeira.Prox;
// Procura a posição a ser inserido
for (int i = 1; i < Posicao; i++, aux = aux.Prox)
{
;
}
if (aux != null)
{
return(aux.Item);
}
}
return(null);
}
public void RemovePos(int n)
{
CCelulaDup aux = Primeira.Prox;
if (Primeira != Ultima)
{
if ((n >= 1) && (n <= Qtde))
{
int cont = 1;
while (cont < n)
{
aux = aux.Prox;
cont++;
}
aux.Prox = aux.Prox.Prox;
if (aux.Prox == null)
{
Ultima = aux;
}
Qtde--;
}
}
}
public CCelulaDup Prox; // Referencia a próxima célula
/// <summary>
/// Inicializa uma nova instância da classe CCelulaDup atribuindo null aos atributos Item, Ant e Prox.
/// </summary>
public CCelulaDup()
{
Item = null;
Ant = null;
Prox = null;
}
/// <summary>
/// Inicializa uma nova instância da classe CCelula atribuindo o valor passado por parâmetro ao atributo Item e null aos atributos Ant e Prox.
/// </summary>
/// <param name="ValorItem">Valor a ser armazenado pela célula.</param>
public CCelulaDup(object ValorItem)
{
Item = ValorItem;
Ant = null;
Prox = null;
}
/// <summary>
/// Aloca a célula cabeça e faz todas as referências
/// apontarem para ela.
/// </summary>
public CListaDup()
{
Primeira = new CCelulaDup();
Ultima = Primeira;
}
/// <summary>
/// Insere um novo elemento no fim da lista.
/// </summary>
/// <param name="ValorItem">O Item a ser inserido no final da lista.</param>
public void InsereFim(Object ValorItem)
{
Ultima.Prox = new CCelulaDup(ValorItem, Ultima, null);
Ultima = Ultima.Prox;
Qtde++;
}