/// <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++; }