EcuRed - Contribuciones del colaborador [es]

Discusión:Sales Biliares

2011-11-26T18:20:43Z

Manuel jc.manzanillo1: Página creada con 'Le añadí una foto al artículo'

Le añadí una foto al artículo

Archivo:Sales Biliares.jpg

2011-11-26T18:18:01Z

Manuel jc.manzanillo1:

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Discusión:Sales Biliares

2011-11-26T17:06:50Z

Manuel jc.manzanillo1: Página blanqueada

Sales Biliares

2011-11-26T17:03:22Z

Manuel jc.manzanillo1:

{{Medicamento
|nombre= Sales Biliares
|logo= Sales_Biliares.jpg
|tamaño= Tabletas de 65 mg
|descripción=Tabletas de color Marron
|Via_de_administracion= VO
|Grupo_terapeutico=Afecciones Gastroinstestinales
}}
'''Sales biliares.''' Son las sales de los ácidos biliares, pueden ser sales sódicas o potásicas. Los ácidos modificados taurocólico y glicocólico, también tienen sales.
== Composición==
Cada tableta revestida contiene 65 mg de sales biliares de magnesio;27,285 mg de lactosa monohidratada, excipiente c.s.
== Mecanismo de acción y acciones farmacológicas ==
Mecanismo de acción: es estimulante de la secreción biliar, aumenta y promueve la expulsión de la bilis. Favorece la digestión de las grasas, las que pasan a la sangre en forma saponificada. El hígado reabsorbe y reexcreta las sales biliares para formar un ciclo necesario en la absorción de las grasas. La principal función de las sales biliares es actuar como coleréticas, también posee acción colagoga. En los estados de deficiencias biliares actúan como terapia sustitutiva, al suplir las sales biliares deficientes y al mismo tiempo estimulan la producción del flujo biliar. Se le atribuyen a las sales biliares acción colepoyética, estimulando las células hepáticas para producir bilis; sin embargo, este punto está en discusión, ya que la cantidad eliminada de sales biliares no es mayor que la administrada. Otra función de la bilis consiste en neutralizar el quimioácido que proviene del estómago, aunque en este sentido su acción es inferior a la del jugo pancreático.
Un derivado del ácido cólico -el ácido dehidrocólico- ha mostrado ser hasta ahora el más potente colerético en cuanto a volumen de bilis secretada, aunque esta aumente en líquido y no en proporción de sólidos. El ácido dehidrocólico, por tanto, es solo un hidrocolerético, pero es menos tóxico que las sales biliares.
== Farmacocinética ==
Acción local.
== Indicaciones ==
En todos los casos de insuficiencia biliar acompañada o no de colecistitis, colangitis, colelitiasis no obstructiva.

== Contraindicaciones ==
Pacientes con galactosemia congénita, síndrome de malaabsorción de la glucosa y de la galactosa o déficit de lactasa.
== Precauciones ==
Pacientes con intolerancia a la lactosa.
== Reacciones adversas ==
No se reportan.
== Posología ==
1-3 tabletas revestidas diarias, antes de cada comida y al acostarse.
== Regulación a la prescripción ==
Por receta médica.
== Fuentes ==
*Formulario Nacional de Medicamentos.

[[Category:Medicamentos_sintéticos]]

Microvita

2011-11-26T16:35:31Z

Manuel jc.manzanillo1:

{{Sistema:Moderación_Salud}}
{{Medicamento|nombre= Microvita |logo= Micro_Vita.jpg|descripcion=Se recomienda en el manejo del acné, fotodaño, hiperqueratosis y celulitis.|presentacion_farmaceutica=Crema |Via_de_administracion=Aplicación en la piel|Grupo_terapeutico=Dermatológicos}}
''' Microvita '''. Pertenece a la familia de [[medicamentos]] llamados dermatológicos. Se usa para el manejo del [[acné]], donde proporciona muy buenos resultados. Además es efectivo cuando se presenta fotodaño, hiperqueratosis y celulitis.

== Ingrediente activo y propiedades: ==

La Microvita contiene retinol, un retinoide precursor del ácido retinoico. El retinol aplicado en la piel, penetra y se transforma parcialmente en ácido retinoico. Ambos compuestos ejercen sus efectos mediante interacción con sus receptores dérmicos respectivos. Tal interacción modula muchas de las funciones del tejido cutáneo, como son:

* Favorecer el crecimiento y diferenciación de los queratinocitos y fibroblastos, células integrantes de la epidermis y dermis, respectivamente.

* Reducir la adherencia celular de la epidermis, permitiendo su exfoliación.
* Retrasa la degradación de colágeno y promueve su síntesis.

Microvita está diseñado con el sistema MicroSkin, el primer sistema de liberación prolongada para uso cutáneo. El sistema MicroSkin se desarrolla a base de microesponjas, las cuales contienen el activo y se suspenden en crema como vehículo. Una vez aplicadas sobre la piel, las microesponjas liberan su contenido paulatinamente, con lo cual proporcionan concentraciones efectivas de mayor duración y sin excesos. El retinol liberado, por su carácter liposoluble, penetra ágilmente a la piel y, en parte, se transforma en ácido retinoico, lo que asegura menor biodegradación con concentraciones constantes, eficaces y de mayor duración, sin alcanzar los niveles que producen reacciones indeseables. Con Microvita se obtiene el efecto deseado con mucho menor riesgo de reacciones como prurito, eritema, ardor y descamación, las cuales frecuentemente son motivo de descontinuación y abandono del uso facial o cutáneo.
Adicionalmente, Microvita se formula con antioxidantes y, se presenta en cápsulas herméticas que aseguran su estabilidad durante más de 2 años.

== Efectos y usos recomendados: ==

La microvita se recomienda usarla especialmente para tratar afecciones como: el acné, fotodaño, hiperqueratosis y celulitis, por sus comprobados resultados satisfactorios.
* En el acné vulgar o juvenil, favorece la descamación y destaponamiento de los folículos pilosebáceos que generan los comedones propios del acné. Reduce la producción de sebo, o previene la formación de abscesos e interfiere con el desarrollo bacteriano (Propionibacterium acnes), promotor del trastorno.
* En piel fotodañada, favorece la exfoliación, restaura la arquitectura cutánea, disminuye las arrugas, incrementa la tensión cutánea y desvanece las manchas asociadas.
* En hiperqueratosis, por su efecto exfoliativo, adelgaza la piel engrosada. Por su fórmula humectante y lubricante, suaviza la piel. Elimina callosidades, cutículas y la aspereza de manos, codos, rodillas, talones y pies.
* En celulitis leve a moderada, detiene y revierte el espesor del panículo y disminuye la fijación y tracción del tejido superficial. Beneficio que en parte se debe a que previene la transformación de fibroblastos en adipocitos.

== Precauciones y limitaciones de uso: ==

Con Microvita, por su sistema MicroSkin, se reduce significativamente el riesgo de reacciones indeseables, permitiendo la continuidad de su aplicación por periodos prolongados. Al igual que cualquier retinoide, se recomienda evitar la exposición a rayos solares, la aplicación matutina de un filtro con factor de protección solar (SPF) 15 ó mayor.
Las primeras dos semanas, es recomendable no aplicarlo sobre párpados, para evitar algún grado de irritación en esta piel tan delgada, o bien, hágalo avanzando sobre la piel poco a poco o alternando los días de aplicación. Úselo únicamente por las noches. Evite combinar con otros productos, principalmente aquellos que contengan exfoliantes fuertes (ácido retinoico, glicólico y otros alfahidroxiácidos –AHA–).
Consérvelo en lugar fresco (entre 8 y 15ºC). No se deje al alcance de los niños.

== Presentaciones y modo de uso: ==

'''Microvita Crema''', se presenta en cápsulas de 0.3 mL, en sus tres diferentes concentraciones, fácilmente identificables por su color:
* MICROVITA 0.075%, cápsulas azul rey.
* MICROVITA 0.15%, cápsulas plata.
* MICROVITA 0.30%, cápsulas oro.

En sus tres concentraciones, se presenta en caja y tarro con 30 cápsulas.
Su exclusivo diseño en cápsulas monodosis, evita contaminaciones de la fórmula y proporciona la cantidad suficiente para cubrir cara y cuello, o áreas equivalentes, sin excesos ni desperdicios.
Para extraer el contenido de la cápsula, gire el cuello de la misma hasta que se rompa y desprenda. O si lo prefiere, corte con una tijera. Invierta la cápsula y presione para depositar su contenido en las yemas de los dedos o en la palma de la mano, y aplíquela suavemente sin frotar. Deje que se absorba y desaparezca. Debe aplicarse diario.

== Véase También ==
* [[Metoclopramida]]
* [[Diazepam]]
* [[Aciclovir]]

== Fuentes ==

* Diccionario de Especialidades Farmacéuticas. Edición 49. México, 2003
* http://www.libreriamedica8a.com

[[Category: Medicamentos_sintéticos]]

Microvita

2011-11-26T16:33:27Z

Manuel jc.manzanillo1:

{{Sistema:Moderación_Salud}}
{{Medicamento|nombre= Microvita |logo= Micro_Vita.jpg|descripcion=Se recomienda en el manejo del acné, fotodaño, hiperqueratosis y celulitis.|presentacion_farmaceutica=Crema |Via_de_administracion=Aplicación en la piel|Grupo_terapeutico=Dermatológicos}}
''' Microvita '''. Pertenece a la familia de [[medicamentos]] llamados dermatológicos. Se usa para el manejo del [[acné]], donde proporciona muy buenos resultados. Además es efectivo cuando se presenta fotodaño, hiperqueratosis y celulitis.

== Ingrediente activo y propiedades: ==

La Microvita contiene retinol, un retinoide precursor del ácido retinoico. El retinol aplicado en la piel, penetra y se transforma parcialmente en ácido retinoico. Ambos compuestos ejercen sus efectos mediante interacción con sus receptores dérmicos respectivos. Tal interacción modula muchas de las funciones del tejido cutáneo, como son:

* Favorecer el crecimiento y diferenciación de los queratinocitos y fibroblastos, células integrantes de la epidermis y dermis, respectivamente.

* Reducir la adherencia celular de la epidermis, permitiendo su exfoliación.
* Retrasa la degradación de colágeno y promueve su síntesis.

Microvita está diseñado con el sistema MicroSkin, el primer sistema de liberación prolongada para uso cutáneo. El sistema MicroSkin se desarrolla a base de microesponjas, las cuales contienen el activo y se suspenden en crema como vehículo. Una vez aplicadas sobre la piel, las microesponjas liberan su contenido paulatinamente, con lo cual proporcionan concentraciones efectivas de mayor duración y sin excesos. El retinol liberado, por su carácter liposoluble, penetra ágilmente a la piel y, en parte, se transforma en ácido retinoico, lo que asegura menor biodegradación con concentraciones constantes, eficaces y de mayor duración, sin alcanzar los niveles que producen reacciones indeseables. Con Microvita se obtiene el efecto deseado con mucho menor riesgo de reacciones como prurito, eritema, ardor y descamación, las cuales frecuentemente son motivo de descontinuación y abandono del uso facial o cutáneo.
Adicionalmente, Microvita se formula con antioxidantes y, se presenta en cápsulas herméticas que aseguran su estabilidad durante más de 2 años.

=== Efectos y usos recomendados:===

La microvita se recomienda usarla especialmente para tratar afecciones como: el acné, fotodaño, hiperqueratosis y celulitis, por sus comprobados resultados satisfactorios.
* En el acné vulgar o juvenil, favorece la descamación y destaponamiento de los folículos pilosebáceos que generan los comedones propios del acné. Reduce la producción de sebo, o previene la formación de abscesos e interfiere con el desarrollo bacteriano (Propionibacterium acnes), promotor del trastorno.
* En piel fotodañada, favorece la exfoliación, restaura la arquitectura cutánea, disminuye las arrugas, incrementa la tensión cutánea y desvanece las manchas asociadas.
* En hiperqueratosis, por su efecto exfoliativo, adelgaza la piel engrosada. Por su fórmula humectante y lubricante, suaviza la piel. Elimina callosidades, cutículas y la aspereza de manos, codos, rodillas, talones y pies.
* En celulitis leve a moderada, detiene y revierte el espesor del panículo y disminuye la fijación y tracción del tejido superficial. Beneficio que en parte se debe a que previene la transformación de fibroblastos en adipocitos.

=== Precauciones y limitaciones de uso:===

Con Microvita, por su sistema MicroSkin, se reduce significativamente el riesgo de reacciones indeseables, permitiendo la continuidad de su aplicación por periodos prolongados. Al igual que cualquier retinoide, se recomienda evitar la exposición a rayos solares, la aplicación matutina de un filtro con factor de protección solar (SPF) 15 ó mayor.
Las primeras dos semanas, es recomendable no aplicarlo sobre párpados, para evitar algún grado de irritación en esta piel tan delgada, o bien, hágalo avanzando sobre la piel poco a poco o alternando los días de aplicación. Úselo únicamente por las noches. Evite combinar con otros productos, principalmente aquellos que contengan exfoliantes fuertes (ácido retinoico, glicólico y otros alfahidroxiácidos –AHA–).
Consérvelo en lugar fresco (entre 8 y 15ºC). No se deje al alcance de los niños.

== Presentaciones y modo de uso: ==

'''Microvita Crema''', se presenta en cápsulas de 0.3 mL, en sus tres diferentes concentraciones, fácilmente identificables por su color:
* MICROVITA 0.075%, cápsulas azul rey.
* MICROVITA 0.15%, cápsulas plata.
* MICROVITA 0.30%, cápsulas oro.

En sus tres concentraciones, se presenta en caja y tarro con 30 cápsulas.
Su exclusivo diseño en cápsulas monodosis, evita contaminaciones de la fórmula y proporciona la cantidad suficiente para cubrir cara y cuello, o áreas equivalentes, sin excesos ni desperdicios.
Para extraer el contenido de la cápsula, gire el cuello de la misma hasta que se rompa y desprenda. O si lo prefiere, corte con una tijera. Invierta la cápsula y presione para depositar su contenido en las yemas de los dedos o en la palma de la mano, y aplíquela suavemente sin frotar. Deje que se absorba y desaparezca. Debe aplicarse diario.

=== Véase También ===
* [[Metoclopramida]]
* [[Diazepam]]
* [[Aciclovir]]

== Fuentes ==

* Diccionario de Especialidades Farmacéuticas. Edición 49. México, 2003
* http://www.libreriamedica8a.com

[[Category: Medicamentos_sintéticos]]

Microvita

2011-11-26T16:32:29Z

Manuel jc.manzanillo1: /* Efectos y usos recomendados: */

{{Sistema:Moderación_Salud}}
{{Medicamento|nombre= Microvita |logo= Micro_Vita.jpg|descripcion=Se recomienda en el manejo del acné, fotodaño, hiperqueratosis y celulitis.|presentacion_farmaceutica=Crema |Via_de_administracion=Aplicación en la piel|Grupo_terapeutico=Dermatológicos}}

''' Microvita '''. Pertenece a la familia de [[medicamentos]] llamados dermatológicos. Se usa para el manejo del [[acné]], donde proporciona muy buenos resultados. Además es efectivo cuando se presenta fotodaño, hiperqueratosis y celulitis.

== Ingrediente activo y propiedades: ==

La Microvita contiene retinol, un retinoide precursor del ácido retinoico. El retinol aplicado en la piel, penetra y se transforma parcialmente en ácido retinoico. Ambos compuestos ejercen sus efectos mediante interacción con sus receptores dérmicos respectivos. Tal interacción modula muchas de las funciones del tejido cutáneo, como son:

* Favorecer el crecimiento y diferenciación de los queratinocitos y fibroblastos, células integrantes de la epidermis y dermis, respectivamente.

* Reducir la adherencia celular de la epidermis, permitiendo su exfoliación.
* Retrasa la degradación de colágeno y promueve su síntesis.

Microvita está diseñado con el sistema MicroSkin, el primer sistema de liberación prolongada para uso cutáneo. El sistema MicroSkin se desarrolla a base de microesponjas, las cuales contienen el activo y se suspenden en crema como vehículo. Una vez aplicadas sobre la piel, las microesponjas liberan su contenido paulatinamente, con lo cual proporcionan concentraciones efectivas de mayor duración y sin excesos. El retinol liberado, por su carácter liposoluble, penetra ágilmente a la piel y, en parte, se transforma en ácido retinoico, lo que asegura menor biodegradación con concentraciones constantes, eficaces y de mayor duración, sin alcanzar los niveles que producen reacciones indeseables. Con Microvita se obtiene el efecto deseado con mucho menor riesgo de reacciones como prurito, eritema, ardor y descamación, las cuales frecuentemente son motivo de descontinuación y abandono del uso facial o cutáneo.
Adicionalmente, Microvita se formula con antioxidantes y, se presenta en cápsulas herméticas que aseguran su estabilidad durante más de 2 años.

=== Efectos y usos recomendados:===

La microvita se recomienda usarla especialmente para tratar afecciones como: el acné, fotodaño, hiperqueratosis y celulitis, por sus comprobados resultados satisfactorios.
* En el acné vulgar o juvenil, favorece la descamación y destaponamiento de los folículos pilosebáceos que generan los comedones propios del acné. Reduce la producción de sebo, o previene la formación de abscesos e interfiere con el desarrollo bacteriano (Propionibacterium acnes), promotor del trastorno.
* En piel fotodañada, favorece la exfoliación, restaura la arquitectura cutánea, disminuye las arrugas, incrementa la tensión cutánea y desvanece las manchas asociadas.
* En hiperqueratosis, por su efecto exfoliativo, adelgaza la piel engrosada. Por su fórmula humectante y lubricante, suaviza la piel. Elimina callosidades, cutículas y la aspereza de manos, codos, rodillas, talones y pies.
* En celulitis leve a moderada, detiene y revierte el espesor del panículo y disminuye la fijación y tracción del tejido superficial. Beneficio que en parte se debe a que previene la transformación de fibroblastos en adipocitos.

=== Precauciones y limitaciones de uso:===

Con Microvita, por su sistema MicroSkin, se reduce significativamente el riesgo de reacciones indeseables, permitiendo la continuidad de su aplicación por periodos prolongados. Al igual que cualquier retinoide, se recomienda evitar la exposición a rayos solares, la aplicación matutina de un filtro con factor de protección solar (SPF) 15 ó mayor.
Las primeras dos semanas, es recomendable no aplicarlo sobre párpados, para evitar algún grado de irritación en esta piel tan delgada, o bien, hágalo avanzando sobre la piel poco a poco o alternando los días de aplicación. Úselo únicamente por las noches. Evite combinar con otros productos, principalmente aquellos que contengan exfoliantes fuertes (ácido retinoico, glicólico y otros alfahidroxiácidos –AHA–).
Consérvelo en lugar fresco (entre 8 y 15ºC). No se deje al alcance de los niños.

== Presentaciones y modo de uso: ==

'''Microvita Crema''', se presenta en cápsulas de 0.3 mL, en sus tres diferentes concentraciones, fácilmente identificables por su color:
* MICROVITA 0.075%, cápsulas azul rey.
* MICROVITA 0.15%, cápsulas plata.
* MICROVITA 0.30%, cápsulas oro.

