Удаление первого элемента из списка: Полное руководство

Узнайте, как удалять первый элемент из списков в Python, Java, JavaScript и других языках программирования. Изучите различные методы с примерами кода и сравнением производительности.

Авторы: НейроАгент

20.11.2025, 09:51

Как удалить первый элемент из списка?

Например:

[0, 1, 2, 3] → [1, 2, 3]

Какие существуют разные способы удаления первого элемента из списка в программировании?

Чтобы удалить первый элемент из списка, можно использовать различные методы в зависимости от вашего языка программирования. В Python распространенные подходы включают использование оператора del, метода pop() или срезов списков, в то время как Java предлагает методы removeFirst() и другие техники манипуляции списками. Каждый метод имеет разные характеристики производительности и варианты использования, причем некоторые более эффективны других в зависимости от ваших конкретных потребностей.

Содержание

Методы Python для удаления первого элемента
Подходы Java для манипуляции списками
Решения на JavaScript и других языках
Сравнение производительности и лучшие практики
Полные примеры кода

Методы Python для удаления первого элемента

Python предлагает несколько способов удаления первого элемента из списка, каждый из которых имеет свои преимущества и варианты использования.

Использование оператора `del`

Оператор del предоставляет простой способ удаления первого элемента путем указания его индекса.

python

my_list = [0, 1, 2, 3]
del my_list[0]
print(my_list)  # Вывод: [1, 2, 3]

Этот метод изменяет список на месте и не возвращает удаленный элемент. Согласно официальной документации Python, оператор del может удалять элементы из списка по индексу.

Использование метода `pop()`

Метод pop() удаляет элемент по указанному индексу и возвращает его.

python

my_list = [0, 1, 2, 3]
removed_element = my_list.pop(0)
print(my_list)  # Вывод: [1, 2, 3]
print(removed_element)  # Вывод: 0

Как объясняется на Mozilla Developer Network, метод pop() полезен, когда вам нужно одновременно удалить и получить элемент. Однако он вызывает исключение IndexError, если список пуст.

Использование срезов списков

Срез списка создает новый список без первого элемента.

python

my_list = [0, 1, 2, 3]
my_list = my_list[1:]
print(my_list)  # Вывод: [1, 2, 3]

Этот подход не изменяет исходный список на месте, а создает новый список. Согласно GeeksforGeeks, срезы особенно полезны, когда вы хотите сохранить исходный список.

Использование метода `remove()` с первым элементом

Хотя это не самый распространенный подход для удаления по индексу, можно использовать remove() с первым элементом:

python

my_list = [0, 1, 2, 3]
my_list.remove(my_list[0])
print(my_list)  # Вывод: [1, 2, 3]

Использование `collections.deque` для частых операций

Для приложений, которые часто удаляют элементы с обоих концов списка, использование deque (двусторонней очереди) более эффективно:

python

from collections import deque

my_list = deque([0, 1, 2, 3])
removed_element = my_list.popleft()
print(my_list)  # Вывод: deque([1, 2, 3])
print(removed_element)  # Вывод: 0

Как объясняется на Spark By Examples, метод popleft() обеспечивает временную сложность O(1) для удаления первого элемента, что делает его идеальным для критически важных к производительности приложений.

Подходы Java для манипуляции списками

Java предлагает несколько методов для удаления первого элемента из списков, с разными подходами в зависимости от реализации списка.

Использование метода `removeFirst()` (Java 21+)

Java 21 представила метод removeFirst() для коллекций:

java

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(List.of(0, 1, 2, 3));
        list.removeFirst();
        System.out.println(list);  // Вывод: [1, 2, 3]
    }
}

Согласно JavaGuides, этот метод предоставляет чистый и интуитивный способ удаления первого элемента из любой реализации списка.

Использование операций `LinkedList`

Для LinkedList существуют специализированные методы:

java

import java.util.LinkedList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>(List.of(0, 1, 2, 3));
        ((LinkedList<Integer>) list).removeFirst();
        System.out.println(list);  // Вывод: [1, 2, 3]
    }
}

Как объясняется на GeeksforGeeks, метод LinkedList.removeFirst() специально разработан для этой операции и обеспечивает временную сложность O(1).

Использование традиционного метода `remove()`

Для любой реализации List можно использовать традиционный метод remove():

java

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(List.of(0, 1, 2, 3));
        list.remove(0);  // Удалить элемент по индексу 0
        System.out.println(list);  // Вывод: [1, 2, 3]
    }
}

