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;}
 

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.

Lo encontré en wikipedia.

Gracias por la colaboración

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;
    }
}