En sus tres concentraciones, se presenta en caja y tarro con 30 cápsulas.
Su exclusivo diseño en cápsulas monodosis, evita contaminaciones de la fórmula y proporciona la cantidad suficiente para cubrir cara y cuello, o áreas equivalentes, sin excesos ni desperdicios.
Para extraer el contenido de la cápsula, gire el cuello de la misma hasta que se rompa y desprenda. O si lo prefiere, corte con una tijera. Invierta la cápsula y presione para depositar su contenido en las yemas de los dedos o en la palma de la mano, y aplíquela suavemente sin frotar. Deje que se absorba y desaparezca. Debe aplicarse diario.

=== Véase También ===
* [[Metoclopramida]]
* [[Diazepam]]
* [[Aciclovir]]

== Fuentes ==

* Diccionario de Especialidades Farmacéuticas. Edición 49. México, 2003
* http://www.libreriamedica8a.com

[[Category: Medicamentos_sintéticos]]

Microvita

2011-11-26T16:31:33Z

Manuel jc.manzanillo1:

{{Sistema:Moderación_Salud}}
{{Medicamento|nombre= Microvita |logo= Micro_Vita.jpg|descripcion=Se recomienda en el manejo del acné, fotodaño, hiperqueratosis y celulitis.|presentacion_farmaceutica=Crema |Via_de_administracion=Aplicación en la piel|Grupo_terapeutico=Dermatológicos}}

''' Microvita '''. Pertenece a la familia de [[medicamentos]] llamados dermatológicos. Se usa para el manejo del [[acné]], donde proporciona muy buenos resultados. Además es efectivo cuando se presenta fotodaño, hiperqueratosis y celulitis.

== Ingrediente activo y propiedades: ==

La Microvita contiene retinol, un retinoide precursor del ácido retinoico. El retinol aplicado en la piel, penetra y se transforma parcialmente en ácido retinoico. Ambos compuestos ejercen sus efectos mediante interacción con sus receptores dérmicos respectivos. Tal interacción modula muchas de las funciones del tejido cutáneo, como son:

* Favorecer el crecimiento y diferenciación de los queratinocitos y fibroblastos, células integrantes de la epidermis y dermis, respectivamente.

* Reducir la adherencia celular de la epidermis, permitiendo su exfoliación.
* Retrasa la degradación de colágeno y promueve su síntesis.

Microvita está diseñado con el sistema MicroSkin, el primer sistema de liberación prolongada para uso cutáneo. El sistema MicroSkin se desarrolla a base de microesponjas, las cuales contienen el activo y se suspenden en crema como vehículo. Una vez aplicadas sobre la piel, las microesponjas liberan su contenido paulatinamente, con lo cual proporcionan concentraciones efectivas de mayor duración y sin excesos. El retinol liberado, por su carácter liposoluble, penetra ágilmente a la piel y, en parte, se transforma en ácido retinoico, lo que asegura menor biodegradación con concentraciones constantes, eficaces y de mayor duración, sin alcanzar los niveles que producen reacciones indeseables. Con Microvita se obtiene el efecto deseado con mucho menor riesgo de reacciones como prurito, eritema, ardor y descamación, las cuales frecuentemente son motivo de descontinuación y abandono del uso facial o cutáneo.
Adicionalmente, Microvita se formula con antioxidantes y, se presenta en cápsulas herméticas que aseguran su estabilidad durante más de 2 años.

=== Efectos y usos recomendados:===

La microvita se recomienda usarla especialmente para tratar afecciones como: el acné, fotodaño, hiperqueratosis y celulitis, por sus comprobados resultados satisfactorios.
* En el acné vulgar o juvenil, favorece la descamación y destaponamiento de los folículos pilosebáceos que generan los comedones propios del acné. Reduce la producción de sebo, o previene la formación de abscesos e interfiere con el desarrollo bacteriano (Propionibacterium acnes), promotor del trastorno.
* En piel fotodañada, favorece la exfoliación, restaura la arquitectura cutánea, disminuye las arrugas, incrementa la tensión cutánea y desvanece las manchas asociadas.
* En hiperqueratosis, por su efecto exfoliativo, adelgaza la piel engrosada. Por su fórmula humectante y lubricante, suaviza la piel. Elimina callosidades, cutículas y la aspereza de manos, codos, rodillas, talones y pies.
* En celulitis leve a moderada, detiene y revierte el espesor del panículo y disminuye la fijación y tracción del tejido superficial. Beneficio que en parte se debe a que previene la transformación de fibroblastos en adipocitos.

=== Precauciones y limitaciones de uso:===

Con Microvita, por su sistema MicroSkin, se reduce significativamente el riesgo de reacciones indeseables, permitiendo la continuidad de su aplicación por periodos prolongados. Al igual que cualquier retinoide, se recomienda evitar la exposición a rayos solares, la aplicación matutina de un filtro con factor de protección solar (SPF) 15 ó mayor.
Las primeras dos semanas, es recomendable no aplicarlo sobre párpados, para evitar algún grado de irritación en esta piel tan delgada, o bien, hágalo avanzando sobre la piel poco a poco o alternando los días de aplicación. Úselo únicamente por las noches. Evite combinar con otros productos, principalmente aquellos que contengan exfoliantes fuertes (ácido retinoico, glicólico y otros alfahidroxiácidos –AHA–).
Consérvelo en lugar fresco (entre 8 y 15ºC). No se deje al alcance de los niños.

== Presentaciones y modo de uso: ==

'''Microvita Crema''', se presenta en cápsulas de 0.3 mL, en sus tres diferentes concentraciones, fácilmente identificables por su color:
* MICROVITA 0.075%, cápsulas azul rey.
* MICROVITA 0.15%, cápsulas plata.
* MICROVITA 0.30%, cápsulas oro.

En sus tres concentraciones, se presenta en caja y tarro con 30 cápsulas.
Su exclusivo diseño en cápsulas monodosis, evita contaminaciones de la fórmula y proporciona la cantidad suficiente para cubrir cara y cuello, o áreas equivalentes, sin excesos ni desperdicios.
Para extraer el contenido de la cápsula, gire el cuello de la misma hasta que se rompa y desprenda. O si lo prefiere, corte con una tijera. Invierta la cápsula y presione para depositar su contenido en las yemas de los dedos o en la palma de la mano, y aplíquela suavemente sin frotar. Deje que se absorba y desaparezca. Debe aplicarse diario.

=== Véase También ===
* [[Metoclopramida]]
* [[Diazepam]]
* [[Aciclovir]]

== Fuentes ==

* Diccionario de Especialidades Farmacéuticas. Edición 49. México, 2003
* http://www.libreriamedica8a.com

[[Category: Medicamentos_sintéticos]]

Microvita

2011-11-26T16:30:47Z

Manuel jc.manzanillo1: /* Fuentes */

{{Sistema:Moderación_Salud}}
{{Medicamento|nombre= Microvita |logo= Micro_Vita.jpeg|descripcion=Se recomienda en el manejo del acné, fotodaño, hiperqueratosis y celulitis.|presentacion_farmaceutica=Crema |Via_de_administracion=Aplicación en la piel|Grupo_terapeutico=Dermatológicos}}

''' Microvita '''. Pertenece a la familia de [[medicamentos]] llamados dermatológicos. Se usa para el manejo del [[acné]], donde proporciona muy buenos resultados. Además es efectivo cuando se presenta fotodaño, hiperqueratosis y celulitis.

== Ingrediente activo y propiedades: ==

La Microvita contiene retinol, un retinoide precursor del ácido retinoico. El retinol aplicado en la piel, penetra y se transforma parcialmente en ácido retinoico. Ambos compuestos ejercen sus efectos mediante interacción con sus receptores dérmicos respectivos. Tal interacción modula muchas de las funciones del tejido cutáneo, como son:

* Favorecer el crecimiento y diferenciación de los queratinocitos y fibroblastos, células integrantes de la epidermis y dermis, respectivamente.

* Reducir la adherencia celular de la epidermis, permitiendo su exfoliación.
* Retrasa la degradación de colágeno y promueve su síntesis.

Microvita está diseñado con el sistema MicroSkin, el primer sistema de liberación prolongada para uso cutáneo. El sistema MicroSkin se desarrolla a base de microesponjas, las cuales contienen el activo y se suspenden en crema como vehículo. Una vez aplicadas sobre la piel, las microesponjas liberan su contenido paulatinamente, con lo cual proporcionan concentraciones efectivas de mayor duración y sin excesos. El retinol liberado, por su carácter liposoluble, penetra ágilmente a la piel y, en parte, se transforma en ácido retinoico, lo que asegura menor biodegradación con concentraciones constantes, eficaces y de mayor duración, sin alcanzar los niveles que producen reacciones indeseables. Con Microvita se obtiene el efecto deseado con mucho menor riesgo de reacciones como prurito, eritema, ardor y descamación, las cuales frecuentemente son motivo de descontinuación y abandono del uso facial o cutáneo.
Adicionalmente, Microvita se formula con antioxidantes y, se presenta en cápsulas herméticas que aseguran su estabilidad durante más de 2 años.

=== Efectos y usos recomendados:===

La microvita se recomienda usarla especialmente para tratar afecciones como: el acné, fotodaño, hiperqueratosis y celulitis, por sus comprobados resultados satisfactorios.
* En el acné vulgar o juvenil, favorece la descamación y destaponamiento de los folículos pilosebáceos que generan los comedones propios del acné. Reduce la producción de sebo, o previene la formación de abscesos e interfiere con el desarrollo bacteriano (Propionibacterium acnes), promotor del trastorno.
* En piel fotodañada, favorece la exfoliación, restaura la arquitectura cutánea, disminuye las arrugas, incrementa la tensión cutánea y desvanece las manchas asociadas.
* En hiperqueratosis, por su efecto exfoliativo, adelgaza la piel engrosada. Por su fórmula humectante y lubricante, suaviza la piel. Elimina callosidades, cutículas y la aspereza de manos, codos, rodillas, talones y pies.
* En celulitis leve a moderada, detiene y revierte el espesor del panículo y disminuye la fijación y tracción del tejido superficial. Beneficio que en parte se debe a que previene la transformación de fibroblastos en adipocitos.

=== Precauciones y limitaciones de uso:===

Con Microvita, por su sistema MicroSkin, se reduce significativamente el riesgo de reacciones indeseables, permitiendo la continuidad de su aplicación por periodos prolongados. Al igual que cualquier retinoide, se recomienda evitar la exposición a rayos solares, la aplicación matutina de un filtro con factor de protección solar (SPF) 15 ó mayor.
Las primeras dos semanas, es recomendable no aplicarlo sobre párpados, para evitar algún grado de irritación en esta piel tan delgada, o bien, hágalo avanzando sobre la piel poco a poco o alternando los días de aplicación. Úselo únicamente por las noches. Evite combinar con otros productos, principalmente aquellos que contengan exfoliantes fuertes (ácido retinoico, glicólico y otros alfahidroxiácidos –AHA–).
Consérvelo en lugar fresco (entre 8 y 15ºC). No se deje al alcance de los niños.

== Presentaciones y modo de uso: ==

'''Microvita Crema''', se presenta en cápsulas de 0.3 mL, en sus tres diferentes concentraciones, fácilmente identificables por su color:
* MICROVITA 0.075%, cápsulas azul rey.
* MICROVITA 0.15%, cápsulas plata.
* MICROVITA 0.30%, cápsulas oro.

En sus tres concentraciones, se presenta en caja y tarro con 30 cápsulas.
Su exclusivo diseño en cápsulas monodosis, evita contaminaciones de la fórmula y proporciona la cantidad suficiente para cubrir cara y cuello, o áreas equivalentes, sin excesos ni desperdicios.
Para extraer el contenido de la cápsula, gire el cuello de la misma hasta que se rompa y desprenda. O si lo prefiere, corte con una tijera. Invierta la cápsula y presione para depositar su contenido en las yemas de los dedos o en la palma de la mano, y aplíquela suavemente sin frotar. Deje que se absorba y desaparezca. Debe aplicarse diario.

=== Véase También ===
* [[Metoclopramida]]
* [[Diazepam]]
* [[Aciclovir]]

== Fuentes ==

* Diccionario de Especialidades Farmacéuticas. Edición 49. México, 2003
* http://www.libreriamedica8a.com

[[Category: Medicamentos_sintéticos]]

Microvita

2011-11-26T16:29:28Z

Manuel jc.manzanillo1: Página creada con '{{Sistema:Moderación_Salud}} {{Medicamento|nombre= Microvita |logo= Micro_Vita.jpeg|descripcion=Se recomienda en el manejo del acné, fotodaño, hiperqueratosis y celulitis.|pr...'

{{Sistema:Moderación_Salud}}
{{Medicamento|nombre= Microvita |logo= Micro_Vita.jpeg|descripcion=Se recomienda en el manejo del acné, fotodaño, hiperqueratosis y celulitis.|presentacion_farmaceutica=Crema |Via_de_administracion=Aplicación en la piel|Grupo_terapeutico=Dermatológicos}}

''' Microvita '''. Pertenece a la familia de [[medicamentos]] llamados dermatológicos. Se usa para el manejo del [[acné]], donde proporciona muy buenos resultados. Además es efectivo cuando se presenta fotodaño, hiperqueratosis y celulitis.

== Ingrediente activo y propiedades: ==

La Microvita contiene retinol, un retinoide precursor del ácido retinoico. El retinol aplicado en la piel, penetra y se transforma parcialmente en ácido retinoico. Ambos compuestos ejercen sus efectos mediante interacción con sus receptores dérmicos respectivos. Tal interacción modula muchas de las funciones del tejido cutáneo, como son:

* Favorecer el crecimiento y diferenciación de los queratinocitos y fibroblastos, células integrantes de la epidermis y dermis, respectivamente.

* Reducir la adherencia celular de la epidermis, permitiendo su exfoliación.
* Retrasa la degradación de colágeno y promueve su síntesis.

Microvita está diseñado con el sistema MicroSkin, el primer sistema de liberación prolongada para uso cutáneo. El sistema MicroSkin se desarrolla a base de microesponjas, las cuales contienen el activo y se suspenden en crema como vehículo. Una vez aplicadas sobre la piel, las microesponjas liberan su contenido paulatinamente, con lo cual proporcionan concentraciones efectivas de mayor duración y sin excesos. El retinol liberado, por su carácter liposoluble, penetra ágilmente a la piel y, en parte, se transforma en ácido retinoico, lo que asegura menor biodegradación con concentraciones constantes, eficaces y de mayor duración, sin alcanzar los niveles que producen reacciones indeseables. Con Microvita se obtiene el efecto deseado con mucho menor riesgo de reacciones como prurito, eritema, ardor y descamación, las cuales frecuentemente son motivo de descontinuación y abandono del uso facial o cutáneo.
Adicionalmente, Microvita se formula con antioxidantes y, se presenta en cápsulas herméticas que aseguran su estabilidad durante más de 2 años.

=== Efectos y usos recomendados:===

La microvita se recomienda usarla especialmente para tratar afecciones como: el acné, fotodaño, hiperqueratosis y celulitis, por sus comprobados resultados satisfactorios.
* En el acné vulgar o juvenil, favorece la descamación y destaponamiento de los folículos pilosebáceos que generan los comedones propios del acné. Reduce la producción de sebo, o previene la formación de abscesos e interfiere con el desarrollo bacteriano (Propionibacterium acnes), promotor del trastorno.
* En piel fotodañada, favorece la exfoliación, restaura la arquitectura cutánea, disminuye las arrugas, incrementa la tensión cutánea y desvanece las manchas asociadas.
* En hiperqueratosis, por su efecto exfoliativo, adelgaza la piel engrosada. Por su fórmula humectante y lubricante, suaviza la piel. Elimina callosidades, cutículas y la aspereza de manos, codos, rodillas, talones y pies.
* En celulitis leve a moderada, detiene y revierte el espesor del panículo y disminuye la fijación y tracción del tejido superficial. Beneficio que en parte se debe a que previene la transformación de fibroblastos en adipocitos.

=== Precauciones y limitaciones de uso:===

Con Microvita, por su sistema MicroSkin, se reduce significativamente el riesgo de reacciones indeseables, permitiendo la continuidad de su aplicación por periodos prolongados. Al igual que cualquier retinoide, se recomienda evitar la exposición a rayos solares, la aplicación matutina de un filtro con factor de protección solar (SPF) 15 ó mayor.
Las primeras dos semanas, es recomendable no aplicarlo sobre párpados, para evitar algún grado de irritación en esta piel tan delgada, o bien, hágalo avanzando sobre la piel poco a poco o alternando los días de aplicación. Úselo únicamente por las noches. Evite combinar con otros productos, principalmente aquellos que contengan exfoliantes fuertes (ácido retinoico, glicólico y otros alfahidroxiácidos –AHA–).
Consérvelo en lugar fresco (entre 8 y 15ºC). No se deje al alcance de los niños.

== Presentaciones y modo de uso: ==

'''Microvita Crema''', se presenta en cápsulas de 0.3 mL, en sus tres diferentes concentraciones, fácilmente identificables por su color:
* MICROVITA 0.075%, cápsulas azul rey.
* MICROVITA 0.15%, cápsulas plata.
* MICROVITA 0.30%, cápsulas oro.

En sus tres concentraciones, se presenta en caja y tarro con 30 cápsulas.
Su exclusivo diseño en cápsulas monodosis, evita contaminaciones de la fórmula y proporciona la cantidad suficiente para cubrir cara y cuello, o áreas equivalentes, sin excesos ni desperdicios.
Para extraer el contenido de la cápsula, gire el cuello de la misma hasta que se rompa y desprenda. O si lo prefiere, corte con una tijera. Invierta la cápsula y presione para depositar su contenido en las yemas de los dedos o en la palma de la mano, y aplíquela suavemente sin frotar. Deje que se absorba y desaparezca. Debe aplicarse diario.

=== Véase También ===
* [[Metoclopramida]]
* [[Diazepam]]
* [[Aciclovir]]

== Fuentes ==

* Diccionario de Especialidades Farmacéuticas. Edición 49. México 2003
* http://www.libreriamedica8a.com/productos/2141.htm

[[Category: Medicamentos_sintéticos]]

Archivo:Micro Vita.jpg

2011-11-26T16:26:00Z

Manuel jc.manzanillo1:

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Algoritmo de ordenamiento por selección

2011-09-30T17:49:42Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif
|tamaño height 200
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.

== Descripción ==

Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1;
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==

El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==

El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
'''c(n)= (n2-n)/2'''
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.

== Estabilidad, Ventajas y Desventajas==

Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus '''ventajas:'''
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas '''desventajas:'''
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.

== Implementación==

A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

'''Java'''
void selecccion(int[] a) {
for (int i = 0; i < a.length - 1; i++)
{
int min = i;
for (int j = i + 1; j < a.length; j++)
{
if (a[j] < a[min])
{
min = j;
}
}
if (i != min)
{
int aux= a[i];
a[i] = a[min];
a[min] = aux;
}
}}

C

