Ordenar vector en otro vector

Explica un poco mejor lo que buscas. Tienes un vector desordenado y tienes que crear uno nuevo ordenado? te piden algun algoritmo en especial? tamaños de los vectores? fijos o variables?

Pues nose si te liare ahora pero asi rapido y chapuzero haria:

int DIMv1 = 0;
int DIMv2 = 0;
int aux = v1[0];
for (recorrer vector original desde v[1])
{
if (v2[DIMv2] >= v1 && v1 < v[i-1])
aux = v1
v2[DIMv2] = aux
DIMv2++
}

Nose si esta bien y no creo que sea muy efectivo xD pero en teoria hace una primera pasada al v1 buscando el valor mas pequeño i lo pone en el v2, hace una segunda pasada i busca el valor mas pequeño que no sea mas menor que el ultimo puesto en el v2 i asi va haciendo

voi a probar con los 2 gracias

no me sale ná xD

Si, lo único que tiene que hacer es:

Primer elemento del vector resultante -> Elemento más pequeño del vector desordenado

Elemento i-ésimo del vector resultanto (i != 0) -> Elemento más pequeño del vector desordenado y que sea mayor a res

Edit: He realizado este en C++ que parece que funiona: http://pastebin.es/2028 <-- Comentado

vector<int> ordena(const vector<int>& v) {
    int m = v.size();
    vector<int> res(m);
    

for (int i = 0; i < m; ++i) {
    int min;
    int c = 0;
    
    if (i == 0) min = v[0];
   else {
        while (v[c] <= res[i - 1]) ++c;
        min = v[c];
    }
    ++c;
    
    while (c < m) {
        if (v[c] < min) {
            if (i == 0 or v[c] > res[i - 1]) min = v[c];
        }
        ++c;
    }
    
    res[i] = min;
}

return res;
}

PD: Poner "int min=1000000; " es una xapucilla ee xDD es demasiado facil joder el programa poniendo simplemente 1000001
Puestos a hacer eso crea un long int y pones un número no representable con un INT, así te aseguras de que realmente siempre será mayor xD Igual que poner "limite = 0" te impide ordenar números negativos.

"Si esta mal o te da problemas dilo por aqui"
El puede decirte que está mal y yo no? xDD

int Lista[10], Mayor=0;
for(int I=0; I<9; I++) {
for(int i=0; i<9-I; i++) {
if (Lista>Lista[i+1]) {
Mayor=Lista;
Lista=Lista[i+1];
Lista[i+1]=Mayor;
}
}
}

El codigo consta de dos bucles: el segundo se encarga de comparar los elementos de dos en dos y colocar el mayor delante del menor y viceversa hasta el noveno elemento (ya que el decimo no tiene con cual compararse). Y el primero solamente repite ese ciclo tantas veces como elementos-1 tiene la lista (9) haciendo que cada vez el segundo bucle sea mas corto porque como ya sabras una vez se usa el metodo de la burbuja el ultimo elemento es sin riesgo a equivocacion el mas grande (o pequeño) de toda la lista. Lo mismo pasa cuando se usa por segunda vez pero esta vez con los dos ultimos elementos, y la tercera con los tres, la cuarta con los cuatro, y suma y sigue...

#11
No esta mal (o si, no lo se, no lo he probado) pero eso de poner un limite arbitrario es poco preciso... es como si un ingeniero sabiendo que un coche necesitara tener mucha resistencia decide poner 10 parachoques a la tururu.

buscarMenor deberia, cojer el menor e intercambiarlo con el ultimo disminuyendo el maximo en 1. ¿ no ?
No se C# pero sera parecido a C++ / C no ?

No lo he compilado ni nada pero no distara mucho, si son enteros lo que ordenas cambia elemento por int y ya ta.

EDIT: Acabo de ver lo de "min = 10000;" , joer : min = v[0]; y ya empiezas en el 1. Y lo del limite, si tienes -1 ya la has jodio xD.

PD: Faltaria la funcion intercambia pero esa no hara falta q la ponga vdd ?

elemento menor(elemento* v, int* max){
  int i;
  elemento e;
  int j;

 e=v[0];
 for ( i=1; i<=*max; i++)
  {
    if ( v[i] < e)
    { e = v[i]; 
       j = i; 
    }
  }

 intercambia(v[*max],v[j]);
 *max= *max-1;
 return e;
}

elemento* ordena(elemento *v, int numElementos){
  elemento ord[numElementos]; // No se si funcionara eso
  elemento aux;
  int i,j,n;
  n= numElementos;
 for(i=0;i<numElementos; i++)
  { aux=  menor(v,&n);
     ord[i] = aux;
  }
}

Mi codigo funciona perfectamente y a la primera. La mayoria no usais el metodo de la burbuja y por eso os salen codigos tan complicados, con dos bucles es mas que suficiente.

Bueno, no sé si he entendido bien, hace tiempo que no programo. Pero, quiero comprobar lo oxidado que estoy! XD Por de pronto se que ya no recuerdo ni el seudolenguaje! XD Pero bueno, esto es lo que haría yo. Chapuzeado al máximo! XD

Leer primera posición. i=vec1 (Por ejemplo)
Comparar con la siguiente posición. i+1<=vec1
Si es menor o igual i+1=Vec1
Si no pasas a la siguiente posición del vector i+2
Y vuelves a comparar. (con esto buscas el valor mínimo comparándolo con el resto de elementos del vector si tener que usar valores limites, solo el contenido del vector).
Repetir hasta ultima posición del vector.
Escribir Posición en nuevo vector.
Repetir búsqueda hasta el final de la longitud del vector.