Visualizador Web de Estructuras de Datos

Aprende estructuras de datos con operaciones reales y visualización interactiva.

Laboratorio de algoritmos en C

Metodos de Ordenamiento

Visualizador didactico de algoritmos de ordenamiento sobre arreglos.

Abrir guía del método

1 Preparar

Máximo técnico: 80
Observa comparaciones, decisiones y cambios de estado.

2 Visualizar

Estrategia del método

Selecciona un algoritmo y prepara una entrada.

Leyenda: C comparación · I intercambio · P pivote · ✓ confirmado · A auxiliar

4 Relacionar con C

Codigo C: Intercambio directo

/**
 * @brief Verifica si un arreglo puede procesarse.
 *
 * @param arreglo Arreglo de enteros.
 * @param n Número de elementos del arreglo.
 * @return 1 si el arreglo es válido; 0 en caso contrario.
 */
static int arreglo_valido(const int arreglo[], size_t n) {
	return arreglo != NULL && n > 0;
}

/**
 * @brief Intercambia el contenido de dos variables enteras.
 *
 * @param a Puntero al primer entero.
 * @param b Puntero al segundo entero.
 */
static void intercambiar(int *a, int *b) {
	int temporal;
	if (a == NULL || b == NULL) return;
	temporal = *a;
	*a = *b;
	*b = temporal;
}

/**
 * @brief Ordena un arreglo usando el método de intercambio directo.
 *
 * @param arreglo Arreglo de enteros a ordenar.
 * @param n Número de elementos del arreglo.
 */
void ordenar_intercambio(int arreglo[], size_t n) {
	size_t i, j;
	if (!arreglo_valido(arreglo, n)) return;
	for (i = 0; i + 1 < n; ++i)
		for (j = i + 1; j < n; ++j)
			if (arreglo[i] > arreglo[j]) intercambiar(&arreglo[i], &arreglo[j]);
}

3 Comprender

Preparación

Selecciona datos y un algoritmo para comenzar.

La explicación de cada paso aparecerá aquí.

0 intentos · 0 aciertos

Variables C

NombreTipoValorSignificado
Sin frame activo.

Pila de llamadas

  1. Sin llamadas activas.

Ciclo actual

Sin ciclo activo.

Punteros y auxiliares

Sin punteros activos.

Actual: +0.00x (1.00x real)

Paso: 0/0

Usa Preparar, Reproducir o Siguiente.

Consola C (printf)

terminal

  


  
5 Reflexionar
Invariante del frame
Se mostrará al preparar la ejecución.
Métricas observadas en esta entrada
Todavía no hay ejecución.
Propiedades teóricas del método
Selecciona y ejecuta un algoritmo.
La complejidad teórica no se deduce de una única entrada.

    
Comparar dos algoritmos
Ambos reciben copias de una única entrada inmutable.
Algoritmo A
Algoritmo B
Una sola entrada permite observar diferencias, pero no demuestra por sí misma la complejidad general.

    
Pregunta guía
Arreglo lineal de enteros ordenado mediante metodos clasicos del TAD C. La simulacion resalta comparaciones, intercambios/movimientos, pivote, rangos y auxiliares.
Reproduce los ejemplos de mejor y peor caso desde la sección Preparar y contrasta las métricas.
Historial de ejecución
    Estructura del TAD
    #define ORDENAMIENTO_OK 1

#define ORDENAMIENTO_ERROR 0

void imprimir_arreglo(const int arreglo[], size_t n);
int copiar_arreglo(int destino[], const int origen[], size_t n);

void ordenar_intercambio(int arreglo[], size_t n);
void ordenar_seleccion(int arreglo[], size_t n);
void ordenar_insercion(int arreglo[], size_t n);
void ordenar_burbuja(int arreglo[], size_t n);
void ordenar_shell(int arreglo[], size_t n);
void ordenar_quicksort(int arreglo[], size_t n);
int  ordenar_mergesort(int arreglo[], size_t n);
void ordenar_heapsort(int arreglo[], size_t n);
int  ordenar_counting_sort(int arreglo[], size_t n);
int  ordenar_binsort(int arreglo[], size_t n);
int  ordenar_radixsort(int arreglo[], size_t n);

void probar_algoritmo_void(const char *nombre, void (*ordenar)(int[], size_t), const int base[], size_t n);
void probar_algoritmo_int(const char *nombre, int (*ordenar)(int[], size_t), const int base[], size_t n);