void ordsel(int * x, int n){
int minimo=0,i,j;
int swap;
for(i=0 ; i<n-1 ; i++)
{
minimo=i;
for(j=i+1 ; j<n ; j++)
if (x[minimo] > x[j])
minimo=j;
swap=x[minimo];
x[minimo]=x[i];
x[i]=swap;
}}
Basic
For i = 1 To n - 1
minimo = i
For j = i + 1 To n
If x(minimo) > x(j) Then
minimo = j
End If
Next j
temp = x(i)
x(i) = x(minimo)
x(minimo) = tempNext i
C++
#include <iostream>#include <vector>using namespace std;

template <class T>void ordena_seleccion(vector<T>& v) {
for (int i = 0; i < v.size() - 1; ++i) {
int min = i;
for (int c = i + 1; c < v.size(); ++c) {
if (v[min] > v[c]) min = c;
}
T aux = v[i];
v[i] = v[min];
v[min] = aux;
}}
Perl
sub seleccion {
my $array = shift; # Recibimos una referencia a un array

my $i; # Índice del elemento a comparar
my $j; # Índice del valor mínimo a encontrar

# Para todos los elementos menos el último
for ( $i = 0; $i < $#$array; $i++ ) {

# Índice y valor del elemento a comparar
my ( $m, $x ) = ( $i, $array->[ $m ] );

# Buscamos el valor más pequeño de todos los demás
for ( $j = $i + 1; $j < @$array; $j++ ) {

( $m, $x ) = ( $j, $array->[ $j ] ) # Nuevo mínimo encontrado
if $array->[ $j ] < $x;
}

# Hacemos el intercambio de elementos, si es necesario
@$array[ $m, $i ] = @$array[ $i, $m ] if $m != $i;
}}
JavaScript
for(var i=0 ; i<vector.length-1 ; i++){
var menor = i;
for(var j=i+1 ; j<vector.length ; j++)
{
if (vector[menor] > vector[j]) menor = j;
}
var temp = vector[menor];
vector[menor] = vector[i];
vector[i] = temp;}

PHP
function IntercambiarElementos(&$arreglo,$pos1,$pos2){
$aux=$arreglo[$pos1];
$arreglo[$pos1]=$arreglo[$pos2];
$arreglo[$pos2]=$aux;}function PosicionMenorElemento($arreglo,$posinicial){
$posmenor=$posinicial;
for($i=$posinicial+1;$i<count($arreglo);$i++){
if($arreglo[$i]<$arreglo[$posmenor]){
$posmenor=$i;
}
}
return $posmenor;}function OrdenamientoPorSeleccion(&$arreglo){
for($i=0;$i<count($arreglo);$i++){
$posmenor=PosicionMenorElemento($arreglo,$i);
if($posmenor>$i){
IntercambiarElementos($arreglo,$i,$posmenor);
}
}}
Python
def seleccion(lista)
n = len(lista)

for i in range(0,n-1):
k = i
t = lista[i]
for j in range(i,n):
if lista[j] < t:
k = j
t = lista[j]
lista[k] = lista[i]
lista[i] = t

return lista
Pascal
Procedure OrdSel (var Sec : TipSec; TamSec : Integer);var
i, j, min, num : Integer;begin
for i := 1 to TamSec-1 do
begin
min := i;
for j := i+1 to TamSec do
begin
NumOpr := NumOpr + 1;
if Sec[j] < Sec[min] then
min := j;
end;
num := Sec[min];
Sec[min] := Sec[i];
Sec[i] := num;
end;end;
Game Maker Language
// array de extensión nfor(i=0 ; i<n-1 ; i+=1){
menor = i;
for(j=i+1 ; j<n; j+=1)
{
if (vector[menor] > vector[j]) {menor = j;}
}
temp = vector[menor];
vector[menor] = vector[i];
vector[i] = temp;}

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_por_selecci%C3%B3n].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:46:48Z

Manuel jc.manzanillo1:

Algoritmo de ordenamiento por selección

2011-09-30T17:42:44Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif
|tamaño height 200
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.

== Descripción ==

Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==

El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==

El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.

== Estabilidad, Ventajas y Desventajas==

Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.

== Implementación==

A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

Java
void selecccion(int[] a) {
for (int i = 0; i < a.length - 1; i++)
{
int min = i;
for (int j = i + 1; j < a.length; j++)
{
if (a[j] < a[min])
{
min = j;
}
}
if (i != min)
{
int aux= a[i];
a[i] = a[min];
a[min] = aux;
}
}}

C

void ordsel(int * x, int n){
int minimo=0,i,j;
int swap;
for(i=0 ; i<n-1 ; i++)
{
minimo=i;
for(j=i+1 ; j<n ; j++)
if (x[minimo] > x[j])
minimo=j;
swap=x[minimo];
x[minimo]=x[i];
x[i]=swap;
}}
Basic
For i = 1 To n - 1
minimo = i
For j = i + 1 To n
If x(minimo) > x(j) Then
minimo = j
End If
Next j
temp = x(i)
x(i) = x(minimo)
x(minimo) = tempNext i
C++
#include <iostream>#include <vector>using namespace std;

template <class T>void ordena_seleccion(vector<T>& v) {
for (int i = 0; i < v.size() - 1; ++i) {
int min = i;
for (int c = i + 1; c < v.size(); ++c) {
if (v[min] > v[c]) min = c;
}
T aux = v[i];
v[i] = v[min];
v[min] = aux;
}}
Perl
sub seleccion {
my $array = shift; # Recibimos una referencia a un array

my $i; # Índice del elemento a comparar
my $j; # Índice del valor mínimo a encontrar

# Para todos los elementos menos el último
for ( $i = 0; $i < $#$array; $i++ ) {

# Índice y valor del elemento a comparar
my ( $m, $x ) = ( $i, $array->[ $m ] );

# Buscamos el valor más pequeño de todos los demás
for ( $j = $i + 1; $j < @$array; $j++ ) {

( $m, $x ) = ( $j, $array->[ $j ] ) # Nuevo mínimo encontrado
if $array->[ $j ] < $x;
}

# Hacemos el intercambio de elementos, si es necesario
@$array[ $m, $i ] = @$array[ $i, $m ] if $m != $i;
}}
JavaScript
for(var i=0 ; i<vector.length-1 ; i++){
var menor = i;
for(var j=i+1 ; j<vector.length ; j++)
{
if (vector[menor] > vector[j]) menor = j;
}
var temp = vector[menor];
vector[menor] = vector[i];
vector[i] = temp;}

PHP
function IntercambiarElementos(&$arreglo,$pos1,$pos2){
$aux=$arreglo[$pos1];
$arreglo[$pos1]=$arreglo[$pos2];
$arreglo[$pos2]=$aux;}function PosicionMenorElemento($arreglo,$posinicial){
$posmenor=$posinicial;
for($i=$posinicial+1;$i<count($arreglo);$i++){
if($arreglo[$i]<$arreglo[$posmenor]){
$posmenor=$i;
}
}
return $posmenor;}function OrdenamientoPorSeleccion(&$arreglo){
for($i=0;$i<count($arreglo);$i++){
$posmenor=PosicionMenorElemento($arreglo,$i);
if($posmenor>$i){
IntercambiarElementos($arreglo,$i,$posmenor);
}
}}
Python
def seleccion(lista)
n = len(lista)

for i in range(0,n-1):
k = i
t = lista[i]
for j in range(i,n):
if lista[j] < t:
k = j
t = lista[j]
lista[k] = lista[i]
lista[i] = t

return lista
Pascal
Procedure OrdSel (var Sec : TipSec; TamSec : Integer);var
i, j, min, num : Integer;begin
for i := 1 to TamSec-1 do
begin
min := i;
for j := i+1 to TamSec do
begin
NumOpr := NumOpr + 1;
if Sec[j] < Sec[min] then
min := j;
end;
num := Sec[min];
Sec[min] := Sec[i];
Sec[i] := num;
end;end;
Game Maker Language
// array de extensión nfor(i=0 ; i<n-1 ; i+=1){
menor = i;
for(j=i+1 ; j<n; j+=1)
{
if (vector[menor] > vector[j]) {menor = j;}
}
temp = vector[menor];
vector[menor] = vector[i];
vector[i] = temp;}

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:39:39Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation1.gif
|tamaño height 200
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

Java
void selecccion(int[] a) {
for (int i = 0; i < a.length - 1; i++)
{
int min = i;
for (int j = i + 1; j < a.length; j++)
{
if (a[j] < a[min])
{
min = j;
}
}
if (i != min)
{
int aux= a[i];
a[i] = a[min];
a[min] = aux;
}
}}

C

void ordsel(int * x, int n){
int minimo=0,i,j;
int swap;
for(i=0 ; i<n-1 ; i++)
{
minimo=i;
for(j=i+1 ; j<n ; j++)
if (x[minimo] > x[j])
minimo=j;
swap=x[minimo];
x[minimo]=x[i];
x[i]=swap;
}}
Basic
For i = 1 To n - 1
minimo = i
For j = i + 1 To n
If x(minimo) > x(j) Then
minimo = j
End If
Next j
temp = x(i)
x(i) = x(minimo)
x(minimo) = tempNext i
C++
#include <iostream>#include <vector>using namespace std;

template <class T>void ordena_seleccion(vector<T>& v) {
for (int i = 0; i < v.size() - 1; ++i) {
int min = i;
for (int c = i + 1; c < v.size(); ++c) {
if (v[min] > v[c]) min = c;
}
T aux = v[i];
v[i] = v[min];
v[min] = aux;
}}
Perl
sub seleccion {
my $array = shift; # Recibimos una referencia a un array

my $i; # Índice del elemento a comparar
my $j; # Índice del valor mínimo a encontrar

# Para todos los elementos menos el último
for ( $i = 0; $i < $#$array; $i++ ) {

# Índice y valor del elemento a comparar
my ( $m, $x ) = ( $i, $array->[ $m ] );

# Buscamos el valor más pequeño de todos los demás
for ( $j = $i + 1; $j < @$array; $j++ ) {

( $m, $x ) = ( $j, $array->[ $j ] ) # Nuevo mínimo encontrado
if $array->[ $j ] < $x;
}

# Hacemos el intercambio de elementos, si es necesario
@$array[ $m, $i ] = @$array[ $i, $m ] if $m != $i;
}}
JavaScript
for(var i=0 ; i<vector.length-1 ; i++){
var menor = i;
for(var j=i+1 ; j<vector.length ; j++)
{
if (vector[menor] > vector[j]) menor = j;
}
var temp = vector[menor];
vector[menor] = vector[i];
vector[i] = temp;}

PHP
function IntercambiarElementos(&$arreglo,$pos1,$pos2){
$aux=$arreglo[$pos1];
$arreglo[$pos1]=$arreglo[$pos2];
$arreglo[$pos2]=$aux;}function PosicionMenorElemento($arreglo,$posinicial){
$posmenor=$posinicial;
for($i=$posinicial+1;$i<count($arreglo);$i++){
if($arreglo[$i]<$arreglo[$posmenor]){
$posmenor=$i;
}
}
return $posmenor;}function OrdenamientoPorSeleccion(&$arreglo){
for($i=0;$i<count($arreglo);$i++){
$posmenor=PosicionMenorElemento($arreglo,$i);
if($posmenor>$i){
IntercambiarElementos($arreglo,$i,$posmenor);
}
}}
Python
def seleccion(lista)
n = len(lista)

for i in range(0,n-1):
k = i
t = lista[i]
for j in range(i,n):
if lista[j] < t:
k = j
t = lista[j]
lista[k] = lista[i]
lista[i] = t

return lista
Pascal
Procedure OrdSel (var Sec : TipSec; TamSec : Integer);var
i, j, min, num : Integer;begin
for i := 1 to TamSec-1 do
begin
min := i;
for j := i+1 to TamSec do
begin
NumOpr := NumOpr + 1;
if Sec[j] < Sec[min] then
min := j;
end;
num := Sec[min];
Sec[min] := Sec[i];
Sec[i] := num;
end;end;
Game Maker Language
// array de extensión nfor(i=0 ; i<n-1 ; i+=1){
menor = i;
for(j=i+1 ; j<n; j+=1)
{
if (vector[menor] > vector[j]) {menor = j;}
}
temp = vector[menor];
vector[menor] = vector[i];
vector[i] = temp;}

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:31:38Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:30:43Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif
|tamaño=height 150
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:28:57Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif
|tamaño=height 400
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:26:58Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif
|tamaño height 100
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:
Java
void selecccion(int[] a) {
for (int i = 0; i < a.length - 1; i++)
{
int min = i;
for (int j = i + 1; j < a.length; j++)
{
if (a[j] < a[min])
{
min = j;
}
}
if (i != min)
{
int aux= a[i];
a[i] = a[min];
a[min] = aux;
}
}}
C
void ordsel(int * x, int n){
int minimo=0,i,j;
int swap;
for(i=0 ; i<n-1 ; i++)
{
minimo=i;
for(j=i+1 ; j<n ; j++)
if (x[minimo] > x[j])
minimo=j;
swap=x[minimo];
x[minimo]=x[i];
x[i]=swap;
}}
Basic
For i = 1 To n - 1
minimo = i
For j = i + 1 To n
If x(minimo) > x(j) Then
minimo = j
End If
Next j
temp = x(i)
x(i) = x(minimo)
x(minimo) = tempNext i
C++
#include <iostream>#include <vector>using namespace std;

template <class T>void ordena_seleccion(vector<T>& v) {
for (int i = 0; i < v.size() - 1; ++i) {
int min = i;
for (int c = i + 1; c < v.size(); ++c) {
if (v[min] > v[c]) min = c;
}
T aux = v[i];
v[i] = v[min];
v[min] = aux;
}}
Perl
sub seleccion {
my $array = shift; # Recibimos una referencia a un array

my $i; # Índice del elemento a comparar
my $j; # Índice del valor mínimo a encontrar

# Para todos los elementos menos el último
for ( $i = 0; $i < $#$array; $i++ ) {

# Índice y valor del elemento a comparar
my ( $m, $x ) = ( $i, $array->[ $m ] );

# Buscamos el valor más pequeño de todos los demás
for ( $j = $i + 1; $j < @$array; $j++ ) {

( $m, $x ) = ( $j, $array->[ $j ] ) # Nuevo mínimo encontrado
if $array->[ $j ] < $x;
}

# Hacemos el intercambio de elementos, si es necesario
@$array[ $m, $i ] = @$array[ $i, $m ] if $m != $i;
}}
JavaScript
for(var i=0 ; i<vector.length-1 ; i++){
var menor = i;
for(var j=i+1 ; j<vector.length ; j++)
{
if (vector[menor] > vector[j]) menor = j;
}
var temp = vector[menor];
vector[menor] = vector[i];
vector[i] = temp;}

PHP
function IntercambiarElementos(&$arreglo,$pos1,$pos2){
$aux=$arreglo[$pos1];
$arreglo[$pos1]=$arreglo[$pos2];
$arreglo[$pos2]=$aux;}function PosicionMenorElemento($arreglo,$posinicial){
$posmenor=$posinicial;
for($i=$posinicial+1;$i<count($arreglo);$i++){
if($arreglo[$i]<$arreglo[$posmenor]){
$posmenor=$i;
}
}
return $posmenor;}function OrdenamientoPorSeleccion(&$arreglo){
for($i=0;$i<count($arreglo);$i++){
$posmenor=PosicionMenorElemento($arreglo,$i);
if($posmenor>$i){
IntercambiarElementos($arreglo,$i,$posmenor);
}
}}
Python
def seleccion(lista)
n = len(lista)

for i in range(0,n-1):
k = i
t = lista[i]
for j in range(i,n):
if lista[j] < t:
k = j
t = lista[j]
lista[k] = lista[i]
lista[i] = t

return lista
Pascal
Procedure OrdSel (var Sec : TipSec; TamSec : Integer);var
i, j, min, num : Integer;begin
for i := 1 to TamSec-1 do
begin
min := i;
for j := i+1 to TamSec do
begin
NumOpr := NumOpr + 1;
if Sec[j] < Sec[min] then
min := j;
end;
num := Sec[min];
Sec[min] := Sec[i];
Sec[i] := num;
end;end;
Game Maker Language
// array de extensión nfor(i=0 ; i<n-1 ; i+=1){
menor = i;
for(j=i+1 ; j<n; j+=1)
{
if (vector[menor] > vector[j]) {menor = j;}
}
temp = vector[menor];
vector[menor] = vector[i];
vector[i] = temp;}

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:26:37Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation1.gif
|tamaño=height 400
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:24:39Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif
|tamaño=height 20
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:23:32Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif
|tamaño=height 250
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:21:48Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif
|tamaño=height 200
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:19:05Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation1.gif
|tamaño=height 200
|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:07:39Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation1.gif|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T17:04:53Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif| 200|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Archivo:Selection-Sort-Animation.gif

2011-09-30T17:03:24Z

Manuel jc.manzanillo1: subió una nueva versión de «Archivo:Selection-Sort-Animation.gif»: Revertido a la versión subida el 30 sep 2011 a las 16:41

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Archivo:Selection-Sort-Animation.gif

2011-09-30T17:00:34Z

Manuel jc.manzanillo1: subió una nueva versión de «Archivo:Selection-Sort-Animation.gif»

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Algoritmo de ordenamiento por selección

2011-09-30T16:47:53Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif|heigth 200|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de ordenamiento por selección

2011-09-30T16:41:32Z

Manuel jc.manzanillo1: Página creada con ' {{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, d...'

{{Definición|Nombre=Algoritmo de ordenamiento. Selección|imagen=Selection-Sort-Animation.gif|concepto=Algoritmo que ubica elementos de una lista o vector, en una secuencia, dada por una relación de orden, tomando como punto de partida el menor elemento.}}

'''Algoritmo de ordenamiento por Selección (Selection Sort en [[inglés]]):''' Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
== Descripción ==
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
Su funcionamiento se puede definir de forma general como:

* Buscar el mínimo elemento entre una posición i y el final de la lista
* Intercambiar el mínimo con el elemento de la posición i

Así, se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

'''para''' i=1 '''hasta''' n-1
minimo = i;
'''para''' j=i+1 '''hasta''' n
'''si''' lista[j] < lista[minimo] '''entonces'''
minimo = j
'''fin si'''
'''fin para'''
intercambiar(lista[i], lista[minimo])
'''fin para'''

== Ejemplo ==
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'].
Se empieza por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor elemento es la primera 'a'. De manera que no ocurre ningún cambio. Luego se procede a buscar el siguiente elemento y se encuentra la segunda 'a'.
Esta se intercambia con el dato que está en la segunda posición, la 's', quedando el arreglo así después de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual se intercambia con lo que está en la tercera posición, o sea, la 'o'. Le sigue la segunda 's', la cual es intercambiada con la 'r'.
El arreglo ahora se ve de la siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r'].
De esta manera se va buscando el elemento que debe ir en la siguiente posición hasta ordenar todo el arreglo.

