Hola esta bien tu código pero me pregunto, necesitas un arreglo para almacenar los registro y otro del mismo tamaño para saber en que posición se encontrarían ordenados? siendo muy estrictos realmente no es un método de ordenamiento ya que los datos siguen como en su estado original.

Pero bueno tomemos tu algoritmo como valido y comparemoslo frente a otros algoritmos amplia-mente documentados y como serian bubble sort y Quick sort como se comporta

Para ello necesitamos algunas subrutinas que nos midan el tiempo de procesamiento de nuestros algoritmos lamentablemente hacer esto no siempre es muy preciso y depende del sistema operativo y arquitectura de la computadora donde se ejecuten estas pruebas.

La primera prueba que vamos a hacer es con tu algoritmo para ello lo encapsule en una función y decidí tomar algunas muestras

#include <stdio.h>
#include<windows.h>
#include <time.h>
 
double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b){
    LARGE_INTEGER freq;
    QueryPerformanceFrequency(&freq);
    return (double)(a->QuadPart - b->QuadPart) / (double)freq.QuadPart;
}
 
 
 
void rellenarOrdenarDatos(int numeros[],int ordenar[],int tamano){
    int i,j,ingreso;
    srand(time(NULL));
 
    for( i=0; i<tamano; i++){
 
        ingreso = rand()%100;
        numeros[i]=ingreso;
        ordenar[i] = 1;
 
        if(i>0){
            j=0;
            while(j<i){
                if( ingreso < numeros[j] ){
                    ordenar[j] += 1;
                }
                else{
                    ordenar[i] += 1;
                }
                j++;
            }
        }
    }
}
 
int main()
{
    const int TAMANO=15000;
    int *arreglo=malloc(sizeof(int)*TAMANO);
    int *ordenar=malloc(sizeof(int)*TAMANO);
 
    LARGE_INTEGER t_ini, t_fin;
    double secs;
 
    QueryPerformanceCounter(&t_ini);
 
    rellenarOrdenarDatos(arreglo,ordenar,TAMANO);
 
    QueryPerformanceCounter(&t_fin);
 
    secs = performancecounter_diff(&t_fin, &t_ini);
    printf("%.16g milliseconds\n", secs * 1000.0);
 
    free(arreglo);
    free(ordenar);
 
    return 0;
}

Entre las muestras que obtuve fueron estos tiempos en milisegundos

Ahora la prueba con BubbleSort

#include <stdio.h>
#include<windows.h>
#include <time.h>
 
double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b){
    LARGE_INTEGER freq;
    QueryPerformanceFrequency(&freq);
    return (double)(a->QuadPart - b->QuadPart) / (double)freq.QuadPart;
}
 
 
 
 
void rellenarArreglo(int numeros[],unsigned int tamano){
    srand(time(NULL));
    int i=0;
 
    for(i=0; i<tamano; i++)
    {
        int r = rand()%100+1;
        numeros[i]=r;
    }
}
 
void bubbleSort(int numeros[],int tamano){
    int i,j,temp;
    for (i=1; i<tamano; i++){
      for(j=0 ; j<tamano - 1; j++){
         if (numeros[j] > numeros[j+1]){
            temp = numeros[j];
            numeros[j] = numeros[j+1];
            numeros[j+1] = temp;
         }
      }
    }
}
 
 
 
int main()
{
    const int TAMANO=15000;
    int *arreglo=malloc(sizeof(int)*TAMANO);
 
 
    LARGE_INTEGER t_ini, t_fin;
    double secs;
 
    QueryPerformanceCounter(&t_ini);
 
    rellenarArreglo(arreglo,TAMANO);
    bubbleSort(arreglo,TAMANO);
 
    QueryPerformanceCounter(&t_fin);
 
    secs = performancecounter_diff(&t_fin, &t_ini);
    printf("%.16g milliseconds\n", secs * 1000.0);
 
    free(arreglo);
 
 
    return 0;
}

Utilizando el algoritmo bubble sort el tiempo de procesamiento fue mas alto por ende menos optimo aproximadamente 1500 milsegundos en promedio, en este caso te debo los tiempos exactos

Por ultimo utilize el algoritmo Quick Sort y la diferencia fue abismal
El siguiente codigo es similar al anterior salvo por el metodo de ordenamiento

void qs(int lista[],int limite_izq,int limite_der)
{
    int izq,der,temporal,pivote;
 
    izq=limite_izq;
    der = limite_der;
    pivote = lista[(izq+der)/2];
 
    do{
        while(lista[izq]<pivote && izq<limite_der)izq++;
        while(pivote<lista[der] && der > limite_izq)der--;
        if(izq <=der)
        {
            temporal= lista[izq];
            lista[izq]=lista[der];
            lista[der]=temporal;
            izq++;
            der--;
 
        }
 
    }while(izq<=der);
    if(limite_izq<der){qs(lista,limite_izq,der);}
    if(limite_der>izq){qs(lista,izq,limite_der);}
 
}
 
