Коротко — сначала про владение/заимствование, затем про неэффективность и улучшения.
Владение и заимствование в вашем коде
- Функция принимает `v: Vec` по значению — владение вектора передаётся функции (вектор перемещён).
- Вы берёте срезы `v[..mid]` и `v[mid..]` — это заимствования (`&[i32]`) из владением `v`.
- Вызов `.to_vec()` на срезе создаёт новый `Vec` путём копирования элементов (для `i32` — быстрый memcpy, для типов без `Copy` — перемещение/клонирование в зависимости от типа).
- После возврата новых двух `Vec` исходный `v` выходит из области видимости и дропается (его память/буфер освобождается), а данные — скопированы в новые векторы.
Почему это неэффективно
- Вы делаете две аллокации и копируете элементы в обе новые структуры. Если длина исходного вектора $n$, то суммарно копируется примерно $n$ элементов (на практике — $mid$ в левый и $n-mid$ в правый), и выполняются два выделения памяти.
- Алгоритмическая сложность: общая копия — $O(n)$. Дополнительно накладные расходы на три размещения/освобождения буфера вместо одного.
- Для типов, не реализующих `Copy`, `.to_vec()` может требовать клонирования элементов (если `T: Clone`) или иное дорогое перемещение.
Улучшения
1) Использовать Vec::split_off (нет двойного копирования; только одна дополнительная аллокация и перемещение хвоста):
- код:
fn split_at_mid(mut v: Vec) -> (Vec, Vec) {
let mid = v.len() / 2;
let right = v.split_off(mid);
(v, right)
}
- характеристика: выполняется одна новая аллокация и перемещается хвост длины $n-mid$, левый вектор использует исходный буфер. Сложность $O(n-mid)$ по перемещениям и $O(1)$ для левой части по выделению.
2) Если допустимо возвращать ссылки (нулевой копии):
- подпись: fn split_at_mid(v: &[i32]) -> (&[i32], &[i32]) { v.split_at(mid) }
- пример:
fn split_at_mid(v: &[i32]) -> (&[i32], &[i32]) {
let mid = v.len() / 2;
v.split_at(mid)
}
- характеристика: ноль аллокаций и копий; но вызывающий код должен сохранить исходный контейнер/буфер живым.
3) Обобщённый вариант для любых `T`:
- для `Vec` (любых `T`) `split_off` корректно «перемещает» элементы (через ptr::read) без клонирования; поэтому для не-Copy типов это тоже эффективнее, чем `.to_vec()` дублями.
- пример:
fn split_at_mid(mut v: Vec) -> (Vec, Vec) {
let mid = v.len() / 2;
let right = v.split_off(mid);
(v, right)
}
Дополнительно
- Если нужен компактный буфер без лишней емкости, после split можно вызвать `shrink_to_fit()` у результатов (по стоимости дополнительного выделения/копирования).
- Для очень специфичных требований (избежать аллокаций совсем) можно работать с `Box` или возвращать итераторы/ссылки.
Вывод
- Ваш вариант работает, но делает двойное копирование и две аллокации. Наиболее простая и эффективная замена — использовать `Vec::split_off`, либо возвращать срезы `&[T]`, если можно хранить исходный буфер снаружи.