== Análisis del Costo Computacional ==
El ciclo externo se ejecuta n veces para una lista de n elementos, o sea que para ordenar un vector de n términos, tiene que realizar siempre el mismo número de comparaciones.
c(n)= (n2-n)/2
Cada búsqueda requiere comparar todos los elementos no clasificados, de manera que el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos; por lo que este algoritmo presenta un comportamiento constante independiente del orden de los datos. Luego la complejidad es del orden n2.
== Estabilidad, Ventajas y Desventajas==
Puede que exista algo de discrepancia en cuanto a si es o no estable este algoritmo, pero en realidad esta implementación parece ser bastante estable. Se puede verificar esto ordenando un conjunto de datos que tenga un par de ellos con la misma clave. Se vera claramente que el orden relativo entre ellos es conservado. Algunos autores no lo consideran asi, pero independientemente de esto, este algoritmo tienes entre sus ventajas:
Es fácil su implementación.
No requiere memoria adicional.
Realiza pocos intercambios.
Tiene un rendimiento constante, pues existe poca diferencia entre el peor y el mejor caso.
Como todos también tiene algunas desventajas:
Es lento y poco eficiente cuando se usa en listas grandes o medianas.
Realiza numerosas comparaciones.
== Implementación==
A continuación se muestra el Ordenamiento por Selección en algunos de los lenguajes de programación de alto nivel más usados:

== Vease también ==

*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]
*[[Algoritmos de clasificación no supervisada]]
*[[Algoritmos jerárquicos]]
*[[Algoritmos matemáticos]]

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Archivo:Selection-Sort-Animation.gif

2011-09-30T16:41:20Z

Manuel jc.manzanillo1:

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Algoritmo de Ordenamiento Shell

2011-08-16T19:09:23Z

Manuel jc.manzanillo1: /* Secuencia de espacios */

{{Definición|Nombre=Algoritmo de ordenamiento. Shell|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden, siendo una generalización del ordenamiento por inserción}}'''[[Algoritmo de ordenamiento]]. Shell:''' El método se denomina así en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso, aunque un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n).
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones:
El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.
El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados.

== Descripción ==
El algoritmo Shell es una mejora de la ordenación por inserción, donde se van comparando elementos distantes, al tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos, el tamaño de los saltos disminuye; por esto mismo, es útil tanto como si los datos desordenados se encuentran cercanos, o lejanos.
Es bastante adecuado para ordenar listas de tamaño moderado, debido a que su velocidad es aceptable y su codificación es bastante sencilla. Su velocidad depende de la secuencia de valores con los cuales trabaja, ordenándolos.El siguiente ejemplo muestra el proceso de forma gráfica: 
Considerando un valor pequeño que está inicialmente almacenado en el final del vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el ordenamiento por inserción, tomará aproximadamente n comparaciones e intercambios para mover este valor hacia el otro extremo del vector. El Shell sort primero mueve los valores usando tamaños de espacio gigantes, de manera que un valor pequeño se moverá bastantes posiciones hacia su posición final, con sólo unas pocas comparaciones e intercambios.
== Ejemplo ==

Por ejemplo, considere una lista de números como [13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10]. Si comenzamos con un tamaño de paso de 8, podríamos visualizar esto dividiendo la lista de números en una tabla con 5 columnas. Esto quedaría así: 
[[Image:Ej1.JPG|center|Ej1.JPG]] 
Entonces ordenamos cada columna, lo que nos queda: 
[[Image:Ej2.JPG|center|Ej2.JPG]] 
Cuando lo leemos de nuevo como una única lista de números, obtenemos [ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]. Aquí, el 10 que estaba en el extremo final, se ha movido hasta el extremo inicial. Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3 posiciones, y después un ordenamiento con un espacio de 1 posición (ordenamiento por inserción simple).
== Secuencia de espacios ==
La ''secuencia de espacios'' es una parte integral del algoritmo Shell sort. Cualquier secuencia incremental funcionaría siempre que el último elemento sea 1. El algoritmo comienza realizando un ''ordenamiento por inserción con espacio'', siendo el espacio el primer número en la secuencia de espacios. Continua para realizar un ordenamiento por inserción con espacio para cada número en la secuencia, hasta que termina con un espacio de 1. Cuando el espacio es 1, el ordenamiento por inserción con espacio es simplemente un ordenamiento por inserción ordinario, garantizando que la lista final estará ordenada.
La secuencia de espacios que fue originalmente sugerida por Donald Shell debía comenzar con N / 2 y dividir por la mitad el número hasta alcanzar 1. Aunque esta secuencia proporciona mejoras de rendimiento significativas sobre los algoritmos cuadráticos como el ordenamiento por inserción, se puede cambiar ligeramente para disminuir más el tiempo necesario medio y el del peor caso.
Quizás la propiedad más crucial del Shell sort es que los elementos permanecen k-ordenados incluso mientras el espacio disminuye. Se dice que un vector dividido en k subvectores esta k-ordenado si cada uno de esos subvectores esta ordenado en caso de considerarlo aislado. Por ejemplo, si una lista fue 5-ordenada y después 3-ordenada, la lista está ahora no sólo 3-ordenada, sino tanto 5-ordenada como 3-ordenada. Si esto no fuera cierto, el algoritmo desharía el trabajo que había hecho en iteraciones previas, y no conseguiría un tiempo de ejecución tan bajo.

== Análisis del Costo Computacional ==
Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. Dependiendo de la elección de la secuencia de espacios, Shell sort tiene un tiempo de ejecución en el peor caso de O(n2) (usando los incrementos de Shell que comienzan con 1/2 del tamaño del vector y se dividen por 2 cada vez), O(n3 / 2) (usando los incrementos de Hibbard de 2k − 1), O(n4 / 3) (usando los incrementos de Sedgewick de 9(4i) − 9(2i) + 1, o 4i + 1 + 3(2i) + 1), o O(nlog2n), y posiblemente mejores tiempos de ejecución no comprobados. La existencia de una implementación O(nlogn) en el peor caso del Shell sort permanece como una pregunta por resolver.
== Implementación==

A continuación se muestra el Ordenamiento Shell en algunos de los lenguajes de programación de alto nivel más usados:
*C 
//Ordenamiento por método Shell 
public static void shellSort(int[] a) { 
for ( int increment = a.length / 2; 
increment > 0; 
increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) { 
for (int i = increment; i <> 
for (int j = i; j >= increment && a[j - increment] > a[j]; j -= increment) { 
int temp = a[j]; 
a[j] = a[j - increment]; 
a[j - increment] = temp; 
} 
} 
} 
} 
*PHP 
<?php
//Ordenamiento por Shell 
01 <?php 
02 function ordenamientoShell($A,$n) 
03 { 
04 for($inc = 1 ; $inc<$n;$inc=$inc*3+1); 
05 while ($inc > 0) 
06 { 
07 for ($i=$inc; $i < $n; $i++) 
08 { 
09 $j = $i; 
10 $temp = $A[$i]; 
11 while (($j >= $inc) && ($A[$j-$inc] > $temp)) 
12 { 
13 $A[$j] = $A[$j - $inc]; 
14 $j = $j - $inc; 
15 } 
16 $A[$j] = $temp; 
17 } 
18 $inc/= 2; 
19 } 
20 return $A; 
21 } 
22 function main() 
23 { 
24 $VectorA=array(5,4,3,2,1); 
25 $VectorB=ordenamientoShell($VectorA,sizeof($VectorA)); 
26 for($i=0;$i<sizeof($VectorB);$i++) 
27 echo $VectorB[$i]."\n"; 
28 } 
29 main(); 
30 ?>
*Python
1. #Algoritmo de ordenamiento Shell 
2. 
3. def shellsort (lista) : 
4. """Ordena la lista por metodo Shell, o ShellSort""" 
5. incremento=len(lista)/2 
6. while (incremento>0) : 
7. for i in range(incremento,len(lista)) : 
8. j=i 
9. temporal=lista[i] 
10. while ( (j>=incremento) and (lista[j-incremento]>temporal) ) : 
11. lista[j]=lista[j-incremento] 
12. j=j-incremento 
13. lista[j]=temporal 
14. if (incremento==2) : incremento=1 
15. else : incremento=int(incremento/2.2) 
16. return lista 

== Vease también ==
*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]

== Fuentes ==
*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de Ordenamiento Shell

2011-08-16T19:06:38Z

Manuel jc.manzanillo1: /* Vease también */

{{Definición|Nombre=Algoritmo de ordenamiento. Shell|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden, siendo una generalización del ordenamiento por inserción}}'''[[Algoritmo de ordenamiento]]. Shell:''' El método se denomina así en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso, aunque un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n).
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones:
El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.
El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados.

== Descripción ==
El algoritmo Shell es una mejora de la ordenación por inserción, donde se van comparando elementos distantes, al tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos, el tamaño de los saltos disminuye; por esto mismo, es útil tanto como si los datos desordenados se encuentran cercanos, o lejanos.
Es bastante adecuado para ordenar listas de tamaño moderado, debido a que su velocidad es aceptable y su codificación es bastante sencilla. Su velocidad depende de la secuencia de valores con los cuales trabaja, ordenándolos.El siguiente ejemplo muestra el proceso de forma gráfica: 
Considerando un valor pequeño que está inicialmente almacenado en el final del vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el ordenamiento por inserción, tomará aproximadamente n comparaciones e intercambios para mover este valor hacia el otro extremo del vector. El Shell sort primero mueve los valores usando tamaños de espacio gigantes, de manera que un valor pequeño se moverá bastantes posiciones hacia su posición final, con sólo unas pocas comparaciones e intercambios.
== Ejemplo ==

Por ejemplo, considere una lista de números como [13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10]. Si comenzamos con un tamaño de paso de 8, podríamos visualizar esto dividiendo la lista de números en una tabla con 5 columnas. Esto quedaría así: 
[[Image:Ej1.JPG|center|Ej1.JPG]] 
Entonces ordenamos cada columna, lo que nos queda: 
[[Image:Ej2.JPG|center|Ej2.JPG]] 
Cuando lo leemos de nuevo como una única lista de números, obtenemos [ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]. Aquí, el 10 que estaba en el extremo final, se ha movido hasta el extremo inicial. Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3 posiciones, y después un ordenamiento con un espacio de 1 posición (ordenamiento por inserción simple).
== Secuencia de espacios ==
La secuencia de espacios es una parte integral del algoritmo Shell sort. Cualquier secuencia incremental funcionaría siempre que el último elemento sea 1. El algoritmo comienza realizando un ordenamiento por inserción con espacio, siendo el espacio el primer número en la secuencia de espacios. Continua para realizar un ordenamiento por inserción con espacio para cada número en la secuencia, hasta que termina con un espacio de 1. Cuando el espacio es 1, el ordenamiento por inserción con espacio es simplemente un ordenamiento por inserción ordinario, garantizando que la lista final estará ordenada.
La secuencia de espacios que fue originalmente sugerida por Donald Shell debía comenzar con N / 2 y dividir por la mitad el número hasta alcanzar 1. Aunque esta secuencia proporciona mejoras de rendimiento significativas sobre los algoritmos cuadráticos como el ordenamiento por inserción, se puede cambiar ligeramente para disminuir más el tiempo necesario medio y el del peor caso.
Quizás la propiedad más crucial del Shell sort es que los elementos permanecen k-ordenados incluso mientras el espacio disminuye. Se dice que un vector dividido en k subvectores esta k-ordenado si cada uno de esos subvectores esta ordenado en caso de considerarlo aislado. Por ejemplo, si una lista fue 5-ordenada y después 3-ordenada, la lista está ahora no sólo 3-ordenada, sino tanto 5-ordenada como 3-ordenada. Si esto no fuera cierto, el algoritmo desharía el trabajo que había hecho en iteraciones previas, y no conseguiría un tiempo de ejecución tan bajo.
== Análisis del Costo Computacional ==
Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. Dependiendo de la elección de la secuencia de espacios, Shell sort tiene un tiempo de ejecución en el peor caso de O(n2) (usando los incrementos de Shell que comienzan con 1/2 del tamaño del vector y se dividen por 2 cada vez), O(n3 / 2) (usando los incrementos de Hibbard de 2k − 1), O(n4 / 3) (usando los incrementos de Sedgewick de 9(4i) − 9(2i) + 1, o 4i + 1 + 3(2i) + 1), o O(nlog2n), y posiblemente mejores tiempos de ejecución no comprobados. La existencia de una implementación O(nlogn) en el peor caso del Shell sort permanece como una pregunta por resolver.
== Implementación==

A continuación se muestra el Ordenamiento Shell en algunos de los lenguajes de programación de alto nivel más usados:
*C 
//Ordenamiento por método Shell 
public static void shellSort(int[] a) { 
for ( int increment = a.length / 2; 
increment > 0; 
increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) { 
for (int i = increment; i <> 
for (int j = i; j >= increment && a[j - increment] > a[j]; j -= increment) { 
int temp = a[j]; 
a[j] = a[j - increment]; 
a[j - increment] = temp; 
} 
} 
} 
} 
*PHP 
<?php
//Ordenamiento por Shell 
01 <?php 
02 function ordenamientoShell($A,$n) 
03 { 
04 for($inc = 1 ; $inc<$n;$inc=$inc*3+1); 
05 while ($inc > 0) 
06 { 
07 for ($i=$inc; $i < $n; $i++) 
08 { 
09 $j = $i; 
10 $temp = $A[$i]; 
11 while (($j >= $inc) && ($A[$j-$inc] > $temp)) 
12 { 
13 $A[$j] = $A[$j - $inc]; 
14 $j = $j - $inc; 
15 } 
16 $A[$j] = $temp; 
17 } 
18 $inc/= 2; 
19 } 
20 return $A; 
21 } 
22 function main() 
23 { 
24 $VectorA=array(5,4,3,2,1); 
25 $VectorB=ordenamientoShell($VectorA,sizeof($VectorA)); 
26 for($i=0;$i<sizeof($VectorB);$i++) 
27 echo $VectorB[$i]."\n"; 
28 } 
29 main(); 
30 ?>
*Python
1. #Algoritmo de ordenamiento Shell 
2. 
3. def shellsort (lista) : 
4. """Ordena la lista por metodo Shell, o ShellSort""" 
5. incremento=len(lista)/2 
6. while (incremento>0) : 
7. for i in range(incremento,len(lista)) : 
8. j=i 
9. temporal=lista[i] 
10. while ( (j>=incremento) and (lista[j-incremento]>temporal) ) : 
11. lista[j]=lista[j-incremento] 
12. j=j-incremento 
13. lista[j]=temporal 
14. if (incremento==2) : incremento=1 
15. else : incremento=int(incremento/2.2) 
16. return lista 

== Vease también ==
*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de burbuja]]

== Fuentes ==
*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de Ordenamiento Shell

2011-08-16T19:05:12Z

Manuel jc.manzanillo1: /* Vease también */

{{Definición|Nombre=Algoritmo de ordenamiento. Shell|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden, siendo una generalización del ordenamiento por inserción}}'''[[Algoritmo de ordenamiento]]. Shell:''' El método se denomina así en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso, aunque un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n).
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones:
El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.
El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados.

== Descripción ==
El algoritmo Shell es una mejora de la ordenación por inserción, donde se van comparando elementos distantes, al tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos, el tamaño de los saltos disminuye; por esto mismo, es útil tanto como si los datos desordenados se encuentran cercanos, o lejanos.
Es bastante adecuado para ordenar listas de tamaño moderado, debido a que su velocidad es aceptable y su codificación es bastante sencilla. Su velocidad depende de la secuencia de valores con los cuales trabaja, ordenándolos.El siguiente ejemplo muestra el proceso de forma gráfica: 
Considerando un valor pequeño que está inicialmente almacenado en el final del vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el ordenamiento por inserción, tomará aproximadamente n comparaciones e intercambios para mover este valor hacia el otro extremo del vector. El Shell sort primero mueve los valores usando tamaños de espacio gigantes, de manera que un valor pequeño se moverá bastantes posiciones hacia su posición final, con sólo unas pocas comparaciones e intercambios.
== Ejemplo ==

Por ejemplo, considere una lista de números como [13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10]. Si comenzamos con un tamaño de paso de 8, podríamos visualizar esto dividiendo la lista de números en una tabla con 5 columnas. Esto quedaría así: 
[[Image:Ej1.JPG|center|Ej1.JPG]] 
Entonces ordenamos cada columna, lo que nos queda: 
[[Image:Ej2.JPG|center|Ej2.JPG]] 
Cuando lo leemos de nuevo como una única lista de números, obtenemos [ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]. Aquí, el 10 que estaba en el extremo final, se ha movido hasta el extremo inicial. Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3 posiciones, y después un ordenamiento con un espacio de 1 posición (ordenamiento por inserción simple).
== Secuencia de espacios ==
La secuencia de espacios es una parte integral del algoritmo Shell sort. Cualquier secuencia incremental funcionaría siempre que el último elemento sea 1. El algoritmo comienza realizando un ordenamiento por inserción con espacio, siendo el espacio el primer número en la secuencia de espacios. Continua para realizar un ordenamiento por inserción con espacio para cada número en la secuencia, hasta que termina con un espacio de 1. Cuando el espacio es 1, el ordenamiento por inserción con espacio es simplemente un ordenamiento por inserción ordinario, garantizando que la lista final estará ordenada.
La secuencia de espacios que fue originalmente sugerida por Donald Shell debía comenzar con N / 2 y dividir por la mitad el número hasta alcanzar 1. Aunque esta secuencia proporciona mejoras de rendimiento significativas sobre los algoritmos cuadráticos como el ordenamiento por inserción, se puede cambiar ligeramente para disminuir más el tiempo necesario medio y el del peor caso.
Quizás la propiedad más crucial del Shell sort es que los elementos permanecen k-ordenados incluso mientras el espacio disminuye. Se dice que un vector dividido en k subvectores esta k-ordenado si cada uno de esos subvectores esta ordenado en caso de considerarlo aislado. Por ejemplo, si una lista fue 5-ordenada y después 3-ordenada, la lista está ahora no sólo 3-ordenada, sino tanto 5-ordenada como 3-ordenada. Si esto no fuera cierto, el algoritmo desharía el trabajo que había hecho en iteraciones previas, y no conseguiría un tiempo de ejecución tan bajo.
== Análisis del Costo Computacional ==
Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. Dependiendo de la elección de la secuencia de espacios, Shell sort tiene un tiempo de ejecución en el peor caso de O(n2) (usando los incrementos de Shell que comienzan con 1/2 del tamaño del vector y se dividen por 2 cada vez), O(n3 / 2) (usando los incrementos de Hibbard de 2k − 1), O(n4 / 3) (usando los incrementos de Sedgewick de 9(4i) − 9(2i) + 1, o 4i + 1 + 3(2i) + 1), o O(nlog2n), y posiblemente mejores tiempos de ejecución no comprobados. La existencia de una implementación O(nlogn) en el peor caso del Shell sort permanece como una pregunta por resolver.
== Implementación==

