单向链表的基本操作

linklist.h

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

typedef char LinkNodeType;
typedef struct LinkNode{
struct LinkNode* next;
LinkNodeType data;
}LinkNode;

void LinklistInit(LinkNode** node);//链表的初始化函数
void LinklistPushBack(LinkNode** phead,LinkNodeType value);//尾插函数
void LinklistPopBack(LinkNode** phead);//尾删函数
LinkNode* CreateNode(LinkNodeType value);//创建节点
void DestroyNode(LinkNode* node);//销毁节点
void LinkNodePrint(LinkNode* head,const char* msg);//打印函数
void LinklistPushFront(LinkNode** head,LinkNodeType value);//头插函数
void LinklistPopFront(LinkNode** head);//头删函数
LinkNode* LinklistFind(LinkNode* head,LinkNodeType to_find);//根据特定值寻找链表的节点
void LinklistInsertBefore(LinkNode** head,LinkNode* pos,LinkNodeType value);//在特定节点前插入一个节点，并赋值
void LinklistInsertAfter(LinkNode** head,LinkNode* pos,LinkNodeType value);//在特定节点后插入一个节点，并赋值
void LinklistErase(LinkNode** head,LinkNode* pos);//删除特定位置的节点
void LinklistRemove(LinkNode** head,LinkNodeType to_delete);//删除与特定值数据相等的第一个节点
void LinklistRemove2(LinkNode** head,LinkNodeType to_delete);//删除与特定值数据相等的第一个节点
void LinklistRemoveAll(LinkNode** head,LinkNodeType value);//删除所有与特定值数据相等的节点
int LinklistEmpyty(LinkNode* head);//判断链表是否为空的函数
size_t LinklistSize(LinkNode* head);//求链表长度的函数
LinkNode* JosephCircle(LinkNode* head,int M);//单链表实现约瑟夫环

linklist.c

#include "linklist.h"

void LinklistInit(LinkNode** node){
if(node == NULL){
return;
}
*node = NULL;
}

void LinkNodePrint(LinkNode* head,const char* msg){
printf("[%s]\n",msg);
LinkNode* cur = head;
for(;cur != NULL;cur = cur->next){
printf("[%c]",cur->data);
}
printf("\n");
}

LinkNode* CreateNode(LinkNodeType value){
LinkNode* next_node=(LinkNode*)malloc(sizeof(LinkNode));
next_node->data=value;
next_node->next=NULL;
return next_node;
}

void DestroyNode(LinkNode* node){
free(node);
}

void LinklistPushBack(LinkNode** phead,LinkNodeType value){
if(phead == NULL){
return;
}
if(*phead == NULL){
*phead=CreateNode(value);
return;
}
LinkNode* cur = *phead;
while(cur->next != NULL){
cur = cur->next;
}
LinkNode* new_node=CreateNode(value);
cur->next=new_node;
}

void LinklistPopBack(LinkNode** phead){
if(phead == NULL){
return;
}
if(*phead == NULL){
return;
}
LinkNode* cur = *phead;
if(cur->next == NULL){
DestroyNode(cur);
*phead = NULL;
}
while(cur->next != NULL){
if(cur->next->next == NULL){
LinkNode* to_delete=cur->next;
cur->next=NULL;
DestroyNode(to_delete);
}
else{
cur=cur->next;
}
}
}

void LinklistPushFront(LinkNode** head,LinkNodeType value){
if(head == NULL){
return;
}
if(*head == NULL){
*head = CreateNode(value);
}
else{
LinkNode* new_node=CreateNode(value);
new_node->next = *head;
*head = new_node;
}
}

void LinklistPopFront(LinkNode** head){
if(head == NULL){
return;
}
if(*head == NULL){
return;
}
LinkNode* to_delete = *head;
*head = (*head)->next;
DestroyNode(to_delete);
}

LinkNode* LinklistFind(LinkNode* head,LinkNodeType to_find){
LinkNode* cur = head;
for(;cur!=NULL;cur=cur->next){
if(cur->data == to_find){
printf("pos = %p\n",cur);
return cur;
}
}
return NULL;
}

void LinklistInsertBefore(LinkNode** head,LinkNode* pos,LinkNodeType value){
if(head == NULL){
return;
}
if(*head == NULL){
*head = CreateNode(value);
return;
}
if(pos == NULL){
LinklistPushBack(head,value);
return;
}
if(*head == pos){
LinklistPushFront(head,value);
return;
}
LinkNode* cur = *head;
while(cur->next != NULL){
if(cur->next == pos){
LinkNode* new_node = CreateNode(value);
new_node->next = pos;
cur->next = new_node;
}
else{
cur = cur->next;
}
}
return;
}

void LinklistInsertAfter(LinkNode** head,LinkNode* pos,LinkNodeType value){
if(head == NULL){
return;
}
if(*head == NULL){
*head = CreateNode(value);
return;
}
if(pos == NULL){
return;
}
LinkNode* new_node = CreateNode(value);
new_node->next = pos->next;
pos->next = new_node;
}

void LinklistErase(LinkNode** head,LinkNode* pos){
if(head == NULL){
return;
}
if(*head == NULL){
return;
}
if(pos == NULL){
return;
}
if(*head == pos){
LinklistPopFront(head);
return;
}
LinkNode* cur = *head;
while(cur != NULL){
if(cur->next!=NULL){
cur->next=pos->next;
DestroyNode(pos);
return;
}
cur=cur->next;
}
return;
}

