Søgning, minimum/maksimum og omvending
Implementér lineær søgning, beregn minimum/maksimum i én gennemløbning, og vend arrays om på stedet eller ved at kopiere dem.
Søgning, minimum/maksimum og omvending er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 2 af 3. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 3 lektioner i alt.
Lineær søgning
Lineær søgning kontrollerer hvert element i rækkefølge, indtil den finder målet.
- Returnér indekset, når målet findes
- Returnér
-1, hvis det ikke findes - Stop tidligt med
break
public class Main {
public static void main(String[] args) {
// Example array
int[] a = {5, 8, 9, 12, 15};
int t = 9; // target value to search
int idx = -1; // will stay -1 if not found
// Loop through each index of the array
for (int i = 0; i < a.length; i = i + 1) {
// Check if current element matches the target
if (a[i] == t) {
idx = i; // store the index where found
break; // exit loop early (found the target)
}
}
// Print result
if (idx != -1) {
System.out.println("Found " + t + " at index " + idx);
} else {
System.out.println(t + " not found in array");
}
}
}
findIndex()
Indkapsl søgningen i en metode:
public class Main {
public static void main(String[] args) {
// Example array
int[] a = {5, 8, 9, 12, 15};
int t = 9; // target value we are searching for
int idx = -1; // default index (-1 means "not found")
// Loop through each index of the array
for (int i = 0; i < a.length; i = i + 1) {
// Check if current element matches the target
if (a[i] == t) {
idx = i; // store the index where it was found
break; // stop searching (first match found)
}
}
// Print result
if (idx != -1) {
System.out.println("Found " + t + " at index " + idx);
} else {
System.out.println(t + " not found in array");
}
}
}
Minimum/maksimum i ét gennemløb
Beregn minimum og maksimum i ét gennemløb:
public class Main {
public static void main(String[] args) {
// Example array
int[] a = {5, 8, 2, 12, 15, 1};
// Initialize min and max with the first element
int min = a[0];
int max = a[0];
// Loop starts from the second element (index 1)
for (int i = 1; i < a.length; i = i + 1) {
// If current element is smaller than current min → update min
if (a[i] < min) min = a[i];
// If current element is larger than current max → update max
if (a[i] > max) max = a[i];
}
// Print results
System.out.println("Minimum value = " + min);
System.out.println("Maximum value = " + max);
}
}
Omvend på stedet
Omvend på stedet ved at bytte enderne, mens du bevæger dig ind mod midten:
public class Main {
public static void main(String[] args) {
// Example array
int[] a = {5, 8, 9, 12, 15};
int i = 0; // start pointer (left side)
int j = a.length - 1; // end pointer (right side)
// Keep swapping until the two pointers meet
while (i < j) {
// Swap elements at positions i and j
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
// Move pointers toward the center
i = i + 1;
j = j - 1;
}
// Print the reversed array
System.out.print("Reversed array: ");
for (int k = 0; k < a.length; k++) {
System.out.print(a[k] + " ");
}
}
}
Omvendt kopi
Opret en omvendt kopi (originalen forbliver uændret):
public class Main {
public static void main(String[] args) {
// Example array
int[] a = {5, 8, 9, 12, 15};
// Create a new array b with the same length
int[] b = new int[a.length];
// Copy elements from a into b in reverse order
for (int i = 0; i < a.length; i = i + 1) {
// (a.length - 1 - i) gives the reversed index
b[a.length - 1 - i] = a[i];
}
// Print original array
System.out.print("Original array: ");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println(); // newline
// Print reversed array
System.out.print("Reversed array: ");
for (int i = 0; i < b.length; i++) {
System.out.print(b[i] + " ");
}
}
}
Demonstration af søgning, minimum/maksimum og omvending
Kør det: Se søgeresultater, minimums- og maksimumsværdier samt omvendte arrays.
public class Main {
static int findIndex(int[] a, int t) {
for (int i = 0; i < a.length; i = i + 1) {
if (a[i] == t) return i;
}
return -1;
}
static int min(int[] a) {
int m = a[0];
for (int i = 1; i < a.length; i = i + 1) {
if (a[i] < m) m = a[i];
}
return m;
}
static int max(int[] a) {
int m = a[0];
for (int i = 1; i < a.length; i = i + 1) {
if (a[i] > m) m = a[i];
}
return m;
}
static void reverseInPlace(int[] a) {
int i = 0, j = a.length - 1;
while (i < j) {
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
i = i + 1;
j = j - 1;
}
}
static int[] reversedCopy(int[] a) {
int[] b = new int[a.length];
for (int i = 0; i < a.length; i = i + 1) {
b[a.length - 1 - i] = a[i];
}
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 = {3, 1, 4, 1, 5};
System.out.println("findIndex 4 -> " + findIndex(a, 4));
System.out.println("findIndex 9 -> " + findIndex(a, 9));
System.out.println("min = " + min(a));
System.out.println("max = " + max(a));
int[] b = reversedCopy(a);
System.out.println("reversedCopy: " + join(b));
reverseInPlace(a);
System.out.println("reverseInPlace: " + join(a));
}
}
Tjek af lineær søgning
Hurtigt tjek: Hvilket kodestykke returnerer indekset for t i a eller -1?
Opsummering og næste skridt
Opsummering: Du implementerede lineær søgning, minimum/maksimum og to måder at vende arrays om på.
Næste: Lær indsættelse, sletning (via indeks) og forskydning af elementer.
Lær Java med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 104
- Lektioner
- 374
Ofte stillede spørgsmål
Er lektionen “Søgning, minimum/maksimum og omvending” gratis?
Ja — hele teksten til “Søgning, minimum/maksimum og omvending” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 3 lektioner i alt.
Hvad lærer jeg i “Søgning, minimum/maksimum og omvending”?
Implementér lineær søgning, beregn minimum/maksimum i én gennemløbning, og vend arrays om på stedet eller ved at kopiere dem. Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Java Academy?
Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 3.
Hvor lang tid tager lektionen “Søgning, minimum/maksimum og omvending”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Java Academy-lektion?
Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Grundlæggende arrays og iteration
- Søgning, minimum/maksimum og omvending
- Indsættelse, sletning efter indeks og forskydning