A continuación se muestra el Ordenamiento Shell en algunos de los lenguajes de programación de alto nivel más usados:
*C 
//Ordenamiento por método Shell 
public static void shellSort(int[] a) { 
for ( int increment = a.length / 2; 
increment > 0; 
increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) { 
for (int i = increment; i <> 
for (int j = i; j >= increment && a[j - increment] > a[j]; j -= increment) { 
int temp = a[j]; 
a[j] = a[j - increment]; 
a[j - increment] = temp; 
} 
} 
} 
} 
*PHP 
<?php
//Ordenamiento por Shell 
01 <?php 
02 function ordenamientoShell($A,$n) 
03 { 
04 for($inc = 1 ; $inc<$n;$inc=$inc*3+1); 
05 while ($inc > 0) 
06 { 
07 for ($i=$inc; $i < $n; $i++) 
08 { 
09 $j = $i; 
10 $temp = $A[$i]; 
11 while (($j >= $inc) && ($A[$j-$inc] > $temp)) 
12 { 
13 $A[$j] = $A[$j - $inc]; 
14 $j = $j - $inc; 
15 } 
16 $A[$j] = $temp; 
17 } 
18 $inc/= 2; 
19 } 
20 return $A; 
21 } 
22 function main() 
23 { 
24 $VectorA=array(5,4,3,2,1); 
25 $VectorB=ordenamientoShell($VectorA,sizeof($VectorA)); 
26 for($i=0;$i<sizeof($VectorB);$i++) 
27 echo $VectorB[$i]."\n"; 
28 } 
29 main(); 
30 ?>
*Python
1. #Algoritmo de ordenamiento Shell 
2. 
3. def shellsort (lista) : 
4. """Ordena la lista por metodo Shell, o ShellSort""" 
5. incremento=len(lista)/2 
6. while (incremento>0) : 
7. for i in range(incremento,len(lista)) : 
8. j=i 
9. temporal=lista[i] 
10. while ( (j>=incremento) and (lista[j-incremento]>temporal) ) : 
11. lista[j]=lista[j-incremento] 
12. j=j-incremento 
13. lista[j]=temporal 
14. if (incremento==2) : incremento=1 
15. else : incremento=int(incremento/2.2) 
16. return lista 

== Vease también ==
*[[Algoritmo de ordenamiento]].
*[[Ordenamiento de Burbuja]]

== Fuentes ==
*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de Ordenamiento Shell

2011-08-16T19:04:10Z

Manuel jc.manzanillo1: /* Vease también */

{{Definición|Nombre=Algoritmo de ordenamiento. Shell|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden, siendo una generalización del ordenamiento por inserción}}'''[[Algoritmo de ordenamiento]]. Shell:''' El método se denomina así en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso, aunque un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n).
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones:
El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.
El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados.

== Descripción ==
El algoritmo Shell es una mejora de la ordenación por inserción, donde se van comparando elementos distantes, al tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos, el tamaño de los saltos disminuye; por esto mismo, es útil tanto como si los datos desordenados se encuentran cercanos, o lejanos.
Es bastante adecuado para ordenar listas de tamaño moderado, debido a que su velocidad es aceptable y su codificación es bastante sencilla. Su velocidad depende de la secuencia de valores con los cuales trabaja, ordenándolos.El siguiente ejemplo muestra el proceso de forma gráfica: 
Considerando un valor pequeño que está inicialmente almacenado en el final del vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el ordenamiento por inserción, tomará aproximadamente n comparaciones e intercambios para mover este valor hacia el otro extremo del vector. El Shell sort primero mueve los valores usando tamaños de espacio gigantes, de manera que un valor pequeño se moverá bastantes posiciones hacia su posición final, con sólo unas pocas comparaciones e intercambios.
== Ejemplo ==

Por ejemplo, considere una lista de números como [13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10]. Si comenzamos con un tamaño de paso de 8, podríamos visualizar esto dividiendo la lista de números en una tabla con 5 columnas. Esto quedaría así: 
[[Image:Ej1.JPG|center|Ej1.JPG]] 
Entonces ordenamos cada columna, lo que nos queda: 
[[Image:Ej2.JPG|center|Ej2.JPG]] 
Cuando lo leemos de nuevo como una única lista de números, obtenemos [ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]. Aquí, el 10 que estaba en el extremo final, se ha movido hasta el extremo inicial. Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3 posiciones, y después un ordenamiento con un espacio de 1 posición (ordenamiento por inserción simple).
== Secuencia de espacios ==
La secuencia de espacios es una parte integral del algoritmo Shell sort. Cualquier secuencia incremental funcionaría siempre que el último elemento sea 1. El algoritmo comienza realizando un ordenamiento por inserción con espacio, siendo el espacio el primer número en la secuencia de espacios. Continua para realizar un ordenamiento por inserción con espacio para cada número en la secuencia, hasta que termina con un espacio de 1. Cuando el espacio es 1, el ordenamiento por inserción con espacio es simplemente un ordenamiento por inserción ordinario, garantizando que la lista final estará ordenada.
La secuencia de espacios que fue originalmente sugerida por Donald Shell debía comenzar con N / 2 y dividir por la mitad el número hasta alcanzar 1. Aunque esta secuencia proporciona mejoras de rendimiento significativas sobre los algoritmos cuadráticos como el ordenamiento por inserción, se puede cambiar ligeramente para disminuir más el tiempo necesario medio y el del peor caso.
Quizás la propiedad más crucial del Shell sort es que los elementos permanecen k-ordenados incluso mientras el espacio disminuye. Se dice que un vector dividido en k subvectores esta k-ordenado si cada uno de esos subvectores esta ordenado en caso de considerarlo aislado. Por ejemplo, si una lista fue 5-ordenada y después 3-ordenada, la lista está ahora no sólo 3-ordenada, sino tanto 5-ordenada como 3-ordenada. Si esto no fuera cierto, el algoritmo desharía el trabajo que había hecho en iteraciones previas, y no conseguiría un tiempo de ejecución tan bajo.
== Análisis del Costo Computacional ==
Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. Dependiendo de la elección de la secuencia de espacios, Shell sort tiene un tiempo de ejecución en el peor caso de O(n2) (usando los incrementos de Shell que comienzan con 1/2 del tamaño del vector y se dividen por 2 cada vez), O(n3 / 2) (usando los incrementos de Hibbard de 2k − 1), O(n4 / 3) (usando los incrementos de Sedgewick de 9(4i) − 9(2i) + 1, o 4i + 1 + 3(2i) + 1), o O(nlog2n), y posiblemente mejores tiempos de ejecución no comprobados. La existencia de una implementación O(nlogn) en el peor caso del Shell sort permanece como una pregunta por resolver.
== Implementación==

A continuación se muestra el Ordenamiento Shell en algunos de los lenguajes de programación de alto nivel más usados:
*C 
//Ordenamiento por método Shell 
public static void shellSort(int[] a) { 
for ( int increment = a.length / 2; 
increment > 0; 
increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) { 
for (int i = increment; i <> 
for (int j = i; j >= increment && a[j - increment] > a[j]; j -= increment) { 
int temp = a[j]; 
a[j] = a[j - increment]; 
a[j - increment] = temp; 
} 
} 
} 
} 
*PHP 
<?php
//Ordenamiento por Shell 
01 <?php 
02 function ordenamientoShell($A,$n) 
03 { 
04 for($inc = 1 ; $inc<$n;$inc=$inc*3+1); 
05 while ($inc > 0) 
06 { 
07 for ($i=$inc; $i < $n; $i++) 
08 { 
09 $j = $i; 
10 $temp = $A[$i]; 
11 while (($j >= $inc) && ($A[$j-$inc] > $temp)) 
12 { 
13 $A[$j] = $A[$j - $inc]; 
14 $j = $j - $inc; 
15 } 
16 $A[$j] = $temp; 
17 } 
18 $inc/= 2; 
19 } 
20 return $A; 
21 } 
22 function main() 
23 { 
24 $VectorA=array(5,4,3,2,1); 
25 $VectorB=ordenamientoShell($VectorA,sizeof($VectorA)); 
26 for($i=0;$i<sizeof($VectorB);$i++) 
27 echo $VectorB[$i]."\n"; 
28 } 
29 main(); 
30 ?>
*Python
1. #Algoritmo de ordenamiento Shell 
2. 
3. def shellsort (lista) : 
4. """Ordena la lista por metodo Shell, o ShellSort""" 
5. incremento=len(lista)/2 
6. while (incremento>0) : 
7. for i in range(incremento,len(lista)) : 
8. j=i 
9. temporal=lista[i] 
10. while ( (j>=incremento) and (lista[j-incremento]>temporal) ) : 
11. lista[j]=lista[j-incremento] 
12. j=j-incremento 
13. lista[j]=temporal 
14. if (incremento==2) : incremento=1 
15. else : incremento=int(incremento/2.2) 
16. return lista 

== Vease también ==
*[[Algoritmo de ordenamiento]].
*[[Algoritmos de ordenamiento. Burbuja]]

== Fuentes ==
*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de Ordenamiento Shell

2011-08-16T19:02:24Z

Manuel jc.manzanillo1: /* Vease también */

{{Definición|Nombre=Algoritmo de ordenamiento. Shell|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden, siendo una generalización del ordenamiento por inserción}}'''[[Algoritmo de ordenamiento]]. Shell:''' El método se denomina así en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso, aunque un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n).
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones:
El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.
El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados.

== Descripción ==
El algoritmo Shell es una mejora de la ordenación por inserción, donde se van comparando elementos distantes, al tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos, el tamaño de los saltos disminuye; por esto mismo, es útil tanto como si los datos desordenados se encuentran cercanos, o lejanos.
Es bastante adecuado para ordenar listas de tamaño moderado, debido a que su velocidad es aceptable y su codificación es bastante sencilla. Su velocidad depende de la secuencia de valores con los cuales trabaja, ordenándolos.El siguiente ejemplo muestra el proceso de forma gráfica: 
Considerando un valor pequeño que está inicialmente almacenado en el final del vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el ordenamiento por inserción, tomará aproximadamente n comparaciones e intercambios para mover este valor hacia el otro extremo del vector. El Shell sort primero mueve los valores usando tamaños de espacio gigantes, de manera que un valor pequeño se moverá bastantes posiciones hacia su posición final, con sólo unas pocas comparaciones e intercambios.
== Ejemplo ==

Por ejemplo, considere una lista de números como [13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10]. Si comenzamos con un tamaño de paso de 8, podríamos visualizar esto dividiendo la lista de números en una tabla con 5 columnas. Esto quedaría así: 
[[Image:Ej1.JPG|center|Ej1.JPG]] 
Entonces ordenamos cada columna, lo que nos queda: 
[[Image:Ej2.JPG|center|Ej2.JPG]] 
Cuando lo leemos de nuevo como una única lista de números, obtenemos [ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]. Aquí, el 10 que estaba en el extremo final, se ha movido hasta el extremo inicial. Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3 posiciones, y después un ordenamiento con un espacio de 1 posición (ordenamiento por inserción simple).
== Secuencia de espacios ==
La secuencia de espacios es una parte integral del algoritmo Shell sort. Cualquier secuencia incremental funcionaría siempre que el último elemento sea 1. El algoritmo comienza realizando un ordenamiento por inserción con espacio, siendo el espacio el primer número en la secuencia de espacios. Continua para realizar un ordenamiento por inserción con espacio para cada número en la secuencia, hasta que termina con un espacio de 1. Cuando el espacio es 1, el ordenamiento por inserción con espacio es simplemente un ordenamiento por inserción ordinario, garantizando que la lista final estará ordenada.
La secuencia de espacios que fue originalmente sugerida por Donald Shell debía comenzar con N / 2 y dividir por la mitad el número hasta alcanzar 1. Aunque esta secuencia proporciona mejoras de rendimiento significativas sobre los algoritmos cuadráticos como el ordenamiento por inserción, se puede cambiar ligeramente para disminuir más el tiempo necesario medio y el del peor caso.
Quizás la propiedad más crucial del Shell sort es que los elementos permanecen k-ordenados incluso mientras el espacio disminuye. Se dice que un vector dividido en k subvectores esta k-ordenado si cada uno de esos subvectores esta ordenado en caso de considerarlo aislado. Por ejemplo, si una lista fue 5-ordenada y después 3-ordenada, la lista está ahora no sólo 3-ordenada, sino tanto 5-ordenada como 3-ordenada. Si esto no fuera cierto, el algoritmo desharía el trabajo que había hecho en iteraciones previas, y no conseguiría un tiempo de ejecución tan bajo.
== Análisis del Costo Computacional ==
Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. Dependiendo de la elección de la secuencia de espacios, Shell sort tiene un tiempo de ejecución en el peor caso de O(n2) (usando los incrementos de Shell que comienzan con 1/2 del tamaño del vector y se dividen por 2 cada vez), O(n3 / 2) (usando los incrementos de Hibbard de 2k − 1), O(n4 / 3) (usando los incrementos de Sedgewick de 9(4i) − 9(2i) + 1, o 4i + 1 + 3(2i) + 1), o O(nlog2n), y posiblemente mejores tiempos de ejecución no comprobados. La existencia de una implementación O(nlogn) en el peor caso del Shell sort permanece como una pregunta por resolver.
== Implementación==

A continuación se muestra el Ordenamiento Shell en algunos de los lenguajes de programación de alto nivel más usados:
*C 
//Ordenamiento por método Shell 
public static void shellSort(int[] a) { 
for ( int increment = a.length / 2; 
increment > 0; 
increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) { 
for (int i = increment; i <> 
for (int j = i; j >= increment && a[j - increment] > a[j]; j -= increment) { 
int temp = a[j]; 
a[j] = a[j - increment]; 
a[j - increment] = temp; 
} 
} 
} 
} 
*PHP 
<?php
//Ordenamiento por Shell 
01 <?php 
02 function ordenamientoShell($A,$n) 
03 { 
04 for($inc = 1 ; $inc<$n;$inc=$inc*3+1); 
05 while ($inc > 0) 
06 { 
07 for ($i=$inc; $i < $n; $i++) 
08 { 
09 $j = $i; 
10 $temp = $A[$i]; 
11 while (($j >= $inc) && ($A[$j-$inc] > $temp)) 
12 { 
13 $A[$j] = $A[$j - $inc]; 
14 $j = $j - $inc; 
15 } 
16 $A[$j] = $temp; 
17 } 
18 $inc/= 2; 
19 } 
20 return $A; 
21 } 
22 function main() 
23 { 
24 $VectorA=array(5,4,3,2,1); 
25 $VectorB=ordenamientoShell($VectorA,sizeof($VectorA)); 
26 for($i=0;$i<sizeof($VectorB);$i++) 
27 echo $VectorB[$i]."\n"; 
28 } 
29 main(); 
30 ?>
*Python
1. #Algoritmo de ordenamiento Shell 
2. 
3. def shellsort (lista) : 
4. """Ordena la lista por metodo Shell, o ShellSort""" 
5. incremento=len(lista)/2 
6. while (incremento>0) : 
7. for i in range(incremento,len(lista)) : 
8. j=i 
9. temporal=lista[i] 
10. while ( (j>=incremento) and (lista[j-incremento]>temporal) ) : 
11. lista[j]=lista[j-incremento] 
12. j=j-incremento 
13. lista[j]=temporal 
14. if (incremento==2) : incremento=1 
15. else : incremento=int(incremento/2.2) 
16. return lista 

== Vease también ==
*[[Algoritmos de ordenamiento]].
*[[Algoritmos de ordenamiento. Burbuja]]

== Fuentes ==
*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de Ordenamiento Shell

2011-08-16T19:01:26Z

Manuel jc.manzanillo1: /* Implementación */

{{Definición|Nombre=Algoritmo de ordenamiento. Shell|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden, siendo una generalización del ordenamiento por inserción}}'''[[Algoritmo de ordenamiento]]. Shell:''' El método se denomina así en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso, aunque un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n).
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones:
El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.
El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados.

== Descripción ==
El algoritmo Shell es una mejora de la ordenación por inserción, donde se van comparando elementos distantes, al tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos, el tamaño de los saltos disminuye; por esto mismo, es útil tanto como si los datos desordenados se encuentran cercanos, o lejanos.
Es bastante adecuado para ordenar listas de tamaño moderado, debido a que su velocidad es aceptable y su codificación es bastante sencilla. Su velocidad depende de la secuencia de valores con los cuales trabaja, ordenándolos.El siguiente ejemplo muestra el proceso de forma gráfica: 
Considerando un valor pequeño que está inicialmente almacenado en el final del vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el ordenamiento por inserción, tomará aproximadamente n comparaciones e intercambios para mover este valor hacia el otro extremo del vector. El Shell sort primero mueve los valores usando tamaños de espacio gigantes, de manera que un valor pequeño se moverá bastantes posiciones hacia su posición final, con sólo unas pocas comparaciones e intercambios.
== Ejemplo ==

Por ejemplo, considere una lista de números como [13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10]. Si comenzamos con un tamaño de paso de 8, podríamos visualizar esto dividiendo la lista de números en una tabla con 5 columnas. Esto quedaría así: 
[[Image:Ej1.JPG|center|Ej1.JPG]] 
Entonces ordenamos cada columna, lo que nos queda: 
[[Image:Ej2.JPG|center|Ej2.JPG]] 
Cuando lo leemos de nuevo como una única lista de números, obtenemos [ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]. Aquí, el 10 que estaba en el extremo final, se ha movido hasta el extremo inicial. Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3 posiciones, y después un ordenamiento con un espacio de 1 posición (ordenamiento por inserción simple).
== Secuencia de espacios ==
La secuencia de espacios es una parte integral del algoritmo Shell sort. Cualquier secuencia incremental funcionaría siempre que el último elemento sea 1. El algoritmo comienza realizando un ordenamiento por inserción con espacio, siendo el espacio el primer número en la secuencia de espacios. Continua para realizar un ordenamiento por inserción con espacio para cada número en la secuencia, hasta que termina con un espacio de 1. Cuando el espacio es 1, el ordenamiento por inserción con espacio es simplemente un ordenamiento por inserción ordinario, garantizando que la lista final estará ordenada.
La secuencia de espacios que fue originalmente sugerida por Donald Shell debía comenzar con N / 2 y dividir por la mitad el número hasta alcanzar 1. Aunque esta secuencia proporciona mejoras de rendimiento significativas sobre los algoritmos cuadráticos como el ordenamiento por inserción, se puede cambiar ligeramente para disminuir más el tiempo necesario medio y el del peor caso.
Quizás la propiedad más crucial del Shell sort es que los elementos permanecen k-ordenados incluso mientras el espacio disminuye. Se dice que un vector dividido en k subvectores esta k-ordenado si cada uno de esos subvectores esta ordenado en caso de considerarlo aislado. Por ejemplo, si una lista fue 5-ordenada y después 3-ordenada, la lista está ahora no sólo 3-ordenada, sino tanto 5-ordenada como 3-ordenada. Si esto no fuera cierto, el algoritmo desharía el trabajo que había hecho en iteraciones previas, y no conseguiría un tiempo de ejecución tan bajo.
== Análisis del Costo Computacional ==
Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. Dependiendo de la elección de la secuencia de espacios, Shell sort tiene un tiempo de ejecución en el peor caso de O(n2) (usando los incrementos de Shell que comienzan con 1/2 del tamaño del vector y se dividen por 2 cada vez), O(n3 / 2) (usando los incrementos de Hibbard de 2k − 1), O(n4 / 3) (usando los incrementos de Sedgewick de 9(4i) − 9(2i) + 1, o 4i + 1 + 3(2i) + 1), o O(nlog2n), y posiblemente mejores tiempos de ejecución no comprobados. La existencia de una implementación O(nlogn) en el peor caso del Shell sort permanece como una pregunta por resolver.
== Implementación==

