基于 ADT 链表数据结构实现的C语言版 LinkList.

C代码

typedefstruct_link_list{

inttheSize;

intmodCount;

struct_node *node;

struct_node *beginMarker;

struct_node *endMarker;

} link_list;

struct_node{

void*data;

struct_node *prev;

struct_node *next;

};

externlink_list* create_link_list(void);

externvoidlink_add(link_list *link,void*data);

externvoid* link_get(link_list *link,intindex);

externvoidlink_set(link_list *link,intindex,void*data);

externintlink_size(link_list *link);

externvoidlink_remove(link_list *link,intindex);

externvoidlink_destory(link_list *link);

typedef struct _link_list{

int theSize;

int modCount;

struct _node *node;

struct _node *beginMarker;

struct _node *endMarker;

} link_list;

struct _node{

void *data;

struct _node *prev;

struct _node *next;

};

extern link_list* create_link_list(void);

extern void link_add(link_list *link, void *data);

extern void* link_get(link_list *link, int index);

extern void link_set(link_list *link, int index, void *data);

extern int link_size(link_list *link);

extern void link_remove(link_list *link, int index);

extern void link_destory(link_list *link);

C代码

// link_list.c

// author denger

#include "../../include/common.h"

#include "../../include/link_list.h"

#define MALLOC_ERROR "Failed to allocate menory space!"

link_list* create_link_list(void){

link_list *list = (link_list*)malloc(sizeof(link_list));

if(list == NULL){

puts(MALLOC_ERROR);

returnNULL;

}

list->theSize = 0;

list->node = (struct_node*)malloc(sizeof(struct_node));

if(list->node != NULL){

list->node->data = NULL;

list->node->next = list->node->prev = NULL;// Initialize pointer NULL

list->endMarker = list->beginMarker = list->node;

}else{

puts(MALLOC_ERROR);

returnNULL;

}

returnlist;

}

// Add any type to link_list.

voidlink_add(link_list *list,void*data){

struct_node* node = (struct_node*)malloc(sizeof(struct_node));

if(node == NULL){

puts(MALLOC_ERROR);

}else{

node->prev = list->node;

list->endMarker = list->node = list->node->next = node;

node->data = data;

list->theSize++;

}

}

// Getter a node in link_list.

struct_node* _link_get_node(link_list *list,intindex){

if(index >= list->theSize || index

printf("List index out of bounds : %d\n", list->theSize);

returnNULL;

}

inti;

struct_node *node;

if(index

node = list->beginMarker->next;

for(i = 0; i

node = node->next;

}

}else{

node = list->endMarker;

intmax = link_size(list) - index - 1;

for(i = 0; i

node = node->prev;

}

}

returnnode;

}

void* link_get(link_list *list,intindex){

struct_node *node = _link_get_node(list, index);

if(node == NULL){

returnNULL;

}

returnnode->data;

}

// return the link list size.

intlink_size(link_list *list){

returnlist->theSize;

}

// replace node.

voidlink_set(link_list *list,intindex,void*data){

struct_node *node = _link_get_node(list, index);

if(node != NULL){

node->data = data;

}

}

// remove node.

voidlink_remove(link_list *list,intindex){

struct_node *node = _link_get_node(list, index);

if(node == NULL){

return;

}

node->prev->next = node->next;

node->next->prev = node->prev;

if(node != NULL){

if(node->data != NULL){

free(node->data);

}

free(node);

node = NULL;

}

list->theSize--;

}

// destory link

voidlink_destory(link_list *list){

inti = 0;

struct_node *node = list->beginMarker;

for(i = 0; i <= list->theSize; i++){

struct_node *next = node->next;

if(node != NULL){

if(node->data != NULL){

free(node->data);

}

free(node);

node = next;

}

}

free(list);

list = NULL;

}

// link_list.c

// author denger

#include "../../include/common.h"

#include "../../include/link_list.h"

#define MALLOC_ERROR "Failed to allocate menory space!"

link_list* create_link_list(void){

link_list *list = (link_list*)malloc(sizeof(link_list));

if (list == NULL){

puts(MALLOC_ERROR);

return NULL;

}

list->theSize = 0;

list->node = (struct _node*)malloc(sizeof(struct _node));

if (list->node != NULL){

list->node->data = NULL;

list->node->next = list->node->prev = NULL; // Initialize pointer NULL

list->endMarker = list->beginMarker = list->node;

}else{

puts(MALLOC_ERROR);

return NULL;

}

return list;

}

// Add any type to link_list.

void link_add(link_list *list, void *data){

struct _node* node = (struct _node*)malloc(sizeof(struct _node));

if (node == NULL){

puts(MALLOC_ERROR);

}else{

node->prev = list->node;

list->endMarker = list->node = list->node->next = node;

node->data = data;

list->theSize++;

}

}

// Getter a node in link_list.

struct _node* _link_get_node(link_list *list, int index){

if (index >= list->theSize || index < 0){

printf("List index out of bounds : %d\n", list->theSize);

return NULL;

}

int i;

struct _node *node;

if (index < link_size(list) / 2){

node = list->beginMarker->next;

for (i = 0; i < index; i++){

node = node->next;

}

}else{

node = list->endMarker;

int max = link_size(list) - index - 1;

for (i = 0; i < max; i++){

node = node->prev;

}

}

return node;

}

void* link_get(link_list *list, int index){

struct _node *node = _link_get_node(list, index);

if (node == NULL){

return NULL;

}

return node->data;

}

// return the link list size.

int link_size(link_list *list){

return list->theSize;

}

// replace node.

void link_set(link_list *list, int index, void *data){

struct _node *node = _link_get_node(list, index);

if (node != NULL){

node->data = data;

}

}

// remove node.

void link_remove(link_list *list, int index){

struct _node *node = _link_get_node(list, index);

if (node == NULL){

return;

}

node->prev->next = node->next;

node->next->prev = node->prev;

if (node != NULL){

if (node->data != NULL){

free(node->data);

}

free(node);

node = NULL;

}

list->theSize--;

}

// destory link

void link_destory(link_list *list){

int i = 0;

struct _node *node = list->beginMarker;

for (i = 0; i <= list->theSize; i++){

struct _node *next = node->next;

if (node != NULL){

if (node->data != NULL){

free(node->data);

}

free(node);

node = next;

}

}

free(list);

list = NULL;

}

C代码

intmain(intargc,char*args[]) {

link_list *list = create_link_list();

inti;

for(i = 0; i

int* value = (int*)malloc(sizeof(int));

*value = i;

link_add(list, value);

}

printf("The list size: %d\n", link_size(list));

for(i = 0; i

printf("index: %d = %d\n", i, *(int*)link_get(list, i));

}

int*new= (int*)malloc(sizeof(int));

*new= 100;

link_set(list, 0,new);

printf("\n Update the index 0 value: %d\n", *(int*)link_get(list, 0));

link_remove(list, 0);

printf("Remove Before========\n");

for(i = 0; i

printf("index: %d = %d\n", i, *(int*)link_get(list, i));

}

link_destory(list);

}