Wstawianie, usuwanie po indeksie i przesuwanie
Wstawią Państwo element do nowej tablicy, usuną element po indeksie z przesunięciem w lewo oraz przećwiczą bezpieczne sprawdzanie zakresów.
Wstawianie, usuwanie po indeksie i przesuwanie to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 3 lekcji w sumie.
Przegląd wstawiania
Wstawienie elementu do zwykłej tablicy zazwyczaj wymaga utworzenia nowej tablicy z jednym dodatkowym miejscem. Należy skopiować elementy znajdujące się przed daną pozycją, umieścić nową wartość, a następnie skopiować pozostałe elementy, przesuwając je o jedno miejsce.
Wstawianie do nowej tablicy
Wstawianie pod indeks i do nowej tablicy:
public class Main {
// Method to insert a value at a given index
static int[] insertAt(int[] a, int i, int val) {
// Create a new array, one element larger
int[] b = new int[a.length + 1];
// Copy elements before the insertion index
for (int p = 0; p < i; p = p + 1) {
b[p] = a[p];
}
// Insert the new value at position i
b[i] = val;
// Copy the rest of the elements after position i
for (int p = i; p < a.length; p = p + 1) {
b[p + 1] = a[p];
}
return b;
}
public static void main(String[] args) {
// Example array
int[] a = {5, 8, 9, 12};
// Insert 99 at index 2 (between 8 and 9)
int[] b = insertAt(a, 2, 99);
// Print new array
System.out.print("Array after insertion: ");
for (int x : b) {
System.out.print(x + " ");
}
}
}
Usuwanie i przesuwanie
Usuwanie według indeksu przez przesunięcie elementów w lewo i wyczyszczenie ostatniej komórki:
public class Main {
// Method to delete an element at index k
static void deleteAt(int[] a, int k) {
// Shift elements to the left, starting from index k
for (int i = k; i < a.length - 1; i = i + 1) {
a[i] = a[i + 1];
}
// Clear the last element (since it's now duplicated)
a[a.length - 1] = 0;
}
public static void main(String[] args) {
// Example array
int[] a = {5, 8, 9, 12, 15};
// Delete element at index 2 (value = 9)
deleteAt(a, 2);
// Print updated array
System.out.print("Array after deletion: ");
for (int x : a) {
System.out.print(x + " ");
}
}
}
Sprawdzanie zakresu
Sprawdzanie zakresu pomaga uniknąć błędów w czasie wykonywania. Prawidłowy indeks dla n elementów mieści się w zakresie 0..n-1. W przypadku wstawiania prawidłowa wartość i mieści się w zakresie 0..n.
public class Main {
// Insert a value at a given index
static int[] insertAt(int[] a, int i, int val) {
// Validate index (0 ≤ i ≤ a.length is allowed for insert)
if (i < 0 || i > a.length) {
throw new IllegalArgumentException("bad index");
}
int[] b = new int[a.length + 1];
for (int p = 0; p < i; p++) b[p] = a[p];
b[i] = val;
for (int p = i; p < a.length; p++) b[p + 1] = a[p];
return b;
}
// Delete a value at a given index
static void deleteAt(int[] a, int k) {
// Validate index (0 ≤ k < a.length is required for delete)
if (k < 0 || k >= a.length) {
throw new IllegalArgumentException("bad index");
}
for (int i = k; i < a.length - 1; i++) {
a[i] = a[i + 1];
}
a[a.length - 1] = 0; // clear the last slot
}
public static void main(String[] args) {
int[] a = {5, 8, 9, 12};
// Test insert
int[] b = insertAt(a, 2, 99);
System.out.print("After insert: ");
for (int x : b) System.out.print(x + " ");
System.out.println();
// Test delete
deleteAt(b, 3);
System.out.print("After delete: ");
for (int x : b) System.out.print(x + " ");
}
}
Usuwanie do nowej tablicy
Utwórz mniejszą kopię, pomijając indeks k:
public class Main {
// Method to create a new array without the element at index k
static int[] without(int[] a, int k) {
// Validate index
if (k < 0 || k >= a.length) {
throw new IllegalArgumentException("bad index");
}
// New array has one fewer element
int[] b = new int[a.length - 1];
// Copy elements before k
for (int p = 0; p < k; p = p + 1) {
b[p] = a[p];
}
// Copy elements after k (shift left by one)
for (int p = k + 1; p < a.length; p = p + 1) {
b[p - 1] = a[p];
}
return b;
}
public static void main(String[] args) {
int[] a = {5, 8, 9, 12, 15};
// Remove element at index 2 (value = 9)
int[] b = without(a, 2);
// Print original
System.out.print("Original array: ");
for (int x : a) System.out.print(x + " ");
System.out.println();
// Print new array
System.out.print("Array without index 2: ");
for (int x : b) System.out.print(x + " ");
}
}
Demonstracja wstawiania i usuwania
Uruchom program: Zobacz wstawianie do nowej tablicy, usuwanie w miejscu z przesunięciem w lewo oraz usuwanie przez utworzenie kopii.
public class Main {
static int[] insertAt(int[] a, int i, int val) {
if (i < 0 || i > a.length) throw new IllegalArgumentException("bad index");
int[] b = new int[a.length + 1];
for (int p = 0; p < i; p = p + 1) b[p] = a[p];
b[i] = val;
for (int p = i; p < a.length; p = p + 1) b[p + 1] = a[p];
return b;
}
static void deleteAtShift(int[] a, int k) {
if (k < 0 || k >= a.length) throw new IllegalArgumentException("bad index");
for (int i = k; i < a.length - 1; i = i + 1) {
a[i] = a[i + 1];
}
a[a.length - 1] = 0;
}
static int[] without(int[] a, int k) {
if (k < 0 || k >= a.length) throw new IllegalArgumentException("bad index");
int[] b = new int[a.length - 1];
for (int p = 0; p < k; p = p + 1) b[p] = a[p];
for (int p = k + 1; p < a.length; p = p + 1) b[p - 1] = a[p];
return b;
}
static String join(int[] a) {
String s = "";
for (int i = 0; i < a.length; i = i + 1) {
s = s + a[i] + (i + 1 < a.length ? " " : "");
}
return s;
}
public static void main(String[] args) {
int[] a = {10, 20, 30, 40};
System.out.println("a = " + join(a));
int[] b = insertAt(a, 2, 99);
System.out.println("insertAt(2) = " + join(b));
deleteAtShift(a, 1);
System.out.println("deleteAt(1) = " + join(a));
int[] c = without(b, 3);
System.out.println("without(3) = " + join(c));
}
}
Sprawdzenie usuwania i przesuwania
Szybkie sprawdzenie: Który fragment kodu usuwa element pod indeksem k, przesuwając pozostałe elementy w lewo i czyszcząc ostatnią komórkę?
Podsumowanie i następny krok
Podsumowanie: Wstawiali Państwo elementy za pomocą nowej tablicy, usuwali je przez przesunięcie w lewo i tworzyli mniejsze kopie. Zawsze należy sprawdzać zakresy.
Następny krok: Przejdźmy do tablic obiektów i prostych algorytmów, takich jak zliczanie częstotliwości występowania.
Często zadawane pytania
Czy lekcja „Wstawianie, usuwanie po indeksie i przesuwanie” jest bezpłatna?
Tak — pełny tekst „Wstawianie, usuwanie po indeksie i przesuwanie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 3 lekcji w sumie.
Co nauczysz się w „Wstawianie, usuwanie po indeksie i przesuwanie”?
Wstawią Państwo element do nowej tablicy, usuną element po indeksie z przesunięciem w lewo oraz przećwiczą bezpieczne sprawdzanie zakresów. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Java Academy?
Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.
Ile czasu zajmuje lekcja „Wstawianie, usuwanie po indeksie i przesuwanie”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?
Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Podstawy tablic i iteracja
- Wyszukiwanie, minimum/maksimum i odwracanie
- Wstawianie, usuwanie po indeksie i przesuwanie