A continuación se muestra el Ordenamiento Shell en algunos de los lenguajes de programación de alto nivel más usados:
*C 
//Ordenamiento por método Shell 
public static void shellSort(int[] a) { 
for ( int increment = a.length / 2; 
increment > 0; 
increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) { 
for (int i = increment; i <> 
for (int j = i; j >= increment && a[j - increment] > a[j]; j -= increment) { 
int temp = a[j]; 
a[j] = a[j - increment]; 
a[j - increment] = temp; 
} 
} 
} 
} 
*PHP 
<?php
//Ordenamiento por Shell 
01 <?php 
02 function ordenamientoShell($A,$n) 
03 { 
04 for($inc = 1 ; $inc<$n;$inc=$inc*3+1); 
05 while ($inc > 0) 
06 { 
07 for ($i=$inc; $i < $n; $i++) 
08 { 
09 $j = $i; 
10 $temp = $A[$i]; 
11 while (($j >= $inc) && ($A[$j-$inc] > $temp)) 
12 { 
13 $A[$j] = $A[$j - $inc]; 
14 $j = $j - $inc; 
15 } 
16 $A[$j] = $temp; 
17 } 
18 $inc/= 2; 
19 } 
20 return $A; 
21 } 
22 function main() 
23 { 
24 $VectorA=array(5,4,3,2,1); 
25 $VectorB=ordenamientoShell($VectorA,sizeof($VectorA)); 
26 for($i=0;$i<sizeof($VectorB);$i++) 
27 echo $VectorB[$i]."\n"; 
28 } 
29 main(); 
30 ?>
*Python
1. #Algoritmo de ordenamiento Shell 
2. 
3. def shellsort (lista) : 
4. """Ordena la lista por metodo Shell, o ShellSort""" 
5. incremento=len(lista)/2 
6. while (incremento>0) : 
7. for i in range(incremento,len(lista)) : 
8. j=i 
9. temporal=lista[i] 
10. while ( (j>=incremento) and (lista[j-incremento]>temporal) ) : 
11. lista[j]=lista[j-incremento] 
12. j=j-incremento 
13. lista[j]=temporal 
14. if (incremento==2) : incremento=1 
15. else : incremento=int(incremento/2.2) 
16. return lista 

== Vease también ==
*Algoritmos de ordenamiento.
*Algoritmos de ordenamiento. Burbuja
== Fuentes ==
*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Algoritmo de Ordenamiento Shell

2011-08-16T18:48:10Z

Manuel jc.manzanillo1: Página creada con '{{Definición|Nombre=Algoritmo de ordenamiento. Shell|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una...'

{{Definición|Nombre=Algoritmo de ordenamiento. Shell|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden, siendo una generalización del ordenamiento por inserción}}'''[[Algoritmo de ordenamiento]]. Shell:''' El método se denomina así en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso, aunque un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n).
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones:
El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.
El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados.

== Descripción ==
El algoritmo Shell es una mejora de la ordenación por inserción, donde se van comparando elementos distantes, al tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos, el tamaño de los saltos disminuye; por esto mismo, es útil tanto como si los datos desordenados se encuentran cercanos, o lejanos.
Es bastante adecuado para ordenar listas de tamaño moderado, debido a que su velocidad es aceptable y su codificación es bastante sencilla. Su velocidad depende de la secuencia de valores con los cuales trabaja, ordenándolos.El siguiente ejemplo muestra el proceso de forma gráfica: 
Considerando un valor pequeño que está inicialmente almacenado en el final del vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el ordenamiento por inserción, tomará aproximadamente n comparaciones e intercambios para mover este valor hacia el otro extremo del vector. El Shell sort primero mueve los valores usando tamaños de espacio gigantes, de manera que un valor pequeño se moverá bastantes posiciones hacia su posición final, con sólo unas pocas comparaciones e intercambios.
== Ejemplo ==

Por ejemplo, considere una lista de números como [13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10]. Si comenzamos con un tamaño de paso de 8, podríamos visualizar esto dividiendo la lista de números en una tabla con 5 columnas. Esto quedaría así: 
[[Image:Ej1.JPG|center|Ej1.JPG]] 
Entonces ordenamos cada columna, lo que nos queda: 
[[Image:Ej2.JPG|center|Ej2.JPG]] 
Cuando lo leemos de nuevo como una única lista de números, obtenemos [ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]. Aquí, el 10 que estaba en el extremo final, se ha movido hasta el extremo inicial. Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3 posiciones, y después un ordenamiento con un espacio de 1 posición (ordenamiento por inserción simple).
== Secuencia de espacios ==
La secuencia de espacios es una parte integral del algoritmo Shell sort. Cualquier secuencia incremental funcionaría siempre que el último elemento sea 1. El algoritmo comienza realizando un ordenamiento por inserción con espacio, siendo el espacio el primer número en la secuencia de espacios. Continua para realizar un ordenamiento por inserción con espacio para cada número en la secuencia, hasta que termina con un espacio de 1. Cuando el espacio es 1, el ordenamiento por inserción con espacio es simplemente un ordenamiento por inserción ordinario, garantizando que la lista final estará ordenada.
La secuencia de espacios que fue originalmente sugerida por Donald Shell debía comenzar con N / 2 y dividir por la mitad el número hasta alcanzar 1. Aunque esta secuencia proporciona mejoras de rendimiento significativas sobre los algoritmos cuadráticos como el ordenamiento por inserción, se puede cambiar ligeramente para disminuir más el tiempo necesario medio y el del peor caso.
Quizás la propiedad más crucial del Shell sort es que los elementos permanecen k-ordenados incluso mientras el espacio disminuye. Se dice que un vector dividido en k subvectores esta k-ordenado si cada uno de esos subvectores esta ordenado en caso de considerarlo aislado. Por ejemplo, si una lista fue 5-ordenada y después 3-ordenada, la lista está ahora no sólo 3-ordenada, sino tanto 5-ordenada como 3-ordenada. Si esto no fuera cierto, el algoritmo desharía el trabajo que había hecho en iteraciones previas, y no conseguiría un tiempo de ejecución tan bajo.
== Análisis del Costo Computacional ==
Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. Dependiendo de la elección de la secuencia de espacios, Shell sort tiene un tiempo de ejecución en el peor caso de O(n2) (usando los incrementos de Shell que comienzan con 1/2 del tamaño del vector y se dividen por 2 cada vez), O(n3 / 2) (usando los incrementos de Hibbard de 2k − 1), O(n4 / 3) (usando los incrementos de Sedgewick de 9(4i) − 9(2i) + 1, o 4i + 1 + 3(2i) + 1), o O(nlog2n), y posiblemente mejores tiempos de ejecución no comprobados. La existencia de una implementación O(nlogn) en el peor caso del Shell sort permanece como una pregunta por resolver.
== Implementación==

A continuación se muestra el Ordenamiento Shell en algunos de los lenguajes de programación de alto nivel más usados:
*C 
//Ordenamiento por método Shell
public static void shellSort(int[] a) {
for ( int increment = a.length / 2;
increment > 0;
increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) {
for (int i = increment; i <>
for (int j = i; j >= increment && a[j - increment] > a[j]; j -= increment) {
int temp = a[j];
a[j] = a[j - increment];
a[j - increment] = temp;
}
}
}
} 
*PHP 
<?php
//Ordenamiento por Shell
01 <?php
02 function ordenamientoShell($A,$n)
03 {
04 for($inc = 1 ; $inc<$n;$inc=$inc*3+1);
05 while ($inc > 0)
06 {
07 for ($i=$inc; $i < $n; $i++)
08 {
09 $j = $i;
10 $temp = $A[$i];
11 while (($j >= $inc) && ($A[$j-$inc] > $temp))
12 {
13 $A[$j] = $A[$j - $inc];
14 $j = $j - $inc;
15 }
16 $A[$j] = $temp;
17 }
18 $inc/= 2;
19 }
20 return $A;
21 }
22 function main()
23 {
24 $VectorA=array(5,4,3,2,1);
25 $VectorB=ordenamientoShell($VectorA,sizeof($VectorA));
26 for($i=0;$i<sizeof($VectorB);$i++)
27 echo $VectorB[$i]."\n";
28 }
29 main();
30 ?>
*Python
1. #Algoritmo de ordenamiento Shell
2.
3. def shellsort (lista) :
4. """Ordena la lista por metodo Shell, o ShellSort"""
5. incremento=len(lista)/2
6. while (incremento>0) :
7. for i in range(incremento,len(lista)) :
8. j=i
9. temporal=lista[i]
10. while ( (j>=incremento) and (lista[j-incremento]>temporal) ) :
11. lista[j]=lista[j-incremento]
12. j=j-incremento
13. lista[j]=temporal
14. if (incremento==2) : incremento=1
15. else : incremento=int(incremento/2.2)
16. return lista

== Vease también ==
*Algoritmos de ordenamiento.
*Algoritmos de ordenamiento. Burbuja
== Fuentes ==
*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_Shell Wikipedia].

[[Category:Algoritmos]]

Archivo:Ej2.JPG

2011-08-16T18:45:29Z

Manuel jc.manzanillo1:

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Archivo:Ej1.JPG

2011-08-16T18:43:25Z

Manuel jc.manzanillo1:

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

QuickSort

2011-07-29T23:39:20Z

Manuel jc.manzanillo1:

{{Definición
|nombre=Ordenamiento por Quicksort
|imagen=Algo_Quicksort.gif
|tamaño=
|concepto=
}}

 '''El ordenamiento rápido,''' '''[[Quicksort|quicksort]] '''en inglés: Es un [[Algoritmo|algoritmo]] basado en la técnica de divide y vencerás, que permite, en promedio, ordenar n elementos en un tiempo proporcional a n log n. 

== Descripción del algoritmo ==

El algoritmo consta de los siguientes pasos:

 

#Elegir un elemento de la lista de elementos a ordenar, al que llamaremos [[Pivote|pivote]].

#Resituar los demás elementos de la lista a cada lado del pivote, de manera que a un lado queden todos los menores que él, y al otro los mayores. Los elementos iguales al pivote pueden ser colocados tanto a su derecha como a su izquierda, dependiendo de la [[Implementación|implementación]] deseada. En este momento, el pivote ocupa exactamente el lugar que le corresponderá en la lista ordenada.

#La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del pivote, y otra por los elementos a su derecha.

#Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados. 

 

== Eficiencia del algoritmo ==

La [[Eficiencia del algoritmo|eficiencia del algoritmo]] depende de la posición en la que termine el pivote elegido. En el mejor caso, el pivote termina en el centro de la lista, dividiéndola en dos sublistas de igual tamaño. En este caso, el orden de [[Complejidad del algoritmo|complejidad del algoritmo]] es O(n•log n). En el peor caso, el pivote termina en un extremo de la lista. El orden de complejidad del algoritmo es entonces de O(n²). El peor caso dependerá de la implementación del algoritmo, aunque habitualmente ocurre en listas que se encuentran ordenadas, o casi ordenadas. Pero principalmente depende del pivote, si por ejemplo el algoritmo implementado toma como pivote siempre el primer elemento del array, y el array que le pasamos está ordenado, siempre va a generar a su izquierda un array vacío, lo que es ineficiente. En el caso promedio, el orden es O(n•log n). Y no es extraño, pues, que la mayoría de [[Optimizaciones|optimizaciones]] que se aplican al algoritmo se centren en la elección del pivote. 

== Demostración ==

Suponiendo que el número total de elementos a ordenar es potencia de dos, es decir, n = 2k. De aquí podemos ver que k = log2(n), donde k es el número de divisiones que realizará el algoritmo.

 En la primera fase del algoritmo habrán n comparaciones, en la segunda fase el algoritmo creará dos sublistas aproximadamente de tamaño n/2. El número total de comparaciones de estas dos sublistas es: 2(n/2) = n. En la tercera fase el algoritmo procesará 4 sublistas más, por tanto el número total de comparaciones en esta fase es 4(n/4) = n.

 En conclusión, el número total de comparaciones que hace el algoritmo es:

 n + n + n + ..... + n = kn, donde k = log2(n), por tanto el tiempo de ejecución del algoritmo en el mejor caso es O(n.log2n) 

== Optimización del algoritmo ==

Cabe destacar que de usarse en su versión recursiva las siguientes optimizaciones y sus desventajas no se ven vistas en el tiempo de ejecución del mismo manteniéndose, así el tiempo de ejecución planteado en un principio. 

== Técnicas de elección del pivote ==

El algoritmo básico del método Quicksort consiste en tomar cualquier elemento de la lista al cual denominaremos como pivote, dependiendo de la partición en que se elija, el algoritmo será más o menos eficiente. Tomar un elemento cualquiera como pivote tiene la ventaja de no requerir ningún cálculo adicional, lo cual lo hace bastante rápido. Sin embargo, esta elección «a ciegas» siempre provoca que el algoritmo tenga un orden de O(n²) para ciertas permutaciones de los elementos en la lista. Otra opción puede ser recorrer la lista para saber de antemano qué elemento ocupará la posición central de la lista, para elegirlo como pivote. Esto puede hacerse en O(n) y asegura que hasta en el peor de los casos, el algoritmo sea O(n•log n). No obstante, el cálculo adicional rebaja bastante la eficiencia del algoritmo en el caso promedio. La opción a medio camino es tomar tres elementos de la lista - por ejemplo, el primero, el segundo, y el último - y compararlos, eligiendo el valor del medio como pivote. 

== Técnicas de reposicionamiento ==

Una idea preliminar para ubicar el pivote en su posición final sería contar la cantidad de elementos menores que él, y colocarlo un lugar más arriba, moviendo luego todos esos elementos menores que él a su izquierda, para que pueda aplicarse la [[Recursividad|recursividad]].

 Existe, no obstante, un procedimiento mucho más efectivo. Se utilizan dos índices: i, al que llamaremos índice izquierdo, y j, al que llamaremos índice derecho. El algoritmo es el siguiente:

 Recorrer la lista simultáneamente con i y j: por la izquierda con i (desde el primer elemento), y por la derecha con j (desde el último elemento). Cuando lista[i] sea mayor que el pivote y lista[j] sea menor, se intercambian los elementos en esas posiciones.

 Repetir esto hasta que se crucen los índices. El punto en que se cruzan los índices es la posición adecuada para colocar el pivote, porque sabemos que a un lado los elementos son todos menores y al otro son todos mayores (o habrían sido intercambiados). 

== Parámetros:  ==

#Se debe llamar a la función Quicksort desde donde quiera ejecutarse

#Ésta llamará a colocar pivote para encontrar el valor del mismo

#Se ejecutará el algoritmo Quicksort de forma recursiva a ambos lados del pivote

 int colocar(int *v, int b, int t) { int i; int pivote, valor_pivote; int temp; pivote = b; valor_pivote = v[pivote]; for (i=b+1; i<=t; i++){ if (v[i] < valor_pivote){ pivote++; temp=v[i]; v[i]=v[pivote]; v[pivote]=temp; } } temp=v[b]; v[b]=v[pivote]; v[pivote]=temp; return pivote; } void Quicksort(int* v, int b, int t) { int pivote; if(b < t){ pivote=colocar(v, b, t); Quicksort(v, b, pivote-1); Quicksort(v, pivote+1, t); } }

 Nota: Los tres parámetros de la llamada inicial a Quicksort serán array[0], 0, numero_elementos -1, es decir, si es un array de 6 elementos array[0], 0, 5 

 

== Implementación del Pseudocódigo ==

function quicksort(array) var list, less, greater if length(array) ≤ 1 return array seleccionar y eliminar un valor pivote pivot en el array for each x in array if x < pivot then añadir x a less else añadir x a greater return concadenar(quicksort(less), pivot, quicksort(greater)) 

== Ejemplo ==

En el siguiente ejemplo se marcan el pivote y los índices i y j con las letras p, i y j respectivamente.

 Comenzamos con la lista completa. El elemento pivote será el 4: 5 - 3 - 7 - 6 - 2 - 1 - 4 p

 Comparamos con el 5 por la izquierda y el 1 por la derecha. 5 - 3 - 7 - 6 - 2 - 1 - 4 i j p

 5 es mayor que 4 y 1 es menor. Intercambiamos: 1 - 3 - 7 - 6 - 2 - 5 - 4 i j p

 Avanzamos por la izquierda y la derecha: 1 - 3 - 7 - 6 - 2 - 5 - 4 i j p

 3 es menor que 4: avanzamos por la izquierda. 2 es menor que 4: nos mantenemos ahí. 1 - 3 - 7 - 6 - 2 - 5 - 4 i j p

 7 es mayor que 4 y 2 es menor: intercambiamos. 1 - 3 - 2 - 6 - 7 - 5 - 4 i j p

 Avanzamos por ambos lados: 1 - 3 - 2 - 6 - 7 - 5 - 4 iyj p

 En este momento termina el ciclo principal, porque los índices se cruzaron. Ahora intercambiamos lista[i] con lista[sup] (pasos 16-18): 1 - 3 - 2 - 4 - 7 - 5 - 6 p

 Aplicamos recursivamente a la sublista de la izquierda (índices 0 - 2). Tenemos lo siguiente: 1 - 3 - 2

 1 es menor que 2: avanzamos por la izquierda. 3 es mayor: avanzamos por la derecha. Como se intercambiaron los índices termina el ciclo. Se intercambia lista[i] con lista[sup]: 1 - 2 - 3

 El mismo procedimiento se aplicará a la otra sublista. Al finalizar y unir todas las sublistas queda la lista inicial ordenada en forma ascendente. 1 - 2 - 3 - 4 - 5 - 6 - 7 

== Referencias ==

*[[Quick Sort|Quick Sort]] 

*[[Ordenamiento rápido, Implementación y descripción|Ordenamiento rápido, Implementación y descripción]]

*[[QuickSort C Code|QuickSort C Code]]

*[[Wikipedia|Wikipedia]]

 

[[Category:Algoritmos]]

Archivo:Algo Quicksort.gif

2011-07-29T23:38:38Z

Manuel jc.manzanillo1:

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Ordenamiento de burbuja

2011-06-30T01:24:56Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Burbuja|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden}}'''[[Algoritmo de ordenamiento]]. Burbuja'''(Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas burbujas. También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.

== Descripción ==

El procedimiento de la burbuja es el siguiente:
§ Ir comparando desde la casilla 0 número tras número hasta encontrar uno mayor, si este es realmente el mayor de todo el vector se llevará hasta la última casilla, si no es así, será reemplazado por uno mayor que él.
§ Este procedimiento seguirá así hasta que haya ordenado todas las casillas del vector.
§ Una de las deficiencias del algoritmo es que ya cuando a ordenado parte del vector vuelve a compararlo cuando esto ya no es necesario.

Dado un vector a1, a2, a3, ... an
1) Comparar a1 con a2 e intercambiarlos si a1>a2 (o a12)
2) Seguir hasta que todo se haya comparado an-1 con an
3) Repetir el proceso anterior n-1 veces 
Algoritmo: Complejidad
for(i=0; i < n-++){ T(n2)
for(j=0; j < n-1; j++){ T(n)
if(vec[j] > vec[j+1]){ T(1)
aux=vec[j]; T(1)
vec[j]=vec[j+1]; T(1)
vec[j+1]=aux;} T(1)
} } 
El siguiente ejemplo muestra el proceso de forma gráfica: 