Использование подхода с подсписком

Также можно создать подсписок, исключающий первый элемент:

java

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> original = new ArrayList<>(List.of(0, 1, 2, 3));
        List<Integer> withoutFirst = original.subList(1, original.size());
        System.out.println(withoutFirst);  // Вывод: [1, 2, 3]
    }
}

Решения на JavaScript и других языках

Методы JavaScript

Использование метода `slice()`

javascript

const arr = [0, 1, 2, 3];
const newArr = arr.slice(1);
console.log(newArr);  // Вывод: [1, 2, 3]

Метод slice() создает новый массив, не изменяя исходный.

Использование метода `splice()`

javascript

const arr = [0, 1, 2, 3];
const removed = arr.splice(0, 1);
console.log(arr);     // Вывод: [1, 2, 3]
console.log(removed);  // Вывод: [0]

Согласно Mozilla Developer Network, метод splice() изменяет исходный массив и возвращает удаленные элементы.

Использование метода `shift()`

javascript

const arr = [0, 1, 2, 3];
const removed = arr.shift();
console.log(arr);     // Вывод: [1, 2, 3]
console.log(removed);  // Вывод: 0

Метод shift() удаляет первый элемент и возвращает его.

Решения на C++

Использование `erase()` с итератором

cpp

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {0, 1, 2, 3};
    vec.erase(vec.begin());
    
    // Вывод результата
    for (int num : vec) {
        std::cout << num << " ";
    }
    // Вывод: 1 2 3
    return 0;
}

Решения на C#

Использование метода `RemoveAt()`

csharp

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        List<int> list = new List<int> { 0, 1, 2, 3 };
        list.RemoveAt(0);
        
        // Вывод результата
        foreach (int num in list) {
            Console.Write(num + " ");
        }
        // Вывод: 1 2 3
    }
}

Сравнение производительности и лучшие практики

Анализ временной сложности

У разных методов разные характеристики производительности:

Метод	Временная сложность	Сложность по памяти	Изменяет исходный?
Python `del`	O(n)	O(1)	Да
Python `pop(0)`	O(n)	O(1)	Да
Python `list[1:]`	O(n)	O(n)	Нет
Python `deque.popleft()`	O(1)	O(1)	Да
Java `remove(0)`	O(n)	O(1)	Да
Java `LinkedList.removeFirst()`	O(1)	O(1)	Да
JavaScript `shift()`	O(n)	O(1)	Да
JavaScript `splice(0, 1)`	O(n)	O(1)	Да

Когда использовать каждый метод

Используйте del или pop(0) в Python, когда нужно изменить список на месте и нет необходимости сохранять исходный
Используйте срезы, когда нужно оставить исходный список без изменений
Используйте deque.popleft() в Python для частого удаления первого элемента в критически важном к производительности коде
Используйте LinkedList.removeFirst() в Java для частых операций с первым элементом
Используйте shift() в JavaScript, когда нужен удаленный элемент и измененный массив

Распространенные ошибки

Пустые списки: Методы вроде pop(0) и removeFirst() вызовут исключения на пустых списках
Производительность: Избегайте методов со сложностью O(n) в критически важных к производительности циклах
Память: Срезы создают новые объекты, что может быть 内存-intensive для больших списков

Полные примеры кода

Полный пример на Python

python

# Метод 1: Использование del
def remove_first_del(lst):
    if len(lst) > 0:
        del lst[0]
    return lst

# Метод 2: Использование pop
def remove_first_pop(lst):
    if len(lst) > 0:
        lst.pop(0)
    return lst

# Метод 3: Использование срезов
def remove_first_slicing(lst):
    return lst[1:] if len(lst) > 0 else []

# Метод 4: Использование deque
from collections import deque
def remove_first_deque(lst):
    dq = deque(lst)
    if len(dq) > 0:
        dq.popleft()
    return list(dq)

# Тестирование всех методов
original = [0, 1, 2, 3]
print("Исходный:", original)
print("del:", remove_first_del(original.copy()))      # [1, 2, 3]
print("pop:", remove_first_pop(original.copy()))       # [1, 2, 3]
print("срезы:", remove_first_slicing(original))     # [1, 2, 3]
print("deque:", remove_first_deque(original.copy()))  # [1, 2, 3]

Полный пример на Java

