C-Code

#include <iostream>
using namespace std;

int main()
{
	double OG,UG,z,x;
cout << "Geben Sie eine Zahl ein:\n ";
cin >> z;

	UG=0;  
	OG=z;

while(OG-UG>0.01)
{
x=(UG+OG)/2;
	if( x*x>z)
		{OG=x;}
	else if (x*x<z)
		{UG=x;}
}

cout <<" Die Wurzel von "<< z << " beträgt: " << x;

}

Java-Code

public class IntervallWurzel {

	private double raiseValue;	// Soll die aktuelle Dezimalstelle des Vergleichswerts erhöhen.
	private int decimalPlace;	// Die aktuell zu erhöhende Dezimalstelle.
	
	
	public double squareroot(double value){
		double lowerLimit = 0.0;
		double searchValue = lowerLimit;
		
		// Die Schleife läuft so lange wie das Quadrat des Sucher-Values ungleich
		// des Wertes ist, von dem die Wurzel gefunden werden soll.
		// Im else-Zweig gibt es noch ein break welches den Fall abfängt, in dem die
		// kleinstmögliche Auflösung für das Such-Value erreicht ist. In dem Fall würde
		// sich das Such-Value nicht mehr ändern und die Suche kann abgebrochen werden.
		while((searchValue * searchValue) != value){
			searchValue += getRaiseValue();			
			if(value < (searchValue * searchValue)){
				// Das Quadrat des Such-Values hat den Betrag des Wertes
				// für den die Wurzel gefunden werden soll überschritten.
				// Also ist eine neue unter Grenze gefunden ab der das Such-Value ...
				searchValue = lowerLimit;
				// ... die nächst kleineren Dezimalstelle untersuchen kann.
				setRaiseValue(determineRaiseValue());
			}else{
				// Das Quadrat des Such-Values hat den Betrag des Wertes
				// für den die Wurzel gefunden werden soll noch nicht überschritten, ...
				if(lowerLimit == searchValue)
					break; // Such Value hat kleinste Auflösung erreich
				// ... so daß eine neue potenzielle untere Grenze gemerkt werden kann.
				lowerLimit = searchValue;
			}
		}
		// Werte zurücksetzen, damit eine weitere Suche erfolgen kann.
		// Das Objekt "lebt" ja noch.
		setDecimalPlace(0);
		setRaiseValue(1.0);
		return searchValue;
	}
	
	private double determineRaiseValue(){
		// Der Erhöhungswert beginnt mit eins und wird jedesmal um eine Dezmalstelle kleiner.
		double tempRaiseValue = 1.0;
		// Dabei gibt @decimalPlace die aktuelle Dezimalstelle an.
		for(int runner = 0; runner < getDecimalPlace(); runner++){
			tempRaiseValue /= 10.0;
		}		
		setDecimalPlace(getDecimalPlace() + 1); // Die nächste Dezimalstelle merken.
		return tempRaiseValue;		
	}
	
	public IntervallWurzel(){
		setDecimalPlace(0);
		setRaiseValue(determineRaiseValue());
	}	
	
	private void setRaiseValue(double raiseValue) {
		this.raiseValue = raiseValue;
	}

	private double getRaiseValue() {
		return raiseValue;
	}

	private int getDecimalPlace() {
		return decimalPlace;
	}

	private void setDecimalPlace(int decimalPlace) {
		this.decimalPlace = decimalPlace;
	}	
}