quicksort(int[], int, int);

• Las líneas 30 - 32 van fuera de ese for(). Así estás haciendo un intercambio en cada iteración de dentro y muchas veces será entre un mismo elemento, lo que equivale a no hacer nada.
• Elimina las declaraciones de i y de j en la línea 5. Las estás declarando nuevamente en el for().
• Utiliza otro nombre de variable en el for() de la línea 36. Puedes tener conflictos entre una i y la otra. Aparte supongo que ese último for lo tendrás para hacer las pruebas porque sino no tiene mucho sentido que muestres todos los productos en cada movimiento.

• Crear las dos clases ejecutables de manera independiente. Ambas clases deben tener su método main() y la clase hija (independiente) debe poder ejecutarse por si sola y funcionar correctamente. Esta última la vamos a crear con un BufferedReader para obtener los datos de la entrada estándar:

public class Independent {
  public static void main(String[] args) {
    try(BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) { // try-with-resources para cerrar automaticamente el br
      System.out.println("Introduce un numero: ");
      int numero = Integer.parseInt(br.readLine());
      System.out.println(numero * 2);
    } catch(Exception e) {}
  }
} 

public class Dependent {
  public static void main(String[] args){
    ProcessBuilder pb = new ProcessBuilder("java", "Independent"); // comando para lanzar la otra clase como si se hiciese desde linea de comandos
    try {
      Process p = pb.start(); // iniciamos el proceso
      OutputStream os = p.getOutputStream(); // redireccionamos su ENTRADA a os. Se utiliza output porque se entiende que es la salida del padre
      BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream())); // redireccionamos su SALIDA (que es la entrada para el padre)
      os.write((4 + "\n").getBytes()); // Simulamos que hemos introducido un 4 por teclado y le hemos dado al enter
      os.flush(); // hacemos que los bytes anteriores se escriban en el flujo. Si no hacemos esto se quedaran en un buffer temporal y no continuara
      // Ahora el programa hijo que ha sido lanzado hace un rato acaba de recibir el flujo anterior como si lo hubiesemos introducido por teclado
      // Ahora "ha mostrado" el resultado (8). Tenemos que recoger su salida mediante br:
      br.readLine(); // Leemos la primera linea de su salida que no interesa (porque es: "Introduce un numero: \n")
      int doble = Integer.parseInt(br.readLine()); // Guardamos el 8 que se habria mostrado por pantalla
      System.out.println("El resultado es: " + doble);
    } catch(Exception e){}
    // ...ahora habria que cerrar flujos y demas...
  }
} 

• Si trabajas desde un IDE es posible que tengas problemas con la instanciación del ProcessBuilder pues tendrás que utilizar un comando de ejecución algo más complejo.
• Si trabajas en Windows y tu IDE está configurado en UTF-8 tendrás que añadir la codificación a la instrucción.

POR FAVOR, CUALQUIER AYUDA O COMENTARIO ES BIENVENIDO    
ESPERO NO ME IGNOREN...

-Muestra el laboratorio de un producto buscándolo por su descripción, en este ya hice unos cambios que de hecho están en el menú "buscarDescripcion"; pero no me da el resultado que espero

char existeProducto2(char descripcionProducto, Producto *producto)//
{
	FILE *archivo;
	char existe;
 
	/* Abre el archivo en modo lectura */
	archivo = fopen("productos.dat", "rb");
 
	if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
		existe = 0;
 
	} else {
		existe = 0;
 
		/* Se busca el producto cuyo código coincida con codigoProducto */
		fread(&(*producto), sizeof(*producto), 1, archivo);
		while (!feof(archivo)) {
			if ((*producto).descripcion == descripcionProducto) {
				existe = 1;
				break;
			}
			fread(&(*producto), sizeof(*producto), 1, archivo);
		}
 
		/* Cierra el archivo */
		fclose(archivo);
	}
 
	return existe;
} 