void quicksort(int lista[],int n)
{
    qs(lista,0,n-1);
}
 
 
 
int main()
{
    const int TAMANO=15000;
    int *arreglo=malloc(sizeof(int)*TAMANO);
 
 
    LARGE_INTEGER t_ini, t_fin;
    double secs;
 
    QueryPerformanceCounter(&t_ini);
 
    rellenarArreglo(arreglo,TAMANO);
    quicksort(arreglo,TAMANO);
 
    QueryPerformanceCounter(&t_fin);
 
    secs = performancecounter_diff(&t_fin, &t_ini);
    printf("%.16g milliseconds\n", secs * 1000.0);
 
    free(arreglo);
 
 
    return 0;
}

Aqui una lista de tiempos obtenidos

En promedio 2 mili-segundos el tiempo de procesamiento

En conclusion yo te recomendaria usar une metodo de ordenamiento ya que ademas de que evitas reservar memoria inecesaria el performance es mejor.

SI hay dudas o no estas de acuerdo con algo no dudes en hacermelo saber.
Saludos....

Hola creo te refieres a los switch anidados revisa este codigo

#include <iostream>
 
using namespace std;
 
int main()
{
    int opcion;
    cout<<"Escoga una opcion del 1 al 5"<<endl;
    cin>>opcion;
 
    switch(opcion){
        case 1:cout<<"Opcion 1"<<endl; break;
        case 2:cout<<"Opcion 2"<<endl;break;
        case 3:{
            int opc;
            cout<<"ingrese una opcion del 1 al 3" <<endl;
            cin>>opc;
            switch(opc){
                case 1:cout<<"Opcion 1 interna"<<endl;break;
                case 2:cout<<"Opcion 2 interna"<<endl;break;
                case 3:cout<<"Opcion 3 interna"<<endl;break;
                default: cout<<"Opcion interna incorrecta"<<endl;break;
            }
        }break;
        case 4:cout<<"Opcion 4"<<endl; break;
        case 5:cout<<"Opcion 5"<<endl; break;
        default: cout<<"Opcion incorrecta"<<endl; break;;
    }
    return 0;
}
 

Espero te sirva saludos....

La verdad si eres totalmente novato en programacion te animo seguir algun curso de programacion puedes empezar con este de jesus conde la verdad es simple

https://www.youtube.com/playlist?list=PLFDA837BC005D3614

PD: Ahi viene la respuesta

Bueno  para gusto los colores hay gente que defiende la tauromaquia y otra que la critica lo cierto esto es que esto no se va a terminar en varios años y mientras siga habiendo una importante población que siga asistiendo a estos espectáculos lo mas probable es que  continúen, no se si es cultural o no pero  admito que me a mi gusta sera que porque he me he criado en un pueblo donde las rancherías abundan y estos eventos son de lo mas normal ademas que mucha gente se gana la vida con ello.  

Te dejo el siguiente enlace https://ebooks-it.org/1590597931-ebook.htm no me hago responsables por los derechos de autor si algun moderador ve que infringí alguna regla pues que retire el enlace.

Saludos...

Jesusinfo  tienes que tener cuidado con la funcion borrar() esta tiene truco ya como ha dicho AlbertoBSD  tienes dos opciones o marcar que la casilla esta vacia o reacomodar las posciones del arreglo

Como te mecione en el post anterior yo prefiero utilizar struct porque son un poco mas flexibles y facilmente se le puede asignar un atributo que indique vacio u ocupado segun se necesite, bueno regresemos al problema para  saber la manera sencilla si una posicion esta vacia segun tu codigo es marcar la casilla con el numero -1 con este puede ser una marca para comprar si una casilla esta vacia  o no.

El otro problema que aparentemente podria ser una mejor opcion pero al mismo tiempo puedes ser un poco mas complicado es reacomodar las posiciones del arreglo.

Supongamos tu ingresas a N estudiantes digamos 5 cada uno con su valor que lo identifica

[1] [2] [3] [4] [5]

cada casilla obviamente esta asociado a N cantidad de calificaciones creo en este ejemplo son tambien 5


Bueno que pasa si el usuario decide eliminar al estudiante numero 3
Lo mas facil seria declararlo como vacio de esta forma

[1] [2] [-1] [4] [5]

Asi cuando imprimir a los estudiantes no existiria el numero 3, en ese momento al momento de marcarlo vacio estas dejando una posicion en desuso  tienes dos opciones al momento de agregar otro alumno el primer es recorrer todo el arreglo y econtrar una poscion vacia(marcada como -1) y anadir ahi al estudiante y la otra es anadir al final de la lista como se esta haciendo habitualmente ingnorando que estamos desperdiciando lugares y claramente memoria.


