Pregunta 1.

static public double mediana(double [] x, int n){
	double [] aux = new double[n];
	for(int i=0;i<n;i++)
		aux[i]=x[i];
	aux = Ordenar(aux);  	// Aqui puede haber cualquier algoritmo visto en 
					//clases...
	if(n%2 == 0){  		//Si n es par...
		double x1 = aux[n/2];
		double x2 = aux[n/2-1];
		return (x1+x2)/2;
	}
	else
		return aux[n/2];
}

El orden del algoritmo depende del metodo usado para ordenar.
Si fue QuickSort, entonces seria n (en copiar) mas nlog(n) (quicksort)
n+nLog(n)=n(1+Log(n))= O(nLog(n)).

Pregunta 2.

static public double moda(double []x , int n){
	int count_max=0;
	double moda;
	for(int i=0;i<n;i++){
		int count=0;
		for(int j=i;j<n;j++)
			if(x[j]==x[i])
				count++;
		if(count>count_max){
			count_max=count;
			moda=x[i];
		}
	}
	return moda;
}

Este algoritmo es de O(n*n) ya que por cada elemento del arreglo lo recorro 
completamente.
Si ordenaramos el arreglo antes mejoraria el tiempo ya que en ordenarlo con 
QuickSort nos demoramos
nLog(n) y para encontar la moda solo lo debemos recorrer una vez, O(n).


Pregunta 3.
static public void ordenar(String[]x, int n, int[]y){
	for(int i=0;i<n-1;++i){
		int im=i;
		for(int j=i+1;j<n;j++)
			if(x[j]<x[im])
				im=j;
		y[i]=im;	//Aqui esta la diferencia... en vez de
				//En vez de intercambiar en el arreglo x
				//anoto en el arreglo y el indice del
				//menor
	}
}


Pregunta 4.
....
public static void main.....{
	//Inicializar el teclado
	Console c = new Console();
	double[] notas=new double[100];
	int n=0;
	while(n<100){
		c.println("Ingrese una nota.Fin con -1");
		double nota=c.readDouble();
		if(nota==-1)
			break;
		notas[n]=nota;
		n++;
	}

	c.println("La mediana :"+mediana(notas,n));
	c.println("La moda    :"+moda(notas,n));
	//Para los ascendentes y descendientes usare un arreglo con
	//los indices ordenados y luego los recorro desde el inicio para
	//los ascendentes y desde el final para los otros
	int[] asc =new int[100];
	ordenar(notas,n,asc);
	c.println("Original\tAscendente\tDescendente");
	for(int i=0;i<n;i++){
		c.print  (notas[i]+"   \t");		//Orden intacto
		c.print  (notas[asc[i]]+"  \t");	//Orden ascendente
		c.println(notas[asc[n-i-1]]+"  ");	//Orden descendente
	}
}