• La función fread() la puedes meter en la condición del while()
• La nomenglatura: (*puntero).valor se puede sustituir por: puntero->valor.
• Los operadores & y * se anulan. Utilizar: &(*p) es lo mismo que utilizar: p.

struct Base {
  virtual void show(){
    cout << "Base" << endl;
  }
};
 
struct Derived : Base {
  void show(){
    Base::show();
    cout << "Derived" << endl;
  }
};
 
int main(){
  Derived d;
  Base *p = &d;
  p->show();
} 

Base
Derived 

• La variable creada es del tipo de la struct derivada. Entonces se llama a la función definida ahí.
• Una función virtual se define así para eso, para poder llamar a la función más adecuada en tiempo de ejecución

struct Base {
  void show(){
    cout << "Base" << endl;
  }
};
 
struct Derived : Base {
  void show(){
    cout << "Derived" << endl;
  }
};
 
int main(){
  Base b;
  b.show(); // b es de tipo Base, se muestra: Base
  Derived d;
  d.show(); // d es de tipo Derived, se muestra: Derived
  // LA DIFERENCIA ESTA AQUI:
  Base *p = &b;
  p->show(); // El puntero es de tipo Base, se muestra: Base
  p = &d;
  p->show(); // El puntero sigue siendo de tipo Base, se muestra: Base
} 

struct Base {
  virtual void show(){
    cout << "Base" << endl;
  }
};
 
struct Derived : Base {
  void show(){
    cout << "Derived" << endl;
  }
};
 
int main(){
  Base b;
  b.show(); // b es de tipo Base, se muestra: Base
  Derived d;
  d.show(); // d es de tipo Derived, se muestra: Derived
  // LA DIFERENCIA ESTA AQUI:
  Base *p = &b;
  p->show(); // La variable a la que apunta es de tipo base, se muestra: Base
  p = &d;
  p->show(); // La variable a la que apunta es de tipo derived, se muestra: Derived
} 

• Empiezas a rellenar el array en la posición 1 y acabas en la 5 (incluida). Los arrays tienen longitud 5 y como en C/C++, el primer índice es el 0, deberías recorrer desde 0 hasta 4 (incluido). {0,1,2,3,4} -> 5 posiciones. La posición 5 queda fuera del array.
  
• En la función EncuentraMayor() no buscas los índices en los que se encuentre el elemento más grande sino cuántas veces aparece el elemento más grande. Esto es porque incrementas la variable cont cada vez que lo encuentras.

#include <stdio.h>
 
const int MAX_SIZE = 5;
 
int main(){
  int v1[MAX_SIZE], v2[MAX_SIZE];
  // Guardar los valores en los arrays. Recuerda: desde el 0 hasta el MAX_SIZE-1.
  for(int i = 0; i < MAX_SIZE; ++i){
    printf("Introduce el valor %d: ", i+1);
    scanf("%d", &v1[i]);
  }
  //...
  int valorMaximo = buscarMayor(v1, MAX_SIZE);
  mostrarIndices(v2, valorMaximo);
} 

int buscarMayor(int v[], int size); 

void mostrarIndices(int v[], int valorBuscado);

• Los tiempos de carga cuando abro un proyecto no son pequeños que digamos y eso que son proyectos muy sencillos.
• Cada vez que ejecuto una aplicación, es bastante lento construyendo el proyecto también. Además los proyectos aumentan mucho de tamaño al ser construidos. No sé si será por la plataforma (Android) o por el IDE pero nunca me ha pasado esto con proyectos de escritorio de Eclipse (Java) o Visual Studio (C#).
• Los AVDs no son muy de fiar. He tenido problemas para ejecutar algunos intents implícitos en estos porque no se lanzan y al final he tenido que probar las aplicaciones en mi dispositivo (lo cual también es una pesadilla tener que estar siempre con el móvil conectado).
• La vista de Diseño de los xml tampoco es muy de fiar. En ocasiones los componentes no se actualizan correctamente hasta después de ejecutar la aplicación.