Por ultimo otra opcion que tenemos como dije mas arriba es reordenar el arreglo supongamos
tenemos esta lista originalmente

 
[1] [2] [3] [4] [5]
 
Eliminamos el tercero
[1] [2]  ? [4] [5]

Pero en vez de marcarlo como vacio con el numero -1 recorremos todo el arreglo haciendo esto

[1] [2] [4] [5]

Esto implica mover todas las casillas que se encuentra a la derecha una posicion anterior eso para un programa que tiene maximo 100 estudiantes no es nada pero imaginates si fueran cantidades mucho mas grandes y complejas la cosas ya no seria tan optima.

Entiendo que estas practicando y te animo ha que termines tu programa usando arreglos es una buena practica y te ayuda a pensar.
Pero seria bueno revisar vectores y  listas enlazada para que te des una idea que este problema se podria resolver de una manera mas simple no importando la cantidad de estudiantes.


Espero te sirva este choro que he escrito.
Saludos....

Hola tienes varios problemas de entrada los nombres de las personas los estas manejando como enteros tienes dos opciones o manejarlos como string o un arreglo de char al ver que estas en C++ aconsejo los strings  otra cosa es que no estabas guardando correctamente las notas ya que las estabas  sobrescribiendo.

Al imprimir no recorrias correctamente los arreglos de notas y nombres de los estudiantes y por eso los datos no eran los correctos, bueno me di a la tarea de modificar tu programa y ya funciona pero tiene detalles.

#include <iostream>
 
using namespace std;
 
void llenar (string  estudiantes[], int notas[]);
void imprimir(string estudiantes[], int notas[]);
int menu ();
 
//variables
int num=0;
int asignatura=5;
 
string estudiantes[100];
int posicionesEstudiante=0;
 
int notas[100];
int posicionNotas=0;
 
int main()
{
 
    int opc;
 
    do
    {
        opc=menu();
        switch (opc)
        {
        case 1:
            llenar(estudiantes, notas);
            break;
        case 2:
            imprimir(estudiantes, notas);
            break;
        case 3:
            cout<<"\nADIOS"<<endl;
            break;
        }
    }
    while (opc !=3);
    cin.get();
}
 
void llenar (string estudiantes[], int notas [])
{
 
    cout<<"Deme el numero de estudiante a insertar: "<<endl<<endl;
    cin>>num;
 
    for(int i=0; i<=num-1; i++)
    {
        cout<<"\nDame el estudiante "<<i+1<<endl;
        cin>>estudiantes[posicionesEstudiante];
        for (int x=0; x<asignatura; x++)
        {
            cout<<"\nNota "<<x+1<<" del estudiante "<<i+1<<" :";
            cin>>notas[posicionNotas];
            posicionNotas++;
 
        }
        posicionesEstudiante++;
 
    }
 
}
 
void imprimir (string estudiantes [], int notas [])
{
    int contador=0;
    for(int i=0; i<=posicionesEstudiante-1; i++)
    {
        cout<<"\nESTUDIANTE "<<i+1<<endl<<endl;
        cout<<estudiantes[i]<<endl<<endl;
        for (int x=0; x<asignatura; x++)
        {
            cout<<notas[contador]<<endl;
            contador++;
        }
 
    }
 
}
 
int menu ()
{
    int opc;
    cout<<"1.LLENAR\n2.IMPRIMIR\n3.SALIR"<<endl;
    cin>>opc;
    return opc;
}
 

Si quieres puedes reformular tu  programa y usar structs para poder tener una mejor abstraccion.
Ejemplo:

#include <iostream>
 
using namespace std;
 
const int NUMERO_ASIGNTURAS=5;
 
struct Estudiante
{
    string nombre;
    int asignaturas[NUMERO_ASIGNTURAS];
};
 
int main(){
  Estudiantes estudiantes[100];
 
  return 0;
}
 

Si sabes usar vector o listas enlazadas puedes sustuir los arreglos.
Si tienes dudas avisanos saludos...

Si lo resuelves el problema estaría genial que publicaras como lo hiciste
Saludos...

Creo que seria mejor un uint8_t ya que este vale 1 byte y el uint16_t  2 bytes

PD: Cual es el objetivo de optimizar el struct?
Saludos....

Personalmente para hacer juegos no me gusta mucho trabajar con las librerias estandar de java has probado con alguna de tercero que este enfocada a video juegos?

Bueno te recomiendo revisar el binding que hay de la libreria sfml
http://pdinklag.de/jsfml/

Tambien te dejo su wiki con ejemplos de uso
https://github.com/pdinklag/JSFML/wiki/Windows

Saludos....