[[Image:Tabla burbuja.JPG|center|Tabla burbuja.JPG]]

== Análisis del Costo Computacional ==

Al algoritmo de la burbuja, para ordenar un vector de '''n''' términos, tiene que realizar siempre el mismo número de comparaciones: 
[[Image:b1.gif|left|b1.gif]] 
Esto es, el número de comparaciones '''c(n) ''' no depende del orden de los términos, si no del número de términos. 
[[Image:b2.gif|left|b2.gif]] 
 
Por lo tanto la cota ajustada asintótica del número de comparaciones pertenece al orden de '''n''' cuadrado.
El numero de intercambios '''i(n)''', que hay que realizar depende del orden de los términos y podemos diferencia, el caso mejor, si el vector esta previamente ordenado, y el caso peor, si el vector esta ordenado en orden inverso.
 
[[Image:b3.gif|left|b3.gif]] 
Por lo que no se puede determinar una cota ajustada asintótica del número de intercambios, dado que este dependerá del orden del vector en cuestión. 
'''Rendimiento en el caso desfavorable''' 
Si pasamos al algoritmo un vector ordenado en orden inverso realizara un número de comparaciones: 
[[Image:b1.gif|left|b1.gif]] 
Como ya hemos dicho anteriormente, y tendrá que realizar un número igual de intercambios entre los términos del vector, dado que en cada comparación los términos estarán desordenados, y se realizará el intercambio. 
[[Image:b4.gif|left|b4.gif]] 
Por lo tanto en el caso más desfavorable tanto el número de comparaciones como el de intercambios coinciden: 
[[Image:b5.gif|left|b5.gif]] 

El número de comparaciones o de intercambios en el caso más desfavorable pertenece al orden de '''n''' cuadrado. 
'''Rendimiento en casos óptimos''' 
En el caso óptimo, el más favorable, es la ordenación que un vector ya ordenado, en este caso el número de comparaciones será el mismo que en cualquier otro caso: 
[[Image:b6.gif|left|b6.gif]] 

La cota inferior asintótica del número de comparaciones pertenece al orden de '''n''' cuadrado, como en los demás casos, pero en todas las comparaciones el orden es el correcto y por tanto no se realiza ningún intercambio: 
[[Image:b7.gif|left|b7.gif]] 

Por lo tanto el coste de intercambios no depende de '''n''', y es constante: 
[[Image:b8.gif|left|b8.gif]] 

El ordenamiento de burbuja tiene una complejidad '''Ω(n²)''' igual que ordenamiento por selección. Cuando una lista ya está ordenada, a diferencia del ordenamiento por inserción, que pasará por la lista una vez y encontrará que no hay necesidad de intercambiar las posiciones de los elementos, el método de ordenación por burbuja está forzado a pasar por dichas comparaciones, lo que hace que su complejidad sea cuadrática en el mejor de los casos. Esto lo cataloga como el '''algoritmo más ineficiente''' que existe, aunque para muchos programadores sea el más sencillo de implementar.

== Aplicación ==

A pesar de que el ordenamiento de burbuja es uno de los algoritmos más sencillos de implementar, su orden '''O(n2)''' lo hace muy ineficiente para usar en listas que tengan más que un número reducido de elementos. Incluso entre los algoritmos de ordenamiento de orden '''O(n2)''', otros procedimientos como el ordenamiento por inserción son considerados más eficientes.
Dada su simplicidad, el ordenamiento de burbuja es utilizado para introducir el concepto de algoritmo de ordenamiento para estudiantes de ciencias de la computación. A pesar de esto, algunos investigadores como Owen Astrachan han criticado su popularidad en la enseñanza de ciencias de la computación, llegando a recomendar su eliminación de los planes de estudio.
Sumado a esto, Jargon File, un libro ampliamente citado en la cultura hacker, lo denomina "el mal algoritmo genérico", y Donald Knuth, uno de los mayores expertos en ciencias de la computación, afirma que el ordenamiento de burbuja "no parece tener nada para recomendar su uso, a excepción de un nombre pegajoso y el hecho de que conlleva a problemas teóricos interesantes".
El ordenamiento de burbuja es asintóticamente equivalente, en tiempos de ejecución, con el ordenamiento por inserción en el peor de los casos, pero ambos algoritmos difieren principalmente en la cantidad de intercambios que son necesarios. Resultados experimentales como los descubiertos por Astrachan han demostrado que el ordenamiento por inserción funciona considerablemente mejor incluso con listas aleatorias. Por esta razón, muchos libros de algoritmos modernos evitan usar el ordenamiento de burbuja, reemplazándolo por el ordenamiento por inserción.
El ordenamiento de burbuja interactúa vagamente con el hardware de las CPU modernas. Requiere al menos el doble de escrituras que el ordenamiento por inserción, el doble de pérdidas de cache, y asintóticamente más predicción de saltos. Varios experimentos de ordenamiento de cadenas en Java hechos por Astrachan muestran que el ordenamiento de burbuja es 5 veces más lento que el ordenamiento por inserción, y 40% más lento que el ordenamiento por selección.

== Implementación==

A continuación se muestra el Ordenamiento de burbuja en algunos de los lenguajes de programación más usados:
*C 
//Ordenamiento por método de la Burbuja
void ordenamientoBurbuja(int v[], int util_v) {
int temp, i, j;

for (i = 0; i < util_v -1 ; i++) {
for (j = i + 1; j < util_v ; j++) {
if (v[i] > v[j]) {
temp = v[i];
v[i] = v[j];
v[j] = temp;
}
}
} }
*C++ 
template<typename _Ty>
void bubble_sort(vector<_Ty> & v){

for (size_t i = 0; i < v.size() - 1; ++i){
for (size_t j = i + 1; j < v.size(); ++j){
if (v[i] > v[j])
swap(v[i], v[j]);
}
}
}
*C#
Public int[] OrdenarBurbuja(int[]x)
{
int t= x.Length, temp;
for(int i=1 ; i< t ; i++)
for(int j = t-1 ; j >= i; j--)
{
if(x[j] < x[j-1])
{
temp= x[j];
x[j]= x[j-1];
x[j-1]= temp;
}
}
return x;
}
*Java
//Ordenamiento por Burbuja
// by ramses2999
publicstatic int[] OrdenarBurbuja(int[] n){
int temp;
int t = n.length;
for (int i = 1; i < t; i++) {
for (int k = t- 1; k >= i; k--) {
if(n[k] < n[k-1]){
temp = n[k];
n[k] = n[k-1];
n[k-1]= temp;
}//fin if
}// fin 2 for
}//fin 1 for
return n;
}//fin
*Perl
sub bubblesort {
# Ordena la lista pasada como argumento por valor
for my $i ( 0 .. @_-2 ) {
for my $j ( $i+1 .. @_-1 ) {
@_[ $i, $j ] = @_[ $j, $i ] if $_[$i] > $_[$j];
}}
}
*Visual Basic
Private Sub OrdenarBurbuja(ByRef VectorOriginal() As Integer)
Dim Temp, Longitud As Integer
Longitud = UBound(VectorOriginal) - 2
For b = 0 To Longitud
For a = 0 To Longitud
If VectorOriginal(a) > VectorOriginal(a + 1) Then
Temp = VectorOriginal(a + 1)
VectorOriginal(a + 1) = VectorOriginal(a)
VectorOriginal(a) = Temp
EndIf
Next
Next
End Sub
*PHP
<?php

//Ordenamiento por burbuja
$numeros = array(9, 4, -1, 7, 8, 11, 6, 12, 10, 5);

$n = count($numeros);

for ($i = 1; $i<$n; $i++) {
for ($j = $n-1; $j >= $i; $j--) {
echo "i: $i, j: $j\n";
echo "Comparando " . $numeros[$j-1] . " y " . $numeros[$j] . "\n";
if ($numeros[$j-1] > $numeros[$j]) {
$aux = $numeros[$j];
$numeros[$j] = $numeros[$j-1];
$numeros[$j-1] = $aux;
}
}
}

print_r($numeros);
*Pascal
Procedure Burbuja(var lista:vector;size:integer);
var i,j:integer;

begin
for i:=1 to size-1 do
for j:=1 to size-i do
begin
if lista[j]>lista[j+1] then
begin
aux:=lista[j];
lista[j]:=lista[j+1];
lista[j+1]:=aux
end;
end;
end;

== Vease también ==

*Algoritmos de ordenamiento.

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_de_burbuja Wikipedia].

[[Category:Algoritmos]]

Ordenamiento de burbuja

2011-06-30T01:23:49Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Burbuja|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden}}'''[[Algoritmo de ordenamiento]]. Burbuja'''(Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas burbujas. También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.

== Descripción ==

El procedimiento de la burbuja es el siguiente:
§ Ir comparando desde la casilla 0 número tras número hasta encontrar uno mayor, si este es realmente el mayor de todo el vector se llevará hasta la última casilla, si no es así, será reemplazado por uno mayor que él.
§ Este procedimiento seguirá así hasta que haya ordenado todas las casillas del vector.
§ Una de las deficiencias del algoritmo es que ya cuando a ordenado parte del vector vuelve a compararlo cuando esto ya no es necesario.

Dado un vector a1, a2, a3, ... an
1) Comparar a1 con a2 e intercambiarlos si a1>a2 (o a12)
2) Seguir hasta que todo se haya comparado an-1 con an
3) Repetir el proceso anterior n-1 veces 
Algoritmo: Complejidad
for(i=0; i < n-++){ T(n2)
for(j=0; j < n-1; j++){ T(n)
if(vec[j] > vec[j+1]){ T(1)
aux=vec[j]; T(1)
vec[j]=vec[j+1]; T(1)
vec[j+1]=aux;} T(1)
} } 
El siguiente ejemplo muestra el proceso de forma gráfica: 

[[Image:Tabla burbuja.JPG|center|Tabla burbuja.JPG]]

== Análisis del Costo Computacional ==

Al algoritmo de la burbuja, para ordenar un vector de '''n''' términos, tiene que realizar siempre el mismo número de comparaciones: 
[[Image:b1.gif|left|b1.gif]] 
Esto es, el número de comparaciones '''c(n) ''' no depende del orden de los términos, si no del número de términos. 
[[Image:b2.gif|left|b2.gif]] 
 
Por lo tanto la cota ajustada asintótica del número de comparaciones pertenece al orden de '''n''' cuadrado.
El numero de intercambios '''i(n)''', que hay que realizar depende del orden de los términos y podemos diferencia, el caso mejor, si el vector esta previamente ordenado, y el caso peor, si el vector esta ordenado en orden inverso.
 
[[Image:b3.gif|left|b3.gif]] 
Por lo que no se puede determinar una cota ajustada asintótica del número de intercambios, dado que este dependerá del orden del vector en cuestión. 
'''Rendimiento en el caso desfavorable''' 
Si pasamos al algoritmo un vector ordenado en orden inverso realizara un número de comparaciones: 
[[Image:b1.gif|left|b1.gif]] 
Como ya hemos dicho anteriormente, y tendrá que realizar un número igual de intercambios entre los términos del vector, dado que en cada comparación los términos estarán desordenados, y se realizará el intercambio. 
[[Image:b4.gif|left|b4.gif]] 
Por lo tanto en el caso más desfavorable tanto el número de comparaciones como el de intercambios coinciden: 
[[Image:b5.gif|left|b5.gif]] 

El número de comparaciones o de intercambios en el caso más desfavorable pertenece al orden de '''n''' cuadrado. 
'''Rendimiento en casos óptimos''' 
En el caso óptimo, el más favorable, es la ordenación que un vector ya ordenado, en este caso el número de comparaciones será el mismo que en cualquier otro caso: 
[[Image:b6.gif|left|b6.gif]] 

La cota inferior asintótica del número de comparaciones pertenece al orden de '''n''' cuadrado, como en los demás casos, pero en todas las comparaciones el orden es el correcto y por tanto no se realiza ningún intercambio: 
[[Image:b7.gif|left|b7.gif]] 

Por lo tanto el coste de intercambios no depende de '''n''', y es constante: 
[[Image:b8.gif|left|b8.gif]] 

El ordenamiento de burbuja tiene una complejidad '''Ω(n²)''' igual que ordenamiento por selección. Cuando una lista ya está ordenada, a diferencia del ordenamiento por inserción, que pasará por la lista una vez y encontrará que no hay necesidad de intercambiar las posiciones de los elementos, el método de ordenación por burbuja está forzado a pasar por dichas comparaciones, lo que hace que su complejidad sea cuadrática en el mejor de los casos. Esto lo cataloga como el '''algoritmo más ineficiente''' que existe, aunque para muchos programadores sea el más sencillo de implementar.

== Aplicación ==

A pesar de que el ordenamiento de burbuja es uno de los algoritmos más sencillos de implementar, su orden '''O(n2)''' lo hace muy ineficiente para usar en listas que tengan más que un número reducido de elementos. Incluso entre los algoritmos de ordenamiento de orden '''O(n2)''', otros procedimientos como el ordenamiento por inserción son considerados más eficientes.
Dada su simplicidad, el ordenamiento de burbuja es utilizado para introducir el concepto de algoritmo de ordenamiento para estudiantes de ciencias de la computación. A pesar de esto, algunos investigadores como Owen Astrachan han criticado su popularidad en la enseñanza de ciencias de la computación, llegando a recomendar su eliminación de los planes de estudio.
Sumado a esto, Jargon File, un libro ampliamente citado en la cultura hacker, lo denomina "el mal algoritmo genérico", y Donald Knuth, uno de los mayores expertos en ciencias de la computación, afirma que el ordenamiento de burbuja "no parece tener nada para recomendar su uso, a excepción de un nombre pegajoso y el hecho de que conlleva a problemas teóricos interesantes".
El ordenamiento de burbuja es asintóticamente equivalente, en tiempos de ejecución, con el ordenamiento por inserción en el peor de los casos, pero ambos algoritmos difieren principalmente en la cantidad de intercambios que son necesarios. Resultados experimentales como los descubiertos por Astrachan han demostrado que el ordenamiento por inserción funciona considerablemente mejor incluso con listas aleatorias. Por esta razón, muchos libros de algoritmos modernos evitan usar el ordenamiento de burbuja, reemplazándolo por el ordenamiento por inserción.
El ordenamiento de burbuja interactúa vagamente con el hardware de las CPU modernas. Requiere al menos el doble de escrituras que el ordenamiento por inserción, el doble de pérdidas de cache, y asintóticamente más predicción de saltos. Varios experimentos de ordenamiento de cadenas en Java hechos por Astrachan muestran que el ordenamiento de burbuja es 5 veces más lento que el ordenamiento por inserción, y 40% más lento que el ordenamiento por selección.

== Implementación==

A continuación se muestra el Ordenamiento de burbuja en algunos de los lenguajes de programación más usados:
*C 
//Ordenamiento por método de la Burbuja
void ordenamientoBurbuja(int v[], int util_v) {
int temp, i, j;

for (i = 0; i < util_v -1 ; i++) {
for (j = i + 1; j < util_v ; j++) {
if (v[i] > v[j]) {
temp = v[i];
v[i] = v[j];
v[j] = temp;
}
}
} }
*C++ 
template<typename _Ty>
void bubble_sort(vector<_Ty> & v){

for (size_t i = 0; i < v.size() - 1; ++i){
for (size_t j = i + 1; j < v.size(); ++j){
if (v[i] > v[j])
swap(v[i], v[j]);
}
}
}
*C#
Public int[] OrdenarBurbuja(int[]x)
{
int t= x.Length, temp;
for(int i=1 ; i< t ; i++)
for(int j = t-1 ; j >= i; j--)
{
if(x[j] < x[j-1])
{
temp= x[j];
x[j]= x[j-1];
x[j-1]= temp;
}
}
return x;
}
*Java
//Ordenamiento por Burbuja
// by ramses2999
publicstatic int[] OrdenarBurbuja(int[] n){
int temp;
int t = n.length;
for (int i = 1; i < t; i++) {
for (int k = t- 1; k >= i; k--) {
if(n[k] < n[k-1]){
temp = n[k];
n[k] = n[k-1];
n[k-1]= temp;
}//fin if
}// fin 2 for
}//fin 1 for
return n;
}//fin
*Perl
sub bubblesort {
# Ordena la lista pasada como argumento por valor
for my $i ( 0 .. @_-2 ) {
for my $j ( $i+1 .. @_-1 ) {
@_[ $i, $j ] = @_[ $j, $i ] if $_[$i] > $_[$j];
}}
}
*Visual Basic
Private Sub OrdenarBurbuja(ByRef VectorOriginal() As Integer)
Dim Temp, Longitud As Integer
Longitud = UBound(VectorOriginal) - 2
For b = 0 To Longitud
For a = 0 To Longitud
If VectorOriginal(a) > VectorOriginal(a + 1) Then
Temp = VectorOriginal(a + 1)
VectorOriginal(a + 1) = VectorOriginal(a)
VectorOriginal(a) = Temp
EndIf
Next
Next
End Sub
*PHP
<?php

//Ordenamiento por burbuja
$numeros = array(9, 4, -1, 7, 8, 11, 6, 12, 10, 5);

$n = count($numeros);

for ($i = 1; $i<$n; $i++) {
for ($j = $n-1; $j >= $i; $j--) {
echo "i: $i, j: $j\n";
echo "Comparando " . $numeros[$j-1] . " y " . $numeros[$j] . "\n";
if ($numeros[$j-1] > $numeros[$j]) {
$aux = $numeros[$j];
$numeros[$j] = $numeros[$j-1];
$numeros[$j-1] = $aux;
}
}
}

print_r($numeros);
*Pascal
Procedure Burbuja(var lista:vector;size:integer);
var i,j:integer;

begin
for i:=1 to size-1 do
for j:=1 to size-i do
begin
if lista[j]>lista[j+1] then
begin
aux:=lista[j];
lista[j]:=lista[j+1];
lista[j+1]:=aux
end;
end;
end;

== Vease también ==

*Algoritmos de ordenamiento.

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_de_burbuja Wikipedia].

[[Category:Algoritmos]]

Ordenamiento de burbuja

2011-06-30T01:22:14Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Burbuja|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden}}'''[[Algoritmo de ordenamiento]]. Burbuja'''(Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas burbujas. También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.

== Descripción ==

El procedimiento de la burbuja es el siguiente:
§ Ir comparando desde la casilla 0 número tras número hasta encontrar uno mayor, si este es realmente el mayor de todo el vector se llevará hasta la última casilla, si no es así, será reemplazado por uno mayor que él.
§ Este procedimiento seguirá así hasta que haya ordenado todas las casillas del vector.
§ Una de las deficiencias del algoritmo es que ya cuando a ordenado parte del vector vuelve a compararlo cuando esto ya no es necesario.

Dado un vector a1, a2, a3, ... an
1) Comparar a1 con a2 e intercambiarlos si a1>a2 (o a12)
2) Seguir hasta que todo se haya comparado an-1 con an
3) Repetir el proceso anterior n-1 veces 
Algoritmo: Complejidad
for(i=0; i < n-++){ T(n2)
for(j=0; j < n-1; j++){ T(n)
if(vec[j] > vec[j+1]){ T(1)
aux=vec[j]; T(1)
vec[j]=vec[j+1]; T(1)
vec[j+1]=aux;} T(1)
} } 
El siguiente ejemplo muestra el proceso de forma gráfica: 