java

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class RemoveFirstElement {
    // Метод 1: Использование remove(0)
    public static List<Integer> removeFirstRemove(List<Integer> list) {
        if (!list.isEmpty()) {
            list.remove(0);
        }
        return new ArrayList<>(list);
    }

    // Метод 2: Использование LinkedList.removeFirst()
    public static List<Integer> removeFirstLinkedList(List<Integer> list) {
        if (!list.isEmpty() && list instanceof LinkedList) {
            ((LinkedList<Integer>) list).removeFirst();
        }
        return new ArrayList<>(list);
    }

    // Метод 3: Использование подсписка
    public static List<Integer> removeFirstSublist(List<Integer> list) {
        if (!list.isEmpty()) {
            return new ArrayList<>(list.subList(1, list.size()));
        }
        return new ArrayList<>();
    }

    public static void main(String[] args) {
        List<Integer> original = List.of(0, 1, 2, 3);
        
        System.out.println("Исходный: " + original);
        System.out.println("remove(0): " + removeFirstRemove(new ArrayList<>(original)));
        
        LinkedList<Integer> linkedList = new LinkedList<>(original);
        System.out.println("LinkedList.removeFirst(): " + removeFirstLinkedList(linkedList));
        
        System.out.println("подсписок: " + removeFirstSublist(new ArrayList<>(original)));
    }
}

Полный пример на JavaScript

javascript

// Метод 1: Использование slice
function removeFirstSlice(arr) {
    return arr.slice(1);
}

// Метод 2: Использование splice
function removeFirstSplice(arr) {
    const arrCopy = [...arr];
    const removed = arrCopy.splice(0, 1);
    return { modified: arrCopy, removed: removed[0] };
}

// Метод 3: Использование shift
function removeFirstShift(arr) {
    const arrCopy = [...arr];
    const removed = arrCopy.shift();
    return { modified: arrCopy, removed: removed };
}

// Тестирование всех методов
const original = [0, 1, 2, 3];
console.log("Исходный:", original);
console.log("slice:", removeFirstSlice(original));  // [1, 2, 3]
console.log("splice:", removeFirstSplice(original));  // { modified: [1, 2, 3], removed: 0 }
console.log("shift:", removeFirstShift(original));  // { modified: [1, 2, 3], removed: 0 }

Источники

Заключение

Удаление первого элемента из списка является фундаментальной операцией в программировании, с множеством подходов, доступных на разных языках. Ключевые факторы включают необходимость изменения исходного списка, необходимость получения удаленного элемента и требования производительности вашего приложения.

Для разработчиков Python del и pop(0) являются простыми методами изменения списка на месте, в то время как deque.popleft() предлагает превосходную производительность для частых операций. Разработчики Java могут выбрать между remove(0) для общих списков и LinkedList.removeFirst() для специализированных операций. JavaScript предлагает методы shift(), splice() и slice() с разными характеристиками.

Всегда учитывайте временную сложность выбранного метода - методы со сложностью O(1), такие как deque.popleft() и LinkedList.removeFirst(), предпочтительны для критически важных к производительности приложений, в то время как методы со сложностью O(n) могут быть достаточными для периодических операций. Не забывайте правильно обрабатывать пустые списки, чтобы избежать исключений времени выполнения в вашем коде.

Авторы

НейроАгент

Автор

Проверено модерацией

НейроОтветы

Модерация

Удаление первого элемента из списка: Полное руководство

Содержание

Методы Python для удаления первого элемента

Использование оператора del

Использование метода pop()

Использование срезов списков

Использование метода remove() с первым элементом

Использование collections.deque для частых операций

Подходы Java для манипуляции списками

Использование метода removeFirst() (Java 21+)

Использование операций LinkedList

Использование традиционного метода remove()

Использование подхода с подсписком

Решения на JavaScript и других языках

Методы JavaScript

Использование метода slice()

Использование метода splice()

Использование метода shift()

Решения на C++

Использование erase() с итератором

Решения на C#

Использование метода RemoveAt()

Сравнение производительности и лучшие практики

Анализ временной сложности

Когда использовать каждый метод

Распространенные ошибки

Полные примеры кода

Полный пример на Python

Полный пример на Java

Полный пример на JavaScript

Источники

Заключение

Использование оператора `del`

Использование метода `pop()`

Использование метода `remove()` с первым элементом

Использование `collections.deque` для частых операций

Использование метода `removeFirst()` (Java 21+)

Использование операций `LinkedList`

Использование традиционного метода `remove()`

Использование метода `slice()`

Использование метода `splice()`

Использование метода `shift()`

Использование `erase()` с итератором

Использование метода `RemoveAt()`