Data Structure / List C#

Question

The problem is:

Do a function to remove the n first elements from an integer list. The function must return whether the operation was possible or not (true: it was possible, false: it was not possible).

Below is the List and the Nolista

 public class Lista
    {
        /// <summary>
        /// Referência do primeiro nó (elemento) da lista
        /// </summary>
        public NoLista InicioLista { get; set; }

        /// <summary>
        /// Construtora da classe lista
        /// </summary>
        public Lista()
        {
            InicioLista = null;
        }

        /// <summary>
        /// Remove um valor da lista
        /// </summary>
        /// <param name="valor">Valor a ser removido</param>
        /// <returns>true se encontrar e false se não encontrar</returns>
        public bool Remove(int valor)
        {
            bool valorRetorno = false;

            NoLista auxiliar = InicioLista;

            //int i;
            //int n = valor;

            //for (i = 0 ; i < n ; i++) {

                // Verificar se a lista está vazia
                if (auxiliar != null) {

                    // Percorrer  lista (navegar) até achar o nó com o valor desejado
                    while ((auxiliar != null) && (auxiliar.informacao != valor)) {

                        // Passa para o próximo elemento da lista
                        auxiliar = auxiliar.proximo;
                    }

                    // So atualizar a lista se o valor foi encontrado
                    if (auxiliar.informacao == valor) {
                        // Verificar se existe um proximo elemento na lista
                        if (auxiliar.proximo != null) {
                            // Remover a referencia do nó anterior
                            (auxiliar.proximo).anterior = null;
                        }

                        // Verificar se é o primeiro da lista
                        if (InicioLista.informacao == valor) {
                            InicioLista = InicioLista.proximo;
                        }
                        else {
                            // Verificar se existe um proximo elemento na lista
                            if (auxiliar.proximo != null) {
                                (auxiliar.proximo).anterior = auxiliar.anterior;
                            }

                            // Fazer o anterior do auxiliar apontar para o proximo do auxiliar
                            (auxiliar.anterior).proximo = auxiliar.proximo;
                        }
                    }
                }

            //}
            return valorRetorno;
        }
        /// <summary>
        /// Adiona um novo valor na lista
        /// </summary>
        /// <param name="valor">Valor a ser adicionado</param>

        public void Add(int valor)
        {
            NoLista novoNo = new NoLista();
            novoNo.informacao = valor;

            // Verificar se é o primeiro da lista
            if (InicioLista == null)
            {
                InicioLista = novoNo;
            }
            else
            {
                NoLista auxiliar = InicioLista;

                while (auxiliar.proximo != null)
                {
                    auxiliar = auxiliar.proximo;
                }

                auxiliar.proximo = novoNo;
                novoNo.anterior = auxiliar;
            }
        }

        public Lista Concatenar (Lista l1, Lista l2) {
            var novaLista = new Lista ( );
            Add1 (novaLista, l1);
            Add1 (novaLista, l2);
            return novaLista;
        }

        private static void Add1 (Lista nova, Lista velha) {
            NoLista p = velha.InicioLista;
            nova.Add (p.informacao);

            while (p.proximo != null) {
                p = p.proximo;
                nova.Add (p.informacao);
            }
        }

        public void Imprime()
        {
            NoLista auxiliar = InicioLista;
            Console.WriteLine("Imprimindo a lista");

            // Percorrer a lista até o fim
            while (auxiliar != null)
            {
                // Imprimir o valor
                Console.WriteLine(auxiliar.informacao);

                // Navegar para o próximo nó
                 auxiliar = auxiliar.proximo;
            }
        }
    }




public class NoLista
    {
        /// <summary>
        /// Aramazena a informação
        /// </summary>
        public int informacao { get; set; }

        /// <summary>
        /// Referência para o próximo nó (elemento) na lista
        /// </summary>
        public NoLista proximo { get; set; }


        /// <summary>
        /// Referência para o nó (elemento) anterior na lista
        /// </summary>
        public NoLista anterior { get; set; }

        /// <summary>
        /// Construtora da classe NoLista
        /// </summary>
        public NoLista()
        {
            informacao = -1;
            proximo = null;
            anterior = null;
        }


    }

Answer 1

For the function you need just make a for about the amount of elements to remove and go modifying the beginning of the list for the element that is exactly following. In addition it is also necessary to adjust the reference to the previous one, so that the list remains correct.

Would then stay so:

/// <summary>
/// Remove os N primeiros elementos da lista
/// </summary>
/// <param name="quantidade">Quantidade de elementos a remover</param>
/// <returns>true se conseguiu remover todos ou false caso contrario</returns>
public bool RemovePrimeiros(int quantidade)
{

    for (int i = 0; i < quantidade; ++i)
    {
        if (InicioLista == null) return false; //se já não tem mais a remover devolve false

        InicioLista = InicioLista.proximo; //remove o primeiro
        InicioLista.anterior = null; //ajusta o anterior do novo primeiro
    }

    return true; //conseguiu remover todos, devolve true
}

See how it works on . Net Fiddle