链表 c实现

linklist.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef int data_t;

typedef struct node{
    data_t data;
    struct node *next;
}NODE;

NODE *linklist_create();

int linklist_is_empty(NODE *head);
int linklist_is_full(NODE *head);

int linklist_length(NODE *head);
void linklist_clear(NODE *head);

int linklist_insert(NODE *head, data_t data, int offset);

int linklist_data_delete(NODE *head, data_t data);
int linklist_offset_delete(NODE *head, int offset);

int linklist_data_change(NODE *head, data_t old_data, data_t new_data);
int linklist_offset_change(NODE *head, data_t data, int offset);

int linklist_data_search(NODE *head, data_t data);
//NODE *linklist_data_search(NODE *head, data_t data);
data_t linklist_offset_search(NODE *head, int offset);

void linklist_show(NODE *head);
void linklist_destory(NODE **head);

void linklist_invert(NODE *head);

#endif

linklist.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <strings.h>

#include "linklist.h"

NODE *linklist_create()
{
    NODE *head = (NODE *)malloc(sizeof(NODE));
    if (NULL == head) {
        printf("malloc failed!
");
        return NULL;
    }
    bzero(head, sizeof(NODE));

    head->data = -1;
    head->next = NULL;

    return head;
}

int linklist_is_empty(NODE *head)
{
    /*
    if (NULL == head->next) {
        return 1;
    }
    return 0;
    */

    return head->next == NULL;
}

int linklist_is_full(NODE *head)
{
    return 0;
}

int linklist_length(NODE *head)
{
    NODE *p = head->next;
    int len = 0;

    while (NULL != p) {
        len++;
        p = p->next;
    }

    return len;
}

void linklist_clear(NODE *head)
{
    NODE *p = head->next;
    NODE *q = NULL;

    while (NULL != p)  {
        q = p->next;
        free(p);
        p = q;
    }

    head->next = NULL;
}

int linklist_insert(NODE *head, data_t data, int offset)
{
    /*判断插入的位置是否有效*/
    int len = linklist_length(head);
    if (0 > offset || offset > len) {
        printf("offset invalid!
");
        return -1;
    }

    /*给想要插入的元素开辟空间，并赋值*/
    NODE *p = (NODE *)malloc(sizeof(NODE));
    if (NULL == p) {
        printf("malloc failed!
");
        return -1;
    }
    bzero(p, sizeof(NODE));

    p->data = data;
    p->next = NULL;

    /*找到插入位置的前一个位置*/
    NODE *q = head;
    int i;
    for (i = 0; i < offset; i++) {
        q = q->next;
    }

    /*在找到的位置后面插入结点*/
    p->next = q->next;
    q->next = p;

    return 0;
}

int linklist_data_delete(NODE *head, data_t data)
{
    /*找到想要删除的元素的位置*/
    int offset = linklist_data_search(head, data);
    if (-1 == offset) {
        printf("search failed!
");
        return -1;
    }

    /*查找删除位置的前一个位置*/
    NODE *p = head;
    int i;
    for (i = 0; i < offset; i++) {
        p = p->next;
    }
#if 0
    NODE *p = head;
    while (NULL != p->next) {
        if (p->next->data == data) {
            break;
        }
        p = p->next;
    }
    if (p->next == NULL) {
        return -1;
    }
#endif

    /*让删除位置的前一个结点指向后一个结点的位置*/
    NODE *q = p->next;
    p->next = q->next;

    /*释放这个位置*/
    free(q);
    q = NULL;

    return 0;
}

int linklist_offset_delete(NODE *head, int offset)
{
    /*判断offset的值是否有效*/
    int len = linklist_length(head);
    if (0 > offset || offset > len-1) {
        printf("offset invalid!
");
        return -1;
    }

    /*查找删除位置的前一个位置*/
    NODE *p = head;
    int i;
    for (i = 0; i < offset; i++) {
        p = p->next;
    }

    /*让删除位置的前一个结点指向后一个结点的位置*/
    NODE *q = p->next;
    p->next = q->next;

    /*释放这个位置*/
    free(q);
    q = NULL;

    return 0;
}

int linklist_data_change(NODE *head, data_t old_data, data_t new_data)
{
    /*找到想要修改元素的位置*/
    int  offset = linklist_data_search(head, old_data);
    if (-1 == offset) {
        printf("search failed!
");
        return -1;
    }

    /*直接修改这个数据*/
    NODE *p = head->next;
    int i;
    for (i = 0; i < offset; i++) {
        p = p->next;
    }

    p->data = new_data;

    return 0;
}

int linklist_offset_change(NODE *head, data_t data, int offset)
{
    /*判断offset的值是否有效*/
    int len = linklist_length(head);
    if (0 > offset || offset > len-1) {
        printf("offset invalid!
");
        return -1;
    }
    
    /*直接修改这个数据*/
    NODE *p = head->next;
    int i;
    for (i = 0; i < offset; i++) {
        p = p->next;
    }

    p->data = data;

    return 0;
}

int linklist_data_search(NODE *head, data_t data)
{
    /*从第一个有效数据开始查找， 直到表结束，找到则返回查找到的位置*/
    NODE *p = head->next;
    int offset = 0;

    while (NULL != p) {
        if (data == p->data) {
            return offset;
        }
        offset++;
        p = p->next;
    }

    return -1;
}
/*
NODE *linklist_data_search(NODE *head, data_t data)
{
    从第一个有效数据开始查找， 直到表结束，找到则返回查找到的位置
    NODE *p = head->next;

    while (NULL != p) {
        if (data == p->data) {
            return p;
        }
        p = p->next;
    }

    return NULL;
}
*/
data_t linklist_offset_search(NODE *head, int offset)
{
    /*判断offset的值是否有效*/
    int len = linklist_length(head);
    if (0 > offset || offset > len-1) {
        printf("offset invalid!
");
        return -1;
    }

    /*找到这个位置，并返回这个位置的值*/
    NODE *p = head->next;
    int i;
    for (i = 0; i < offset; i++) {
        p = p->next;
    }

    return p->data;
}

void linklist_show(NODE *head)
{
    NODE *p = head->next;

    while (NULL != p) {
        printf("%d, ", p->data);
        p = p->next;
    }
    printf("
");
}

void linklist_destory(NODE **head)
{
    linklist_clear(*head);

    free(*head);
    *head = NULL;
}

void linklist_invert(NODE *head)
{
    NODE *p = head;
    NODE *q = head->next;
    p->next = NULL;//意思是第一个插入的元素的指针位已经是空了（因为头插法第一个插入的元素会变成最后一个元素。）

    NODE *t = NULL;

    while (NULL != q) {
        t = q->next;

        q->next = p->next;
        p->next = q;

        q = t;
    }
}

调用main.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <strings.h>

#include "linklist.h"

int main()
{
    NODE *head = linklist_create();

    if (NULL == head) {
        printf("create failed!
");
        return -1;
    }

    int n = 10;
    while (n--) {
        if (-1 == linklist_insert(head, n+1, 0)) {
            printf("insert failed!
");
            break;
        }
    }
    linklist_show(head);

    if (-1 == linklist_insert(head, 100, 10)) {
        printf("insert failed!
");
        return -1;
    }
    linklist_show(head);

    if (-1 == linklist_data_change(head, 10, 1000)) {
        printf("change data failed!
");
        return -1;
    }
    linklist_show(head);
    
    if (-1 == linklist_offset_change(head, 100, 0)) {
        printf("change offset failed!
");
        return -1;
    }
    linklist_show(head);
    
    if (-1 == linklist_data_delete(head, 100)) {
        printf("change data failed!
");
        return -1;
    }
    linklist_show(head);
    
    if (-1 == linklist_offset_delete(head, 0)) {
        printf("change offset failed!
");
        return -1;
    }
    linklist_show(head);

    linklist_invert(head);
    linklist_show(head);

    linklist_destory(&head);

    return 0;
}