数据结构之——链表

闲来无事温习一下基本的数据结构，一个简单的单链表实现

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

//#define LIST_DEBUG


typedef struct _int_list {
    struct _int_list *next;
    int item;
} int_list_node_t;

int_list_node_t *int_list_create(void) {
    int_list_node_t *node;
    node = calloc(1, sizeof(int_list_node_t));
    if (NULL == node) {
        return NULL;
    }

    node->next = NULL;

    return node;
}

void int_list_print(int_list_node_t *head) {

    int_list_node_t *node;
    int_list_node_t *node_pre;
    node     = head->next;
    node_pre = head;
    if (NULL == node) {
        printf("empty list\n");
    }
    while(node) {
        printf("node: %p, node->next: %p, value: %d\n", node, node->next, node->item);
        node_pre = node;
        node     = node->next;
    }
    printf("\n");
}

int int_list_add(int_list_node_t *head, int value) {

    int_list_node_t *node;
    node = calloc(1, sizeof(int_list_node_t));
    if (NULL == node) {
        return -ENOMEM;
    }
    node->item = value;

    int_list_node_t *node1;
    node1 = head->next;
    head->next = node;
    node->next = node1;

    return 0;
}

int int_list_delete(int_list_node_t *head, int value) {

    int_list_node_t *node;
    int_list_node_t *node_pre;
    node     = head->next;
    node_pre = head;
    while(node) {
        if (node->item == value) {
            node_pre->next = node->next;
            free(node);
            return 0;
        } else {
            node_pre = node;
            node     = node->next;
        }
    }

    return -1;
}

int int_list_delete_1(int_list_node_t *head, int value) {

    if (NULL == head || NULL == head->next) {
        return -1;
    }

    int_list_node_t **pp = &head->next;
    int_list_node_t *entry = head->next;
#ifdef LIST_DEBUG
    int_list_node_t *entry_pre = head;
    fprintf(stdout, "\nInitial status:\n");
    fprintf(stdout, "pp point to head %p's next\n"
                    "and *pp is : %p\n", entry_pre, *pp);
    fprintf(stdout, "To process node@%p whit value: %d\n", entry, entry->item);
#endif
    while(entry) {
        if(entry->item == value) {
            *pp = entry->next;
#ifdef LIST_DEBUG
    fprintf(stdout, "\nTarget found:"
                    "\nchange node %p's next field to node@%p\n\n",
                    entry_pre, *pp);
#endif
            free(entry);
            return 0;
        }

#ifdef LIST_DEBUG
        entry_pre = entry;
#endif
        pp = &entry->next;
        entry = entry->next;
#ifdef LIST_DEBUG
    fprintf(stdout, "\nStatus changed, pp is updated:\n");
    fprintf(stdout, "pp point to node %p's next field\n"
                    "now *pp is : %p\n", entry_pre, *pp);
    fprintf(stdout, "To process node@%p whit value: %d\n", entry, entry->item);
#endif
    }

    return 0;
}

int_list_node_t* int_list_from_array(int array[], int n) {
    int_list_node_t *node;
    node = int_list_create();
    if (NULL == node) {
        return NULL;
    }

    int i;
    for (i = 0; i < n; i++) {
        int_list_add(node, array[i]);
    }

    return node;
}

int_list_node_t* int_list_from_cmd_line(int argc, char *argv[]) {
    int_list_node_t *node;
    node = int_list_create();
    if (NULL == node) {
        return NULL;
    }

    int i;
    for (i = 0; i < argc; i++) {
        int_list_add(node, strtol(argv[i], NULL, 0));
    }

    return node;
}

void int_list_reverse(int_list_node_t *head) {
    int_list_node_t *node;
    int_list_node_t *node_next;
    int_list_node_t *node_tmp;
    node      = head->next;
    node_next = node ? node->next : NULL;
    if (NULL == node) {
        return;
    }

    while(node && node_next) {
        node_tmp  = node_next->next;
        node_next->next = node;
        node     = node_next;
        node_next = node_tmp;
    }

    //The old first element will be the last
    head->next->next = NULL;
    //set the new first element
    head->next = node;

}

void int_list_reverse_1(int_list_node_t *head) {
    int_list_node_t *node_cur = head->next;
    int_list_node_t *node_pre = NULL;
    int_list_node_t *node_next;

    if (NULL == node_cur) {
        return;
    }

    for(;
        node_cur;
        node_next = node_cur->next, node_cur->next = node_pre,
        node_pre = node_cur, node_cur = node_next);

    head->next = node_pre;
}

int main(int argc, char *argv[])
{
    int_list_node_t *head;
    if (argc > 1) {
        head = int_list_from_cmd_line(argc - 1, &argv[1]);
    } else {
        int array[] = { 1, 2, 3};
#define ARRAY_SIZE(a) (sizeof(a) /sizeof(a[0]))
        head = int_list_from_array(array, ARRAY_SIZE(array));
    }
    int_list_print(head);
    int_list_reverse_1(head);
    int_list_print(head);
    int_list_delete_1(head, 2);
    int_list_print(head);
    return 0;
}

没什么好说的，链表反转（逆序），在面试时总可以遇到，今天自己实现一下。

 

记得去年什么时候，大神linus说好多程序员不懂指针的指针，在进行链表操作时，不够简练。今天试着理解了一下，使用二级指针

来实现了链表的删除操作。