MinIntValue

[sebjensen1]

Hallo.

In Delphi gibt es eine vorgefertige Funktion, die deen kleinsten vorzeichenbehafteten Wert eines Integer-Arrays zurückliefert "MinIntValue" (analog MaxIntValue).

Gibt es so eine Funktion auch in Java?

Viele Grüße.

 

[byte]

Nö, sowas musste Dir selbst schreiben.

 

[sebjensen1]

Und wie mache ich das?
Kannst du mir dabei helfen?

 

[sebjensen1]

unit UMedian3QuickSort;

interface

procedure Median3QuickSort(var A: array of Integer);

implementation

uses
  Math; // wegen Nutzung der Min-Max-Funktionen

procedure Median3QuickSort(var A: array of Integer);

  procedure M3QSort(LoIndex, HiIndex: Integer);
  var
    Lo, Hi: Integer;
    Left, Middle, Right, Median: Integer;
    Pivot: Integer;
    Swap: Integer;
  begin

    { 3-Median-Strategie:
      Sei das Pivot-Element stets
      der Median von Links-Mitte-Rechts! }

    // Die drei Elemente der zu sortierenden Liste
    Left := A[LoIndex];
    Middle := A[(LoIndex + HiIndex) div 2];
    Right := A[HiIndex];

    // Bestimme den Median
    Median := Middle;
    if Middle = MinIntValue([Left, Middle, Right])
      then Median := Min(Left, Right);
    if Middle = MaxIntValue([Left, Middle, Right])
      then Median := Max(Left, Right);
    Pivot := Median;

    { Der Rest wie gehabt! }

    Lo := LoIndex;
    Hi := HiIndex;
    repeat
      while A[Lo] < Pivot do Inc(Lo);
      while A[Hi] > Pivot do Dec(Hi);
      if Lo <= Hi then
      begin
        Swap := A[Lo];
        A[Lo] := A[Hi];
        A[Hi] := Swap;
        Inc(Lo);
        Dec(Hi);
      end;
    until Lo > Hi;
    if LoIndex < Hi then M3QSort(LoIndex, Hi);
    if Lo < HiIndex then M3QSort(Lo, HiIndex);
  end;

begin
  M3QSort(Low(A), High(A));
end;

end.

Ich habe diese Programm in Delphi und möchte es in Java umschreiben. Bisher habe ich folgendes:

package edu.cau.informatikII.serie08;

public class Medianvondrei {
	public static void main(String[] args){
		int[] A = new int[7];
		A[0]=50;
		A[1]=34;
		A[2]=124;
		A[3]=9;
		A[4]=15;
		A[5]=2;
		A[6]=21;
		meridian(A,0,6);
		System.out.println(A.length);
		for (int i=0; i<A.length; i++) {
			System.out.println(A[i]);
		}
	}
	
	public static void meridian(int[] A, int LoIndex, int HiIndex) {
		
		int Lo;
		int Hi;
		int left, middle, right, median;
		int pivot;
		int swap;
		
		// Die drei Elemente der zur sortierenden Liste
		left   = A[LoIndex];
		middle = A[(int)Math.floor((LoIndex + HiIndex)/2)];
		right  = A[HiIndex];
		
		
		//Bestimme den Median
		median = middle;
		if (middle = )
			median = Math.min(left,right);
		if (middle = )
			median = Math.max(left,right);
		pivot = median;
		

		
		quicksort(A,l+1,r-1,j);
	}
	
	public static void minimum(int[]A) {
		int min = A[0];
		 for ( int index = 0; index < A.length; index++ ) {
		    	if (A[index] < min) {
		    		min = A[index];
		    	}
		 }
	}
	
	
	public static void quicksort(int[] A, int l, int r, int j) {
		int x,i,temp;
		if (l<r){
			x=A[l];
			i=l+1;
			j=(int) Math.floor((l+r)/2);
			while (i<=j){
				while( (i<=j)&&(A[i]<=x)) 
					i++;
				
				while( (i<=j)&&(A[j]>=x)) 
					j--;
				
				if (i<j){
					temp=A[i];
					A[i]=A[j];
					A[j]=temp;
				}
			}
			
			i--;
			A[l]=A[i];
			A[i]=x;
			quicksort(A,l,i-1,j);
			quicksort(A,i+1,r,j);
		}
		 

	}

}

 

[byte]

Du durchwanderst das Array mit einer Schleife. In der ersten Iteration merkst Du Dir den ersten Wert. In allen folgenden Iterationen vergleichst Du den Wert mit dem aktuellen Wert, falls er kleiner ist überschreibst Du den Wert mit diesem neuen Wert. Am Ende bleibt das Minimum übrig (bzw. analog das Maximum).