Откройте для себя невероятные возможности методов push и pop в JavaScript! Всего несколькими строками кода вы можете открыть целый мир возможностей и погрузиться в мир структур данных и алгоритмических операций. Независимо от того, хотите ли вы поменять местами массивы и строки или создать сложные структуры данных, такие как очереди и стеки, эти фрагменты увлекут вас в процессе написания кода.
Приготовьтесь к увлекательному исследованию кода, где мы раскроем секреты этих методов массива и своими глазами увидим, как они могут изменить ваше мастерство программирования. Давайте погрузимся и воспользуемся силой push and pop, чтобы справиться со сложными задачами на собеседовании и расширить наши горизонты кодирования.
Фрагмент 1: перевернуть массив с помощью push и pop:
function reverseArray(arr) {
var reversed = [];
while (arr.length > 0) {
reversed.push(arr.pop());
}
return reversed;
}
var arr = [1, 2, 3, 4, 5];
var reversedArray = reverseArray(arr);
console.log(reversedArray); // [5, 4, 3, 2, 1]
Объяснение. Этот фрагмент кода переворачивает массив, многократно извлекая элементы из исходного массива и помещая их в новый массив в обратном порядке.
Фрагмент 2: Реализуйте стек, используя массив с методами push и pop:
function Stack() {
this.stack = [];
this.push = function (item) {
this.stack.push(item);
};
this.pop = function () {
if (this.stack.length === 0) {
return "Stack is empty.";
}
return this.stack.pop();
};
}
var stack = new Stack();
stack.push("A");
stack.push("B");
stack.push("C");
console.log(stack.pop());
console.log(stack.pop());
console.log(stack.pop());
console.log(stack.pop());
//Output
C
B
A
Stack is empty.
Объяснение. Этот фрагмент демонстрирует реализацию стека с использованием массива. Метод push добавляет элемент на вершину стека, а метод pop удаляет и возвращает верхний элемент из стека.
Фрагмент 3: удаление дубликатов из массива с помощью push и pop:
function removeDuplicates(arr) {
var unique = [];
while (arr.length > 0) {
var current = arr.pop();
if (!unique.includes(current)) {
unique.push(current);
}
}
return unique.reverse();
}
var arr = [1, 2, 2, 3, 4, 4, 5];
var uniqueArray = removeDuplicates(arr);
console.log(uniqueArray);
//output
[5, 4, 3, 2, 1]
Объяснение. Этот фрагмент кода удаляет дубликаты из массива, извлекая элементы из исходного массива и помещая в новый массив только уникальные элементы.
Фрагмент 4: проверьте, является ли строка палиндромом, используя push и pop:
function isPalindrome(str) {
var reversed = [];
for (var i = 0; i < str.length; i++) {
reversed.push(str[i]);
}
var reversedStr = '';
while (reversed.length > 0) {
reversedStr += reversed.pop();
}
return str === reversedStr;
}
var str = "racecar";
var isPalindromeResult = isPalindrome(str);
console.log(isPalindromeResult);
//Output
true
Объяснение. Этот фрагмент проверяет, является ли строка палиндромом, помещая каждый символ строки в массив, затем извлекая символы из массива и объединяя их для формирования перевернутой строки. Затем он сравнивает исходную и перевернутую строки, чтобы определить, совпадают ли они.
Фрагмент 5: объединить два отсортированных массива в один отсортированный массив, используя push и pop:
function mergeSortedArrays(arr1, arr2) {
var merged = [];
while (arr1.length && arr2.length) {
if (arr1[arr1.length - 1] >= arr2[arr2.length - 1]) {
merged.push(arr1.pop());
} else {
merged.push(arr2.pop());
}
}
return merged.concat(arr1.reverse(), arr2.reverse());
}
var arr1 = [1, 3, 5, 7];
var arr2 = [2, 4, 6, 8];
var mergedArray = mergeSortedArrays(arr1, arr2);
console.log(mergedArray);
//Output
[8, 7, 6, 5, 4, 3, 2, 1]
Объяснение. Этот фрагмент объединяет два отсортированных массива в один отсортированный массив, сравнивая последние элементы обоих массивов и помещая больший элемент в новый объединенный массив. Этот процесс продолжается до тех пор, пока один из массивов не станет пустым. Наконец, он объединяет оставшиеся элементы непустого массива в объединенный массив.
Фрагмент 6: Реализуйте очередь, используя массив с методами push и pop:
function Queue() {
this.queue = [];
this.enqueue = function (item) {
this.queue.push(item);
};
this.dequeue = function () {
if (this.queue.length === 0) {
return "Queue is empty.";
}
return this.queue.shift();
};
}
var queue = new Queue();
queue.enqueue("A");
queue.enqueue("B");
queue.enqueue("C");
console.log(queue.dequeue());
console.log(queue.dequeue());
console.log(queue.dequeue());
console.log(queue.dequeue());
//Output
A
B
C
Queue is empty.
Объяснение. Этот фрагмент демонстрирует реализацию очереди с использованием массива. Метод enqueue добавляет элемент в конец очереди, а метод dequeue удаляет и возвращает первый элемент из очереди.
Фрагмент 7: сглаживание массива вложенных массивов с помощью push и pop:
function flattenArray(arr) {
var flattened = [];
while (arr.length) {
var next = arr.pop();
if (Array.isArray(next)) {
arr.push(...next);
} else {
flattened.push(next);
}
}
return flattened.reverse();
}
var arr = [1, [2, 3], [4, [5, 6]]];
var flattenedArray = flattenArray(arr);
console.log(flattenedArray);
//Output
[6, 5, 4, 3, 2, 1]
Объяснение. Этот фрагмент кода сглаживает массив вложенных массивов путем многократного извлечения элементов из исходного массива. Если извлеченный элемент является массивом, его элементы распределяются и помещаются обратно в исходный массив. Если это не массив, элемент помещается в новый сглаженный массив. Наконец, сглаженный массив переворачивается, чтобы сохранить исходный порядок.
Фрагмент 8: Найдите максимальный элемент в массиве, используя push и pop:
function findMax(arr) {
var max = Number.NEGATIVE_INFINITY;
while (arr.length) {
var element = arr.pop();
if (element > max) {
max = element;
}
}
return max;
}
var arr = [3, 7, 2, 9, 5];
var maxNumber = findMax(arr);
console.log(maxNumber);
//Output
9
Объяснение. Этот фрагмент кода находит максимальный элемент в массиве, извлекая элементы из массива и сравнивая каждый элемент с текущим максимумом. Если найден больший элемент, он заменяет текущее максимальное значение.
Фрагмент 9: Реализуйте бинарный поиск в отсортированном массиве, используя push и pop:
function binarySearch(arr, target) {
var low = 0;
var high = arr.length - 1;
while (low <= high) {
var mid = Math.floor((low + high) / 2);
var midElement = arr[mid];
if (midElement === target) {
return mid;
} else if (midElement < target) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
var arr = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91];
var target = 23;
var result = binarySearch(arr, target);
console.log(result);
//Output
5
Объяснение. Этот фрагмент кода выполняет бинарный поиск в отсортированном массиве путем многократного деления диапазона поиска пополам. Он сравнивает средний элемент диапазона с целевым значением и корректирует диапазон соответствующим образом, пока цель не будет найдена или диапазон не будет исчерпан.
Фрагмент 10. Найдите медиану отсортированного массива, используя push и pop:
function findMedian(arr) {
var length = arr.length;
var midIndex = Math.floor(length / 2);
var median;
while (arr.length > midIndex + 1) {
arr.pop();
}
if (length % 2 === 0) {
median = (arr.pop() + arr.pop()) / 2;
} else {
median = arr.pop();
}
return median;
}
var arr = [1, 3, 5, 7, 9];
var medianValue = findMedian(arr);
console.log(medianValue);
//Output
5
Объяснение. Этот фрагмент кода находит медиану отсортированного массива путем многократного извлечения элементов из массива, пока не будет достигнут средний индекс. Если длина массива четная, медиана вычисляется как среднее значение двух средних элементов. Если длина нечетная, средний элемент назначается медианой.
Фрагмент 11: Реализуйте приоритетную очередь, используя массив с методами push и pop:
function PriorityQueue() {
this.queue = [];
this.enqueue = function (item, priority) {
this.queue.push({ item, priority });
};
this.dequeue = function () {
if (this.queue.length === 0) {
return "Priority queue is empty.";
}
var maxPriorityIndex = 0;
for (var i = 1; i < this.queue.length; i++) {
if (this.queue[i].priority > this.queue[maxPriorityIndex].priority) {
maxPriorityIndex = i;
}
}
return this.queue.splice(maxPriorityIndex, 1)[0].item;
};
}
var priorityQueue = new PriorityQueue();
priorityQueue.enqueue("Task 1", 3);
priorityQueue.enqueue("Task 2", 1);
priorityQueue.enqueue("Task 3", 2);
console.log(priorityQueue.dequeue());
console.log(priorityQueue.dequeue());
console.log(priorityQueue.dequeue());
console.log(priorityQueue.dequeue());
//Output
Task 2
Task 3
Task 1
Priority queue is empty.
Объяснение. Этот фрагмент реализует приоритетную очередь с использованием массива. Метод enqueue добавляет элемент в очередь с указанным приоритетом. Метод удаления из очереди удаляет и возвращает элемент с наивысшим приоритетом из очереди на основе линейного поиска.
Фрагмент 12. Реализуйте циклическую очередь, используя массив с методами push и pop:
function CircularQueue(k) {
this.queue = [];
this.maxSize = k;
this.enqueue = function (item) {
if (this.queue.length < this.maxSize) {
this.queue.push(item);
} else {
return "Circular queue is full.";
}
};
this.dequeue = function () {
if (this.queue.length === 0) {
return "Circular queue is empty.";
}
return this.queue.shift();
};
}
var circularQueue = new CircularQueue(3);
console.log(circularQueue.dequeue()); // Circular queue is empty.
circularQueue.enqueue("Item 1");
circularQueue.enqueue("Item 2");
circularQueue.enqueue("Item 3");
console.log(circularQueue.enqueue("Item 4")); // Circular queue is full.
console.log(circularQueue.dequeue()); // Item 1
console.log(circularQueue.dequeue()); // Item 2
console.log(circularQueue.dequeue()); // Item 3
console.log(circularQueue.dequeue()); // Circular queue is empty.
//Output
Circular queue is empty.
Circular queue is full.
Item 1
Item 2
Item 3
Circular queue is empty.
Объяснение. Этот фрагмент демонстрирует реализацию циклической очереди с использованием массива. Метод enqueue добавляет элемент в конец очереди, если не достигнут максимальный размер. Метод dequeue удаляет и возвращает первый элемент из очереди, учитывая циклический характер очереди.
Фрагмент 13. Выполните транспонирование матрицы с помощью push и pop:
function transposeMatrix(matrix) {
var transposed = [];
while (matrix[0].length) {
transposed.push(matrix.map(row => row.pop()));
}
return transposed;
}
var matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
];
var transposedMatrix = transposeMatrix(matrix);
console.log(transposedMatrix);
//Output
[
[1, 4, 7],
[2, 5, 8],
[3, 6, 9]
]
Объяснение. В этом фрагменте выполняется транспонирование матрицы путем многократного извлечения последнего элемента из каждой строки исходной матрицы и построения новой транспонированной матрицы с использованием push().
Фрагмент 14. Реализуйте функцию отмены/возврата с помощью push и pop:
function UndoRedo() {
this.undoStack = [];
this.redoStack = [];
this.executeAction = function (action) {
this.undoStack.push(action);
this.redoStack = [];
};
this.undo = function () {
if (this.undoStack.length === 0) {
return "No actions to undo.";
}
var action = this.undoStack.pop();
this.redoStack.push(action);
return action;
};
this.redo = function () {
if (this.redoStack.length === 0) {
return "No actions to redo.";
}
var action = this.redoStack.pop();
this.undoStack.push(action);
return action;
};
}
var undoRedo = new UndoRedo();
function addAction(action) {
console.log("Executing action:", action);
undoRedo.executeAction(action);
}
function undoAction() {
var undoneAction = undoRedo.undo();
if (undoneAction) {
console.log("Undone action:", undoneAction);
} else {
console.log("No actions to undo.");
}
}
function redoAction() {
var redoneAction = undoRedo.redo();
if (redoneAction) {
console.log("Redone action:", redoneAction);
} else {
console.log("No actions to redo.");
}
}
addAction("Action 1"); // Execute Action 1
addAction("Action 2"); // Execute Action 2
undoAction(); // Undo Action 2
redoAction(); // Redo Action 2
undoAction(); // Undo Action 2
undoAction(); // Undo Action 1
redoAction(); // Redo Action 1
redoAction(); // Redo Action 2
redoAction(); // No actions to redo.
// Output
Executing action: Action 1
Executing action: Action 2
Undone action: Action 2
Redone action: Action 2
Undone action: Action 2
Undone action: Action 1
Redone action: Action 1
No actions to redo.
Объяснение. В этом фрагменте реализована функция отмены/возврата с использованием двух стеков. Метод executeAction помещает действие в стек отмен и очищает стек повторов. Метод отмены извлекает действие из стека отмены и помещает его в стек повтора для будущих операций повтора. Метод повтора извлекает действие из стека повторов и помещает его в стек отмен для повторного выполнения действия.
Фрагмент 15: Сгенерируйте все возможные подмножества массива, используя push и pop:
function generateSubsets(arr) {
var subsets = [[]];
while (arr.length) {
var element = arr.pop();
var subsetsWithElement = [];
for (var i = 0; i < subsets.length; i++) {
subsetsWithElement.push([...subsets[i], element]);
}
subsets.push(...subsetsWithElement);
}
return subsets;
}
var sampleData = [1, 2, 3];
var subsets = generateSubsets(sampleData);
console.log(subsets);
//Output
[ [],
[1],
[2],
[1, 2],
[3],
[1, 3],
[2, 3],
[1, 2, 3]
]
Объяснение. Этот фрагмент кода создает все возможные подмножества массива путем многократного извлечения элементов из исходного массива и создания новых подмножеств путем объединения каждого существующего подмножества с извлеченным элементом.
Надеюсь, что приведенная выше статья дала лучшее понимание. Если у вас есть какие-либо вопросы относительно областей, которые я обсуждал в этой статье, области улучшения, не стесняйтесь комментировать ниже.
[Раскрытие информации: эта статья является совместным творением, в котором мои собственные идеи сочетаются с помощью ChatGPT для оптимальной артикуляции.]