void LinklistRemove(LinkNode** head,LinkNodeType to_delete){
if(head == NULL){
return;
}
if(*head == NULL){
return;
}
LinkNode* pos = LinklistFind(*head,to_delete);
LinklistErase(head,pos);
}

void LinklistRemove2(LinkNode** head,LinkNodeType to_delete){
if(head == NULL){
return;
}
if(*head == NULL){
return;
}
if((*head)->data == to_delete){
LinkNode* to_delete = *head;
*head = (*head)->next;
DestroyNode(to_delete);
return;
}
LinkNode* cur = (*head)->next;
LinkNode* pre = *head;
while(cur != NULL){
if(cur->data = to_delete){
pre->next = cur->next;
DestroyNode(cur);
return;
}
else{
pre = pre->next;
cur = cur->next;
}
}
return;
}

void LinklistRemoveAll(LinkNode** head,LinkNodeType value){
if(head == NULL){
return;
}
if(*head == NULL){
return;
}
while(1){
LinkNode* pos = LinklistFind(*head,value);
if(pos == NULL){
return;
}
LinklistErase(head,pos);
}
return;
}

int LinklistEmpty(LinkNode* head){
return head==NULL?1:0;
}

size_t LinklistSize(LinkNode* head){
if(head == NULL){
return 0;
}
size_t count = 0;
LinkNode* cur = head;
while(cur != NULL){
++count;
cur = cur->next;
}
printf("count = %d\n",count);
return count;
}

LinkNode* JosephCircle(LinkNode* head,int M){
if(head == NULL){
return;
}
LinkNode* cur = head;
while(cur->next != cur){
int i = 1;
for(;i<M;++i){
cur = cur->next;
}
printf("%c\n",cur->data);
cur->data = cur->next->data;
LinkNode* to_delete = cur->next;
cur->next = to_delete->next;
DestroyNode(to_delete);
}
return cur;
}

test.c

#include"linklist.h"
#define PRINT_HEAD printf("\n==========%s==========\n",__FUNCTION__)

void TestInit(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);
}

void TestLinklistPushBack(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
LinkNodePrint(head,"insert four elements to the linklist");
}

void TestLinklistPopBack(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
LinklistPopBack(&head);
LinklistPopBack(&head);
LinkNodePrint(head,"delete two elements from the linklist");

}

void TestLinklistPushFront(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushFront(&head,'a');
LinklistPushFront(&head,'b');
LinklistPushFront(&head,'c');
LinklistPushFront(&head,'d');
LinkNodePrint(head,"insert four elements from the linklist");
}

void TestLinklistPopFront(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
LinklistPopFront(&head);
LinklistPopFront(&head);
LinkNodePrint(head,"delete two elements from the linklist");
}

void TestLinklistFind(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushFront(&head,'a');
LinklistPushFront(&head,'b');
LinklistPushFront(&head,'c');
LinklistPushFront(&head,'d');
LinklistFind(head,'c');
}

void TestLinklistInsertBefore(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
LinklistInsertBefore(&head,head,'x');
LinkNodePrint(head,"insert an element before the head");
}

void TestLinklistInsertAfter(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
LinklistInsertAfter(&head,head,'x');
LinkNodePrint(head,"insert an element after the head");
}

void TestLinklistErase(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
LinkNode* pb = LinklistFind(head,'b');
LinklistErase(&head,pb);
LinkNodePrint(head,"erase an element from the specific position");
}

void TestLinklistRemove(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
LinklistRemove(&head,'b');
LinkNodePrint(head,"remove an element from the specific value");
}

void TestLinklistRemove2(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
LinklistRemove(&head,'b');
LinkNodePrint(head,"remove an element from the specific value");
}

void TestLinklistRemoveAll(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'a');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
LinklistRemoveAll(&head,'b');
LinkNodePrint(head,"remove  elements from the specific value");
}

void TestLinklistEmpty(){
PRIN
a85e
T_HEAD;
LinkNode* head;
LinklistInit(&head);

int ret = LinklistEmpty(head);
printf("expect 1, actual %d\n",ret);
LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
ret = LinklistEmpty(head);
printf("expect 0, actual %d\n",ret);
}

void TestLinklistSize(){
PRINT_HEAD;
LinkNode* head;
LinklistInit(&head);

LinklistPushBack(&head,'a');
LinklistPushBack(&head,'b');
LinklistPushBack(&head,'c');
LinklistPushBack(&head,'d');
size_t ret = LinklistSize(head);
printf("expect 4, actual %d\n",ret);
}

void TestJosephCircle(){
PRINT_HEAD;
LinkNode* a = CreateNode('a');
LinkNode* b = CreateNode('b');
LinkNode* c = CreateNode('c');
LinkNode* d = CreateNode('d');
LinkNode* e = CreateNode('e');
LinkNode* f = CreateNode('f');
LinkNode* g = CreateNode('g');
a->next = b;
b->next = c;
c->next = d;
d->next = e;
e->next = f;
f->next = g;
g->next = a;
LinkNode* survive = JosephCircle(a,5);
printf("survive is %c\n",survive->data);
}

int main(){
TestInit();
TestLinklistPushBack();
TestLinklistPopBack();
TestLinklistPushFront();
TestLinklistPopFront();
TestLinklistFind();
TestLinklistInsertBefore();
TestLinklistInsertAfter();
TestLinklistErase();
TestLinklistRemove();
TestLinklistRemove2();
TestLinklistRemoveAll();
TestLinklistEmpty();
TestLinklistSize();
TestJosephCircle();
}