Foro de elhacker.net

Hola, quiero ordenar un vector en orden creciente.

Para ello he creado una función que me devuelva el valor máximo del vector, así este elemento ya lo situó como el primer elemento del vector. Luego una acción para intercambiar los elementos en caso que un  elemento menor sea menor que un elemento mayor.

Gracias por la ayuda ;)

#include<iostream>
#include<vector>
using namespace std;
 
int maxim(vector<int>&v){
    int i=0,m;
    while(i<v.size()){
 
    if(v[i]>=v[m]){ m=i;
                  }
                      i++;
                      }
    return m;
    }
 
void intercambia(int &a,int &b){
     int m=a;
     a=b;
     b=m;
     }
void ordena(vector<int>&v){
     int m=maxim(v);
     v[0]=m;
     for(int i=1;i<v.size();i++){
             if(v[i]<v[i+1]){
             intercambia(v[i],v[i+1]);}
             }
 
     }
 
int main(){
     int n,e;
     cout<<"introduzca el tamaño del vector"<<endl;
     cin>>n;
     vector<int>v(n);
 
     for(int i=0;i<n;i++){
     cout<<"introduzca el elemento"<<" "<<i<<" del vector"<<endl;
             cin>>e;
             v[i]=e;
             }
    ordena(v);
 
    for(int i=0;i<v.size();i++){
            cout<<v[i]<<endl;
            }
    system("pause");
    return 0;}
 

Lo mejor para ordenar un vector es utilizar la función sort (http://www.cplusplus.com/reference/algorithm/sort/).

Errores en el programa hay varios. En la función "ordena":

int m = maxim(v);
v[0] = m;

Con eso pierdes el primer valor del vector ya que no lo resguardas y si la intención es ordenar en orden ascendente el elemento mayor debe colocarse en la ultima posición.

Otro error se encuentra en la función que busca el máximo:

int i = 0, m;
 
while (i < v.size()){
   if (v[i] >= v[m]){
      m = i;

Ahí falta inicializar la variable "m", lo usual es asumir que el máximo es el primer elemento buscando uno mayor entre los restantes.

Otro error en el bucle de la función "ordena":

void ordena(vector<int>&v)
{
   int m = maxim(v);
   v[0] = m;
 
   for (int i = 1; i < v.size(); i++){
      if (v[i] < v[i + 1]){
         intercambia(v[i], v[i + 1]);
      }
   }
}

En la ultima iteracion del bucle el valor de "i" es "size - 1" y la expresión "i + 1" termina como "size - 1 + 1" que es igual a "size". No puedes utilizar ese valor y acceder al elemento "v[size]" ya que este no existe (los indices validos van de 0 a size-1).

Por ultimo buscar el elemento mayor me hace pensar en el algoritmo SelectSort. Por otra parte en la función donde intentas ordenar intercambias elementos adyacentes y eso es propio del algoritmo BubbleSort.

Mejor indícanos que algoritmo deseas implementar en tu programa.

Un saludo

Además que para poder recorrer correctamente una lista o un vector es mejor usar un iterador para apuntar exactamente al espacio de memoria reservador por el vector

http://www.cplusplus.com/reference/vector/vector/begin/

// vector::begin/end
#include <iostream>
#include <vector>
 
int main ()
{
  std::vector<int> myvector;
  for (int i=1; i<=5; i++) myvector.push_back(i);
 
  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it = myvector.begin() ; it != myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';
 
  return 0;
}

seria algo más o menos así

 
//Inicializando el iterador de operacion para recorrer el vector, algo asi como "int i=0"
vector<int>&v::iterator it = v.begin();
 
for(; it != v.end(); it++)
{
       //algoritmo de intercambio, tu funcion tipo burbuja usando auxiliares
       // ... reordenando
       // ... reordenando
}
 
 

Pues para ser practica, estas simplemente separando un burbuja de tu funcion principal, asi que independientemente si es un arreglo, una lista, un vector o similar puedes reutilizarlo, vas bien, pero te daras cuenta, que reinventar la rueda es algo ineficiente si lo llevas a terminos practicos, una vez aprendas a usar correctamente estas funciones, intenta con sort, que es una funcion de la libreria vector la cual puedes usar de diferentes formas dependiendo de lo que necesites.

cuando usas el iterador, te ahorras el problema del size y tamaños los cuales pueden salir del rango de posiciones reservadas en la memoria, pero tiene un problema muy molesto y es que cada vez que es requerido un iterador debe declararse a la justa medida de lo que se necesita, y a veces ello puede alargar innecesariamente una linea de codigo, lo que lo hace dificil de entender, para ello se ha implementado la palabra reservada "auto" pero solo funciona si es compilado bajo el estandar C++11/c++0x, y es bueno, cuando menos enredado.

El algoritmo de ordenamiento por selección.

Lo encontré en wikipedia.

Gracias por la colaboración :D

void ordena_seleccion(vector<int>& v) {
    for (int i = 0; i < v.size(); ++i) {
        int min = i;
        for (int c = i + 1; c < v.size(); ++c) {
            if (v[min] > v[c]) min = c;
        }
        int aux = v[i];
        v[i] = v[min];
        v[min] = aux;
    }
}
 

Eso no es así, el operador[] también apunta al espacio de memoria.

Una de las ventajas que tiene de usar iteradores en vectores es que si después quieres cambiar a una lista, no tienes que cambiar nada del código.