1，单向链简洁。

单向链表(单链表)是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指列表中的下一个结点；

列表是由结点构成，由head指针指向第一个成为表头的结点而终止于最后一个指向nuLL的指针；

2，例子要求：

根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转；

3，代码实现。

#include

#include

#include

#include

#include

//节点的定义

typedef struct Node {

void *data; //数据域 //链域

struct Node *next;

} NodeStruct, *pNode;

pNode head = NULL;

typedef char (*pCompareFunc)(void *a, void *b);

typedef void* (*pChar)(void *p);

// 字符串判断

int str_compare(void *a, void *b) {

char *pa = (char*)a;

char *pb = (char*)b;

return strcmp(pa , pb);

}

// 分配一个节点

pNode allocate_node(void *data, pChar char_func) {

pNode node = allocate();

node->data = char_func(data);

return node;

}

// 创建节点

pNode allocate() {

void *p = malloc(sizeof(NodeStruct));

pNode node = (pNode)p;

node->next = NULL;

node->data = NULL;

return node;

}

// 添加一个节点

void insertNode(pNode node){

if (head == null){

head=node;

}

else {

node->next = head;

head = node;

}

}

void* char_char(void *p) {

char* pa = (char*)malloc(sizeof(char));

memcpy(pa, p, sizeof(char));

return pa;

}

// 初始化节点

pNode allocate_node(void *data, pChar char_func) {

pNode node = allocate();

node->data = char_func(data);

return node;

}

// 释放资源

void free_list(pNode node) {

pNode next = node;

while (next != NULL) {

if (next->data != NULL)

free(next->data);

pNode temp = next;

next = next->next;

free(temp);

}

}

// 1.1 添加一个节点

void insert(pNode node) {

if (head == NULL)

head = node;

else {

node->next = head;

head = node;

}

}

//1.2查找

int str_search(void* data,pCompareFunc compare){

pNode next = head;

pNode prev = NULL;

while (next != NULL ) {

if (compare(data, next->data) == 0) {

// 如果查找到了，就退出返回1

return 1;

break;

}

prev = next;

next = next->next;

}

// 如果一直查找不到，就返回0

return 0;

}

// 1.3删除节点

void remove(void* data,pCompareFunc compare) {

pNode next = head;

pNode prev = NULL;

while (next != NULL) {

if (compare(data, next->data) == 0) {

if (prev == NULL) {

head = next->next;

next->next = NULL;

free_list(next);

} else {

prev->next = next->next;

next->next = NULL;

free_list(next);

}

break;

}

prev = next;

next = next->next;

}

}

//1.4反转

void invert_order()

{

node *This,*prev;

p=head.next;

This=NULL;

while(p) {

prev=This;

This=p;

p=p->next;

This->next=prev;

}

head.next=This;

}

void main(){

// 1单向链表

char a1[] = 'aaa1';

char a2[] = 'aaa2';

char a3[] = 'aaa3';

// 1.1添加

insertNode(allocate_node(a1, init_char));

insertNode(allocate_node(a2, init_char));

insertNode(allocate_node(a3, init_char));

// 1.2查找

int flag = 0;

flag = str_search(&a2,str_compare);

// 1.3删除

remove(&a2,str_compare);

// 1.4反转

invert_order();

}