[[Image:Tabla burbuja.JPG|center|Tabla burbuja.JPG]]

== Análisis del Costo Computacional ==

Al algoritmo de la burbuja, para ordenar un vector de '''n''' términos, tiene que realizar siempre el mismo número de comparaciones: 
[[Image:b1.gif|left|b1.gif]] 
Esto es, el número de comparaciones '''c(n) ''' no depende del orden de los términos, si no del número de términos. 
[[Image:b2.gif|left|b2.gif]] 
 
Por lo tanto la cota ajustada asintótica del número de comparaciones pertenece al orden de '''n''' cuadrado.
El numero de intercambios '''i(n)''', que hay que realizar depende del orden de los términos y podemos diferencia, el caso mejor, si el vector esta previamente ordenado, y el caso peor, si el vector esta ordenado en orden inverso.
 
[[Image:b3.gif|left|b3.gif]] 
Por lo que no se puede determinar una cota ajustada asintótica del número de intercambios, dado que este dependerá del orden del vector en cuestión. 
'''Rendimiento en el caso desfavorable''' 
Si pasamos al algoritmo un vector ordenado en orden inverso realizara un número de comparaciones: 
[[Image:b1.gif|left|b1.gif]] 
Como ya hemos dicho anteriormente, y tendrá que realizar un número igual de intercambios entre los términos del vector, dado que en cada comparación los términos estarán desordenados, y se realizará el intercambio. 
[[Image:b4.gif|left|b4.gif]] 
Por lo tanto en el caso más desfavorable tanto el número de comparaciones como el de intercambios coinciden: 
[[Image:b5.gif|left|b5.gif]] 

El número de comparaciones o de intercambios en el caso más desfavorable pertenece al orden de '''n''' cuadrado. 
'''Rendimiento en casos óptimos''' 
En el caso óptimo, el más favorable, es la ordenación que un vector ya ordenado, en este caso el número de comparaciones será el mismo que en cualquier otro caso: 
[[Image:b6.gif|left|b6.gif]] 

La cota inferior asintótica del número de comparaciones pertenece al orden de '''n''' cuadrado, como en los demás casos, pero en todas las comparaciones el orden es el correcto y por tanto no se realiza ningún intercambio: 
[[Image:b7.gif|left|b7.gif]] 

Por lo tanto el coste de intercambios no depende de '''n''', y es constante: 
[[Image:b8.gif|left|b8.gif]] 

El ordenamiento de burbuja tiene una complejidad '''Ω(n²)''' igual que ordenamiento por selección. Cuando una lista ya está ordenada, a diferencia del ordenamiento por inserción, que pasará por la lista una vez y encontrará que no hay necesidad de intercambiar las posiciones de los elementos, el método de ordenación por burbuja está forzado a pasar por dichas comparaciones, lo que hace que su complejidad sea cuadrática en el mejor de los casos. Esto lo cataloga como el '''algoritmo más ineficiente''' que existe, aunque para muchos programadores sea el más sencillo de implementar.

== Aplicación ==

A pesar de que el ordenamiento de burbuja es uno de los algoritmos más sencillos de implementar, su orden '''O(n2)''' lo hace muy ineficiente para usar en listas que tengan más que un número reducido de elementos. Incluso entre los algoritmos de ordenamiento de orden '''O(n2)''', otros procedimientos como el ordenamiento por inserción son considerados más eficientes.
Dada su simplicidad, el ordenamiento de burbuja es utilizado para introducir el concepto de algoritmo de ordenamiento para estudiantes de ciencias de la computación. A pesar de esto, algunos investigadores como Owen Astrachan han criticado su popularidad en la enseñanza de ciencias de la computación, llegando a recomendar su eliminación de los planes de estudio.
Sumado a esto, Jargon File, un libro ampliamente citado en la cultura hacker, lo denomina "el mal algoritmo genérico", y Donald Knuth, uno de los mayores expertos en ciencias de la computación, afirma que el ordenamiento de burbuja "no parece tener nada para recomendar su uso, a excepción de un nombre pegajoso y el hecho de que conlleva a problemas teóricos interesantes".
El ordenamiento de burbuja es asintóticamente equivalente, en tiempos de ejecución, con el ordenamiento por inserción en el peor de los casos, pero ambos algoritmos difieren principalmente en la cantidad de intercambios que son necesarios. Resultados experimentales como los descubiertos por Astrachan han demostrado que el ordenamiento por inserción funciona considerablemente mejor incluso con listas aleatorias. Por esta razón, muchos libros de algoritmos modernos evitan usar el ordenamiento de burbuja, reemplazándolo por el ordenamiento por inserción.
El ordenamiento de burbuja interactúa vagamente con el hardware de las CPU modernas. Requiere al menos el doble de escrituras que el ordenamiento por inserción, el doble de pérdidas de cache, y asintóticamente más predicción de saltos. Varios experimentos de ordenamiento de cadenas en Java hechos por Astrachan muestran que el ordenamiento de burbuja es 5 veces más lento que el ordenamiento por inserción, y 40% más lento que el ordenamiento por selección.

== Implementación==

A continuación se muestra el Ordenamiento de burbuja en algunos de los lenguajes de programación más usados:
*C 
//Ordenamiento por método de la Burbuja
void ordenamientoBurbuja(int v[], int util_v) {
int temp, i, j;

for (i = 0; i < util_v -1 ; i++) {
for (j = i + 1; j < util_v ; j++) {
if (v[i] > v[j]) {
temp = v[i];
v[i] = v[j];
v[j] = temp;
}
}
} }
*C++ 
template<typename _Ty>
void bubble_sort(vector<_Ty> & v){

for (size_t i = 0; i < v.size() - 1; ++i){
for (size_t j = i + 1; j < v.size(); ++j){
if (v[i] > v[j])
swap(v[i], v[j]);
}
}
}
*C#
Public int[] OrdenarBurbuja(int[]x)
{
int t= x.Length, temp;
for(int i=1 ; i< t ; i++)
for(int j = t-1 ; j >= i; j--)
{
if(x[j] < x[j-1])
{
temp= x[j];
x[j]= x[j-1];
x[j-1]= temp;
}
}
return x;
}
*Java
//Ordenamiento por Burbuja
// by ramses2999
publicstatic int[] OrdenarBurbuja(int[] n){
int temp;
int t = n.length;
for (int i = 1; i < t; i++) {
for (int k = t- 1; k >= i; k--) {
if(n[k] < n[k-1]){
temp = n[k];
n[k] = n[k-1];
n[k-1]= temp;
}//fin if
}// fin 2 for
}//fin 1 for
return n;
}//fin
*Perl
sub bubblesort {
# Ordena la lista pasada como argumento por valor
for my $i ( 0 .. @_-2 ) {
for my $j ( $i+1 .. @_-1 ) {
@_[ $i, $j ] = @_[ $j, $i ] if $_[$i] > $_[$j];
}}
}
*Visual Basic
Private Sub OrdenarBurbuja(ByRef VectorOriginal() As Integer)
Dim Temp, Longitud As Integer
Longitud = UBound(VectorOriginal) - 2
For b = 0 To Longitud
For a = 0 To Longitud
If VectorOriginal(a) > VectorOriginal(a + 1) Then
Temp = VectorOriginal(a + 1)
VectorOriginal(a + 1) = VectorOriginal(a)
VectorOriginal(a) = Temp
EndIf
Next
Next
End Sub
*PHP
<?php

//Ordenamiento por burbuja
$numeros = array(9, 4, -1, 7, 8, 11, 6, 12, 10, 5);

$n = count($numeros);

for ($i = 1; $i<$n; $i++) {
for ($j = $n-1; $j >= $i; $j--) {
echo "i: $i, j: $j\n";
echo "Comparando " . $numeros[$j-1] . " y " . $numeros[$j] . "\n";
if ($numeros[$j-1] > $numeros[$j]) {
$aux = $numeros[$j];
$numeros[$j] = $numeros[$j-1];
$numeros[$j-1] = $aux;
}
}
}

print_r($numeros);
*Pascal
Procedure Burbuja(var lista:vector;size:integer);
var i,j:integer;

begin
for i:=1 to size-1 do
for j:=1 to size-i do
begin
if lista[j]>lista[j+1] then
begin
aux:=lista[j];
lista[j]:=lista[j+1];
lista[j+1]:=aux
end;
end;
end;

== Vease también ==

*Algoritmos de ordenamiento.

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_de_burbuja Wikipedia].

[[Category:Algoritmos]]

Ordenamiento de burbuja

2011-06-30T01:20:55Z

Manuel jc.manzanillo1:

{{Definición|Nombre=Algoritmo de ordenamiento. Burbuja|imagen=Sorting_quicksort_.JPG|concepto=Algoritmo que pone elementos de una lista o un vector, en una secuencia dada por una relación de orden}}'''[[Algoritmo de ordenamiento]]. Burbuja'''(Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas burbujas. También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.

== Descripción ==

El procedimiento de la burbuja es el siguiente:
§ Ir comparando desde la casilla 0 número tras número hasta encontrar uno mayor, si este es realmente el mayor de todo el vector se llevará hasta la última casilla, si no es así, será reemplazado por uno mayor que él.
§ Este procedimiento seguirá así hasta que haya ordenado todas las casillas del vector.
§ Una de las deficiencias del algoritmo es que ya cuando a ordenado parte del vector vuelve a compararlo cuando esto ya no es necesario.

Dado un vector a1, a2, a3, ... an
1) Comparar a1 con a2 e intercambiarlos si a1>a2 (o a12)
2) Seguir hasta que todo se haya comparado an-1 con an
3) Repetir el proceso anterior n-1 veces 
Algoritmo: Complejidad
for(i=0; i < n-++){ T(n2)
for(j=0; j < n-1; j++){ T(n)
if(vec[j] > vec[j+1]){ T(1)
aux=vec[j]; T(1)
vec[j]=vec[j+1]; T(1)
vec[j+1]=aux;} T(1)
} } 
El siguiente ejemplo muestra el proceso de forma gráfica: 

[[Image:Tabla burbuja.JPG|center|Tabla burbuja.JPG]]

== Análisis del Costo Computacional ==

Al algoritmo de la burbuja, para ordenar un vector de '''n''' términos, tiene que realizar siempre el mismo número de comparaciones: 
[[Image:b1.gif|left|b1.gif]] 
Esto es, el número de comparaciones '''c(n) ''' no depende del orden de los términos, si no del número de términos. 
[[Image:b2.gif|left|b2.gif]] 

Por lo tanto la cota ajustada asintótica del número de comparaciones pertenece al orden de '''n''' cuadrado.
El numero de intercambios '''i(n)''', que hay que realizar depende del orden de los términos y podemos diferencia, el caso mejor, si el vector esta previamente ordenado, y el caso peor, si el vector esta ordenado en orden inverso.
 
[[Image:b3.gif|left|b3.gif]] 
Por lo que no se puede determinar una cota ajustada asintótica del número de intercambios, dado que este dependerá del orden del vector en cuestión. 
'''Rendimiento en el caso desfavorable''' 
Si pasamos al algoritmo un vector ordenado en orden inverso realizara un número de comparaciones: 
[[Image:b1.gif|left|b1.gif]] 
Como ya hemos dicho anteriormente, y tendrá que realizar un número igual de intercambios entre los términos del vector, dado que en cada comparación los términos estarán desordenados, y se realizará el intercambio. 
[[Image:b4.gif|left|b4.gif]] 
Por lo tanto en el caso más desfavorable tanto el número de comparaciones como el de intercambios coinciden: 
[[Image:b5.gif|left|b5.gif]] 

El número de comparaciones o de intercambios en el caso más desfavorable pertenece al orden de '''n''' cuadrado. 
'''Rendimiento en casos óptimos''' 
En el caso óptimo, el más favorable, es la ordenación que un vector ya ordenado, en este caso el número de comparaciones será el mismo que en cualquier otro caso: 
[[Image:b6.gif|left|b6.gif]] 

La cota inferior asintótica del número de comparaciones pertenece al orden de '''n''' cuadrado, como en los demás casos, pero en todas las comparaciones el orden es el correcto y por tanto no se realiza ningún intercambio: 
[[Image:b7.gif|left|b7.gif]] 

Por lo tanto el coste de intercambios no depende de '''n''', y es constante: 
[[Image:b8.gif|left|b8.gif]] 

El ordenamiento de burbuja tiene una complejidad '''Ω(n²)''' igual que ordenamiento por selección. Cuando una lista ya está ordenada, a diferencia del ordenamiento por inserción, que pasará por la lista una vez y encontrará que no hay necesidad de intercambiar las posiciones de los elementos, el método de ordenación por burbuja está forzado a pasar por dichas comparaciones, lo que hace que su complejidad sea cuadrática en el mejor de los casos. Esto lo cataloga como el '''algoritmo más ineficiente''' que existe, aunque para muchos programadores sea el más sencillo de implementar.

== Aplicación ==

A pesar de que el ordenamiento de burbuja es uno de los algoritmos más sencillos de implementar, su orden '''O(n2)''' lo hace muy ineficiente para usar en listas que tengan más que un número reducido de elementos. Incluso entre los algoritmos de ordenamiento de orden '''O(n2)''', otros procedimientos como el ordenamiento por inserción son considerados más eficientes.
Dada su simplicidad, el ordenamiento de burbuja es utilizado para introducir el concepto de algoritmo de ordenamiento para estudiantes de ciencias de la computación. A pesar de esto, algunos investigadores como Owen Astrachan han criticado su popularidad en la enseñanza de ciencias de la computación, llegando a recomendar su eliminación de los planes de estudio.
Sumado a esto, Jargon File, un libro ampliamente citado en la cultura hacker, lo denomina "el mal algoritmo genérico", y Donald Knuth, uno de los mayores expertos en ciencias de la computación, afirma que el ordenamiento de burbuja "no parece tener nada para recomendar su uso, a excepción de un nombre pegajoso y el hecho de que conlleva a problemas teóricos interesantes".
El ordenamiento de burbuja es asintóticamente equivalente, en tiempos de ejecución, con el ordenamiento por inserción en el peor de los casos, pero ambos algoritmos difieren principalmente en la cantidad de intercambios que son necesarios. Resultados experimentales como los descubiertos por Astrachan han demostrado que el ordenamiento por inserción funciona considerablemente mejor incluso con listas aleatorias. Por esta razón, muchos libros de algoritmos modernos evitan usar el ordenamiento de burbuja, reemplazándolo por el ordenamiento por inserción.
El ordenamiento de burbuja interactúa vagamente con el hardware de las CPU modernas. Requiere al menos el doble de escrituras que el ordenamiento por inserción, el doble de pérdidas de cache, y asintóticamente más predicción de saltos. Varios experimentos de ordenamiento de cadenas en Java hechos por Astrachan muestran que el ordenamiento de burbuja es 5 veces más lento que el ordenamiento por inserción, y 40% más lento que el ordenamiento por selección.

== Implementación==

A continuación se muestra el Ordenamiento de burbuja en algunos de los lenguajes de programación más usados:
*C 
//Ordenamiento por método de la Burbuja
void ordenamientoBurbuja(int v[], int util_v) {
int temp, i, j;

for (i = 0; i < util_v -1 ; i++) {
for (j = i + 1; j < util_v ; j++) {
if (v[i] > v[j]) {
temp = v[i];
v[i] = v[j];
v[j] = temp;
}
}
} }
*C++ 
template<typename _Ty>
void bubble_sort(vector<_Ty> & v){

for (size_t i = 0; i < v.size() - 1; ++i){
for (size_t j = i + 1; j < v.size(); ++j){
if (v[i] > v[j])
swap(v[i], v[j]);
}
}
}
*C#
Public int[] OrdenarBurbuja(int[]x)
{
int t= x.Length, temp;
for(int i=1 ; i< t ; i++)
for(int j = t-1 ; j >= i; j--)
{
if(x[j] < x[j-1])
{
temp= x[j];
x[j]= x[j-1];
x[j-1]= temp;
}
}
return x;
}
*Java
//Ordenamiento por Burbuja
// by ramses2999
publicstatic int[] OrdenarBurbuja(int[] n){
int temp;
int t = n.length;
for (int i = 1; i < t; i++) {
for (int k = t- 1; k >= i; k--) {
if(n[k] < n[k-1]){
temp = n[k];
n[k] = n[k-1];
n[k-1]= temp;
}//fin if
}// fin 2 for
}//fin 1 for
return n;
}//fin
*Perl
sub bubblesort {
# Ordena la lista pasada como argumento por valor
for my $i ( 0 .. @_-2 ) {
for my $j ( $i+1 .. @_-1 ) {
@_[ $i, $j ] = @_[ $j, $i ] if $_[$i] > $_[$j];
}}
}
*Visual Basic
Private Sub OrdenarBurbuja(ByRef VectorOriginal() As Integer)
Dim Temp, Longitud As Integer
Longitud = UBound(VectorOriginal) - 2
For b = 0 To Longitud
For a = 0 To Longitud
If VectorOriginal(a) > VectorOriginal(a + 1) Then
Temp = VectorOriginal(a + 1)
VectorOriginal(a + 1) = VectorOriginal(a)
VectorOriginal(a) = Temp
EndIf
Next
Next
End Sub
*PHP
<?php

//Ordenamiento por burbuja
$numeros = array(9, 4, -1, 7, 8, 11, 6, 12, 10, 5);

$n = count($numeros);

for ($i = 1; $i<$n; $i++) {
for ($j = $n-1; $j >= $i; $j--) {
echo "i: $i, j: $j\n";
echo "Comparando " . $numeros[$j-1] . " y " . $numeros[$j] . "\n";
if ($numeros[$j-1] > $numeros[$j]) {
$aux = $numeros[$j];
$numeros[$j] = $numeros[$j-1];
$numeros[$j-1] = $aux;
}
}
}

print_r($numeros);
*Pascal
Procedure Burbuja(var lista:vector;size:integer);
var i,j:integer;

begin
for i:=1 to size-1 do
for j:=1 to size-i do
begin
if lista[j]>lista[j+1] then
begin
aux:=lista[j];
lista[j]:=lista[j+1];
lista[j+1]:=aux
end;
end;
end;

== Vease también ==

*Algoritmos de ordenamiento.

== Fuentes ==

*Aprenda C/C++.
*Estructuras de datos.
*[http://es.wikipedia.org/wiki/Ordenamiento_de_burbuja Wikipedia].

[[Category:Algoritmos]]

Archivo:B8.gif

2011-06-30T01:20:33Z

Manuel jc.manzanillo1:

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Archivo:B7.gif

2011-06-30T01:19:52Z

Manuel jc.manzanillo1:

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Archivo:B6.gif

2011-06-30T01:18:43Z

Manuel jc.manzanillo1:

== Sumario ==

== Estado de copyright: ==

== Fuente: ==

Archivo:B5.gif

2011-06-30T01:17:20Z

Manuel jc.manzanillo1: