Recursos

Bibliografía 📚

Estructuras de datos y algoritmos

• Wirth, N. Algoritmos y Estructuras de Datos. Prentice-Hall, 1987.
• Weiss, M. A. Estructuras de Datos y Algoritmos. Addison-Wesley Iberoamericana, 1995.
• Aho, A. V., J. E. Hopcroft y J. D. Ullman. Estructuras de Datos y Algoritmos. Addison-Wesley Iberoamericana, 1988.
• Karumanchi, N. Data Structures and Algorithms Made Easy.

Lenguaje de programación C

• Kernighan, B. W. y D. M. Ritchie. El lenguaje de programación C. Prentice-Hall, 1991.
• Deitel, H. M. y P. J. Deitel. Cómo programar en C/C++. Prentice-Hall, 1998.

Recursos adicionales

Puente entre PP y EDA

• 📘 Punteros 101
  • Manual breve de apoyo sobre direcciones, punteros, arrays, struct y memoria dinámica
  • Pensado como puente entre el final de PP y el arranque de EDA

Herramientas

• ZinjaI: link
  • IDE libre y gratuito para programar en C/C++
  • Interfaz simple para empezar y soporte suficiente para trabajar con programas de más de un archivo
  • Disponible para Linux, Windows y Mac OS X
• Compilador Online C: link
  • Solo para compilar y ejecutar código en tiempo real
  • No permite trabajar con múltiples archivos
• Visualizar ejecución: link
  • Útil para ver el comportamiento de punteros, referencias y memoria dinámica
• Visualización de algoritmos: link
  • Útil para visualizar algoritmos de ordenamiento y comparación de costos

Material de apoyo

• Manual de C del curso: link
• OpenFing Programación 2: link
• EVA Programación 2: link

Tipos Abstractos de Datos (TADs)

Archivos de cabecera con ejercicios y prototipos de funciones para implementar. Se mantiene la nomenclatura original de cada interfaz aunque algunos nombres estén en inglés, para que el sitio, los ejercicios y los archivos provistos coincidan.

• 📝 Lista Enlazada Simple
  linked_list.h Descargar

  #ifndef LINKED_LIST_H
    #define LINKED_LIST_H
    
    #include <stdbool.h>
    
    typedef struct _list_node {
      int data;
      struct _list_node *next;
    } ListNode;
    
    ListNode *create_list_node(int data);
    
    bool search(ListNode *head, int data);
    int size_list(ListNode *head);
    void print_list(ListNode *head);
    void destroy_list(ListNode *head);
    
    ListNode *insert_front(ListNode *head, int data);
    ListNode *insert_back(ListNode *head, int data);
    ListNode *insert_at(ListNode *head, int position, int data);
    
    ListNode *delete_value(ListNode *head, int data);
    ListNode *delete_at(ListNode *head, int position);
    
    bool search_rec(ListNode *head, int data);
    int size_list_rec(ListNode *head);
    void print_list_rec(ListNode *head);
    void print_list_inverso_rec(ListNode *head);
    void destroy_list_rec(ListNode *head);
    
    ListNode *insert_back_rec(ListNode *head, int data);
    ListNode *insert_at_rec(ListNode *head, int position, int data);
    ListNode *delete_value_rec(ListNode *head, int data);
    
    ListNode *invert_list_rec(ListNode *head);
    bool compare_lists_rec(ListNode *l1, ListNode *l2);
    
    #endif
    

• 📝 Variantes de Listas Enlazadas
  dlist.h Descargar

  #ifndef DLIST_H
    #define DLIST_H
    
    #include <stdbool.h>
    
    typedef struct _dlist_node {
      int data;
      struct _dlist_node *prev;
      struct _dlist_node *next;
    } DListNode;
    
    typedef struct {
      DListNode *head;
      DListNode *tail;
    } DList;
    
    DList *dlist_create(void);
    void dlist_destroy(DList *list);
    
    DListNode *dlist_create_node(int data);
    
    bool dlist_insert_front(DList *list, int data);
    bool dlist_insert_back(DList *list, int data);
    bool dlist_insert_at(DList *list, int position, int data);
    
    bool dlist_delete_value(DList *list, int data);
    bool dlist_delete_node(DList *list, DListNode *node);
    bool dlist_delete_at(DList *list, int position);
    
    bool dlist_search(DList *list, int data);
    int dlist_size(DList *list);
    
    void dlist_print_forward(DList *list);
    void dlist_print_backward(DList *list);
    
    DList *dlist_invert(DList *list);
    bool dlist_compare(DList *l1, DList *l2);
    
    /* Circular doubly linked list */
    DList *cdlist_create(int data);
    bool cdlist_insert_front(DList *list, int data);
    bool cdlist_insert_back(DList *list, int data);
    bool cdlist_delete_value(DList *list, int data);
    bool cdlist_search(DList *list, int data);
    int cdlist_size(DList *list);
    void cdlist_destroy(DList *list);
    void cdlist_print_forward(DList *list);
    void cdlist_print_backward(DList *list);
    
    #endif
    

• 📝 Pila (Stack)
  stack.h Descargar

  #ifndef STACK_H
    #define STACK_H
    
    #include <stdbool.h>
    
    typedef struct _stack_node {
      int data;
      struct _stack_node *next;
    } StackNode;
    
    StackNode *create_stack_node(int data);
    
    StackNode *push(StackNode *top, int data);
    StackNode *pop(StackNode *top, int *data);
    
    bool peek_stack(StackNode *top, int *data);
    bool is_empty_stack(StackNode *top);
    
    int size_stack(StackNode *top);
    int size_stack_rec(StackNode *top);
    
    void destroy_stack(StackNode *top);
    void destroy_stack_rec(StackNode *top);
    
    void print_stack(StackNode *top);
    void print_stack_rec(StackNode *top);
    void print_stack_inverso_rec(StackNode *top);
    
    StackNode *invert_stack_rec(StackNode *top);
    
    #endif
    

• 📝 Cola (Queue)
  queue.h Descargar

  #ifndef QUEUE_H
    #define QUEUE_H
    
    #include <stdbool.h>
    
    typedef struct _queue_node {
      int data;
      struct _queue_node *next;
    } QueueNode;
    
    typedef struct {
      QueueNode *front;
      QueueNode *rear;
    } Queue;
    
    Queue *queue_create(void);
    void queue_destroy(Queue *q);
    
    bool queue_enqueue(Queue *q, int data);
    bool queue_dequeue(Queue *q, int *data);
    
    bool queue_front(Queue *q, int *data);
    bool queue_is_empty(Queue *q);
    int queue_size(Queue *q);
    
    void queue_print(Queue *q);
    
    #endif
    

• 📝 Árbol Binario (incluye BST)
  binary_tree.h Descargar

  #ifndef BINARY_TREE_H
    #define BINARY_TREE_H
    
    #include <stdbool.h>
    
    typedef struct _tree_node {
      int data;
      struct _tree_node *left;
      struct _tree_node *right;
    } TreeNode;
    
    TreeNode *create_tree_node(int data);
    
    void preorder(TreeNode *root);
    void inorder(TreeNode *root);
    void postorder(TreeNode *root);
    void level_order(TreeNode *root);
    
    int size_tree(TreeNode *root);
    int height_tree(TreeNode *root);
    int count_leaves(TreeNode *root);
    
    bool is_empty_tree(TreeNode *root);
    bool is_leaf(TreeNode *node);
    
    bool attach_left(TreeNode *parent, int data);
    bool attach_right(TreeNode *parent, int data);
    
    void destroy_tree(TreeNode *root);
    
    TreeNode *mirror_tree(TreeNode *root);
    
    TreeNode *bst_insert(TreeNode *root, int data);
    bool bst_search(TreeNode *root, int data);
    TreeNode *bst_delete(TreeNode *root, int data);
    TreeNode *bst_find_min(TreeNode *root);
    TreeNode *bst_find_max(TreeNode *root);
    
    #endif
    

• 📝 Heap (Montículo)
  heap.h Descargar

  #ifndef HEAP_H
    #define HEAP_H
    
    #include <stdbool.h>
    
    #define MAX_HEAP 100
    
    typedef struct heap {
      int datos[MAX_HEAP];
      int tamano;
      int tipo;
    } heap_t;
    
    heap_t *heap_crear(int tipo);
    
    int heap_insertar(heap_t *heap, int elemento);
    
    int heap_extraer_min(heap_t *heap);
    int heap_extraer_max(heap_t *heap);
    
    int heap_minimo(heap_t *heap);
    int heap_maximo(heap_t *heap);
    bool heap_vacio(heap_t *heap);
    
    int heap_tamano(heap_t *heap);
    
    void heapify_up(heap_t *heap, int indice);
    void heapify_down(heap_t *heap, int indice);
    void heap_intercambiar(heap_t *heap, int i, int j);
    
    int heap_construir(heap_t *heap, int *array, int n);
    
    void heapsort(int *array, int n);
    
    void heap_destruir(heap_t *heap);
    
    void heap_imprimir(heap_t *heap);
    
    #endif
    

Material adicional

• 📄 Ejercicios extra
• 📄 Soluciones de ejercicios extra

Obligatorios

• 📄 Manejador de versiones
• 📄 Manejador de versiones - Parte 1
• 📄 Manejador de versiones - Parte 2