单链表的基本操作（适合数据结构初学者）

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


/**********定义链表*********/ 


//定义结点 
typedef struct node {
int           data;
struct node*  next;
}Node;


//定义链表结构 
typedef struct {
Node*  head;   //头指针 
Node*  tail;   //尾指针 
}LinkedList;


/**************创建链表***************/
LinkedList* createList(){
LinkedList* list = (LinkedList*)malloc(sizeof(LinkedList));
list -> head = NULL;
list -> tail = NULL;
return list;
}
/******************链表是否为空************************/
bool  isEmpty(LinkedList* list){
Node* p = list -> head ;
return (p == NULL);
} 


/******************添加结点*********************/
void insertData (LinkedList* list, int data){
Node* node = (Node*) malloc (sizeof (Node));
node -> data = data ;
node -> next = NULL ;
if (list -> head == NULL){
list -> head = node ;
list -> tail = node ;
}
else {
list -> tail -> next = node ;
list -> tail = node ; 
}
}
 
/*********************删除结点**************************/


/*********按照数据删除**********/
void deteleData (LinkedList* list, int data){
Node* p = list -> head;
Node* temp = NULL ;
if (p != NULL){         //判断是否为空链表 
if (p -> data == data){          //若要删除的数据是表头结点 
list -> head = p -> next;
free(p);
}   
else {
while (p -> next != NULL && p -> next -> data != data){
p = p -> next ; 
}
if (p -> next != NULL  ){  //查找到该数据 
temp = p -> next;
p -> next = temp -> next ;      //断开该结点 
free(temp);
}
else {
printf (" ERROR! the list doesn't have the data!\n"); 
}
}
}
else {
printf (" ERROR! The list is empty !");
}
} 
/*************按照指针删除**************/
/**常规照指针删除需要O（n）的 时间复杂度
*然而一个较好的思路是对该结点数据用它的下一个结点数据覆盖
*下一个结点直接删除，这样避免了遍历指针查找*****/ 
void deteleDataFast (LinkedList* list, Node* detelePoint){
Node* p = list -> head;
Node* temp ;
if (p == NULL){
return ;
}
if (p == detelePoint) { // 要删除的是首结点
list -> head = p -> next;
free(p);
}
else if (detelePoint -> next == NULL){        //要删除的是尾结点
while (p -> next != detelePoint){
p = p -> next;
}
p -> next = NULL;
free(detelePoint);
}
else {
temp = detelePoint -> next;
detelePoint -> data = temp -> data ;
detelePoint -> next = temp -> next ;
free (temp);
}
}


/***********************查找结点**************************/


/************按照数据查找****************/
// Node* searchElement(LinkedList* list, int data){
// Node* p = list -> head;
// while (p  != NULL && p -> data != data){
// p = p -> next;
// }
// if (p == NULL){
// return NULL;
// }
// else {
// return p;
// }
// } 
/******** 按照第k个结点查找  ******************/


Node* searchElement(LinkedList* list, int k){
Node* p = list -> head;
int i ;
for (i = 1; i <= k; i++){
if (p == NULL){
printf (" ERROR! please check it ! The length has a problem .\n");
return NULL;
} 
else if (p != NULL && i == k){
return p;
} 
p = p -> next;
}
} 


/************************链表翻转**************************/
/****常规的链表翻转需要的空间复杂度为O（n），那么怎么将O（n）降到O（1）
**出处注明：本算法受B站正月点灯笼大牛启发，***/
void reverseLink(LinkedList* list){
Node* p = list -> head;
Node* temp ;
Node* prev = NULL;
list -> tail = p;
while (p != NULL){
temp = p -> next;
p -> next = prev;
prev = p;
p = temp;
}
list -> head = prev;
} 


/*************************************************/


/*********************链表输出*************************/
void printList(LinkedList* list){
Node* p = list -> head ;
int data ; 
while (p != NULL){
data = p-> data;
p = p -> next;
printf("   %d  ->", data);
}
printf ("   NULL\n");
} 


int main () {
LinkedList* list = createList();
  insertData(list, 14);
insertData(list, 15);
insertData(list, 16);
insertData(list, 17); 
printList(list);
// deteleData(list,15);
// printList(list);
// Node* temp = searchElement(list, 15);
// printf ("%d\n", temp);
// Node* temp = searchElement(list, 4);
// printf ("%d\n", temp ); 
// reverseLink(list);
// printList(list);
// printf("%d\n", isEmpty(list));
// deteleData(list, 14);
// deteleData(list, 15);
// deteleData(list, 16);
// deteleData(list, 17);
// printf("%d\n", isEmpty(list));
// Node* temp = searchElement(list, 4);
// deteleDataFast (list, temp);
// printList(list);


return 0;
}