带头节点控制单链表之C语言实现

// 1.头、尾节点位置

// 2.链表

// 元素数量

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <string.h>

//链表节点信息：

//

// 1.数据域

// 2.指针域

#define TRUE (1)

#define FALSE (0)

#define ZERO (0)

#define ONLY_ONE (1)

#define TWO (2)

#define get_data_size() ((unsigned long)&(((List_node *)0)->next))

struct List_node; //声明一个类型

//链表控制信息

typedef struct List

{

struct List_node *head; //指向链表头部

struct List_node *tail; //指向链表尾部

int count; //链表节点数量

}List;

//链表节点信息

typedef struct List_node

{

int data; //数据域

struct List_node *next; //指针域

}List_node;

typedef unsigned char Boolean;

// lua

// C语言接口与实现 lcc

//链表的接口

List *init_list(void) ; //链表的初始化

void destroy_list(List **list) ; //链表的销毁

Boolean push_front(List *list, int value) ; //头部插入

Boolean push_back(List *list, int value) ; //尾部插入

Boolean pop_front(List *list) ; //头部删除

Boolean pop_back(List *list) ; //尾部删除

void show_list(List *list) ; //显示链表信息

void sort_list_ascend(List *list) ; //升序排列

void sort_list_descent(List *list) ; //降序排列

int get_list_count(List *list) ; //得到链表节点数量

///

List *merge_two_lists(List *list1, List *list2) ; //合并两个有序链表

List *merge_two_lists_recure(List *list1, List *list2); //合并两个有序链表（递归）

List_node *find_revise_node(List *list, int num) ; //找到链表的倒数第num个节点

List_node *find_mid_node(List *list) ; //找到链表的中间节点

List *reverse_list(List *list) ; //逆置一个链表

List *list_dump(List *list) ; //链表的拷贝

void reverse_show_list(List *list) ; //逆序输出链表信息

Boolean is_list_intersect(List *list1, List *list2) ; //判断链表是否有交点

List_node *get_first_common_node(List *list1, List *list2) ; //得到第一个交点

void delete_one_node(List *list, List_node *node) ; //在O（1）的时间复杂度删除节点

Boolean has_circle(List *list, List_node **intersect) ; //判断一个链表是否有环

List_node *find_circle_first_node(List *list) ; //找到带环链表的环入口节点

static void *Malloc(size_t size);

static List_node *create_node(void);

static void swap(void *a, void *b, int length);

static void rev_show_list(List_node *node);

static void swap(void *a, void *b, int length)

{

void *temp = Malloc(length);

memcpy(temp, a, length);

memcpy(a, b, length);

memcpy(b, temp, length);

free(temp);

}

static List_node *create_node(void) //创建链表节点

{

List_node *node = (List_node *)Malloc(sizeof(List_node));

bzero(node, sizeof(List_node));

return node;

}

static void *Malloc(size_t size)

{

void *result = malloc(size);

if(result == NULL){

fprintf(stderr, "the memory is full\n");

exit(1);

}

return result;

}

////////////////////////////////////////////////////////////////////////////////////////

//

// 链表接口实现

//

// 链表控制信息

// typedef struct List

// {

// struct List_node *head; //指向链表头部

// struct List_node *tail; //指向链表尾部

// int count; //链表节点数量

// }List;

//

// //链表节点信息

// typedef struct List_node

// {

// int data; //数据域

// struct List_node *next; //指针域

// }List_node;

//

////////////////////////////////////////////////////////////////////////////////////////

List *init_list(void) //链表的初始化

{

List *list = (List *)Malloc(sizeof(List));

// | head | tail | count |

// \ / 0

// \ /

// NULL

bzero(list, sizeof(List));

return list;

}

void destroy_list(List **list) //链表的销毁

{

// list

// /

// list_head

// /

// | head | tail | count |

// \ \ n + 1

//

// \ \

// node->node2->node3

if(list == NULL || *list == NULL){

return ;

}

// 链表删除步骤：

// 1.删除链表节点信息;

while((*list)->count){ //头部删除链表节点

pop_front(*list);

}

// 2.删除链表控制信息.

free(*list);

*list = NULL;

}

Boolean push_front(List *list, int value) //头部插入

{

List_node *node = NULL;

if(list == NULL){

return FALSE;

}

//创建节点并赋值

node = create_node();

node->data = value;

// case1:

// | head | tail | count |

// \ / 1

// \ /

// node

if(list->count == ZERO){

list->tail = node;

}else{

// case2:

// | head | tail | count |

// \ / n + 1

// \ /

// node->node2->node3

node->next = list->head;

}

list->head = node;

list->count++;

return TRUE;

}

Boolean push_back(List *list, int value) //尾部插入

{

List_node *node = NULL;

if(list == NULL){

return FALSE;

}

node = create_node();

node->data = value;

// case1:

// | head | tail | count |

// \ / 1

// \ /

// node

if(list->count == ZERO){

list->head = list->tail = node;

}else{

// case2:

// | head | tail | count |

// \ / n + 1

// \ /

// node1->node2->node

list->tail->next = node;

list->tail = node;

}

list->count++;

return TRUE;

}

Boolean pop_front(List *list) //头部删除

{

List_node *p_node = NULL;

if(list == NULL || list->count == ZERO){

return FALSE;

}

// case1:

// | head | tail | count |

// \ / 1->0

// \ /

// node

// case2:

// | head | tail | count |

// \ / n-> n - 1

// \ /

// node1->node2->node3

p_node = list->head;

if(list->count == ONLY_ONE){

list->head = list->tail = NULL;

}else{

list->head = list->head->next;

}

free(p_node);

list->count--;

return TRUE;

}

Boolean pop_back(List *list) //尾部删除

{

List_node *p_node = NULL;

if(list == NULL || list->count == ZERO){

return FALSE;

}

// case1:

// | head | tail | count |

// \ / 1->0

// \ /

// node

// case2:

// | head | tail | count |

// \ / n-> n - 1

// \ /

// node1->node2->node3

p_node = list->head;

if(list->count == ONLY_ONE){

list->head = list->tail = NULL;

free(p_node);

}else{

//判断倒数第二个？

// p_node->next == list->tail

while(p_node->next != list->tail){

p_node = p_node->next;

}

free(list->tail);

list->tail = p_node;

p_node->next = NULL;

}

list->count--;

return TRUE;

}

void show_list(List *list) //显示链表信息

{

List_node *p_node = NULL;

if(list != NULL && list->count != ZERO){

for(p_node = list->head; p_node; p_node = p_node->next){

printf("%d ", p_node->data);

}

printf("\n");

}

}

#if 1

void sort_list_ascend(List *list) //升序排列

{

List_node *p_node = NULL;

List_node *q_node = NULL;

unsigned long data_size = 0;

if(list == NULL || list->count < TWO){

return ;

}

// List_node *p = list->head;

// p->next = NULL;

// ((unsigned long)&(((List_node *)0)->next))

// sizeof(List_node) - sizeof(List_node *);

// int data; // 0 1 2 3

// // 4 5 6 7

// struct List_Node *next; // 8 9 10 11

// 12 13 14 15

//

data_size = get_data_size(); //求得数据区域得大小

for(p_node = list->head; p_node->next; p_node = p_node->next){

for(q_node = p_node->next; q_node ; q_node = q_node->next){

if(p_node->data > q_node->data){

swap(p_node, q_node, data_size);

}

}

}

}

void sort_list_descent(List *list) //降序排列

{

List_node *p_node = NULL;

List_node *q_node = NULL;

unsigned long data_size = 0;

if(list == NULL || list->count < TWO){

return ;

}

// List_node *p = list->head;

// p->next = NULL;

// ((unsigned long)&(((List_node *)0)->next))

// sizeof(List_node) - sizeof(List_node *);

// int data; // 0 1 2 3

// // 4 5 6 7

// struct List_Node *next; // 8 9 10 11

// 12 13 14 15

//

data_size = get_data_size(); //求得数据区域得大小

for(p_node = list->head; p_node->next; p_node = p_node->next){

for(q_node = p_node->next; q_node ; q_node = q_node->next){

if(p_node->data < q_node->data){

swap(p_node, q_node, data_size);

}

}

}

}

int get_list_count(List *list) //得到链表节点数量

{

if(list == NULL){

return -1;

}

return list->count;

}

// char *str1 = (char *)malloc(20);

// strcpy(str1, "hello,world");

//

// char *str2 = str1;

// free(str1);

//

// *str2 = 'c';

///

List *merge_two_lists(List *list1, List *list2) //合并两个有序链表

{

List *result = NULL;

List_node *list1_move = NULL;

List_node *list2_move = NULL;

#if 0

if(list1 == NULL){

return result = copy_list_by_ctl(list2);

}else if(list2 == NULL){

return result = copy_list_by_ctl(list1);

}

#endif

if(list1 == NULL || list2 == NULL){

return result;

}

result = init_list(); //结果链表得初始化

list1_move = list1->head;

list2_move = list2->head;

// | head | tail | count |

// \ / n-> n - 1

// \ /

// node1->node2->node3

//

//

// | head | tail | count |

// \ / n-> n - 1

// \ /

// node1->node2->node3

//

//如果两个链表都没有遍历完，进行比较

while(list1_move != NULL && list2_move != NULL){

if(list1_move->data <= list2_move->data){

push_back(result, list1_move->data);

list1_move = list1_move->next;

}else{

push_back(result, list2_move->data);

list2_move = list2_move->next;

}

}

//当两个链表中任何一个遍历结束，则把另外一个进行尾部添加

while(list2_move != NULL){

push_back(result, list2_move->data);

list2_move = list2_move->next;

}

while(list1_move != NULL){

push_back(result, list1_move->data);

list1_move = list1_move->next;

}

return result;

}

List *merge_two_lists_recure(List *list1, List *list2); //合并两个有序链表（递归）

List_node *find_revise_node(List *list, int num) //找到链表的倒数第num个节点

{

List_node *move = NULL;

int move_count = 0;

// 10 23 5 15 50 67 45 32

if(list == NULL || num <= 0 || num > list->count){

return NULL;

}

move = list->head;

//移动的步长

move_count = list->count - num;

while(move_count--){

move = move->next;

}

return move;

}

List_node *find_mid_node(List *list) //找到链表的中间节点

{

// 1. 快慢指针：

//

// f 每次移动2步， s 每次移动1步

// 10 23 5 15 50 67 45 32 82

//

// 2. 8 / 2 = 4

List_node *move = NULL;

int move_count = 0;

if(list == NULL){

return NULL;

}

move = list->head;

move_count = list->count >> 1;

// 0000 1010 10

// 10 >> 1

// 0000 0101 5

while(move_count--){

move = move->next;

}

return move;

}

List *reverse_list(List *list) //逆置一个链表

{

List_node *p_node = NULL;

List_node *q_node = NULL;

List_node *m_node = NULL;

// | head | tail | count |

// \ / n-> n - 1

// \ /

// node1->node2->node3

if(list == NULL || list->count < TWO){

return list;

}

//两个节点

if(list->count == TWO){

list->tail->next = list->head;

list->head->next = NULL;

}else{ //三个节点

p_node = list->head;

q_node = p_node->next;

m_node = q_node->next;

p_node->next = NULL;

do{

q_node->next = p_node; //让中间指针的next指向前一个

p_node = q_node; //指针整体向后搬移

q_node = m_node;

m_node = m_node->next;

}while(m_node != NULL);

q_node->next = p_node;

}

//交换头尾指针

swap(&(list->head), &(list->tail), sizeof(List_node *));

return list;

}

List *list_dump(List *list) //链表的拷贝

{

}

static void rev_show_list(List_node *node)

{

//要打印当前节点，先打印其后续节点

if(node != NULL){

rev_show_list(node->next);

printf("%d ", node->data);

}

}

void reverse_show_list(List *list) //逆序输出链表信息

{

if(list == NULL || list->count == ZERO){

return ;

}

rev_show_list(list->head);

printf("\n");

}

Boolean is_list_intersect(List *list1, List *list2) //判断链表是否有交点

{

if(list1 == NULL || list2 == NULL){

return FALSE;

}

return list1->tail == list2->tail;

}

List_node *get_first_common_node(List *list1, List *list2) //得到第一个交点

{

int list1_len = 0;

int list2_len = 0;

int distance = 0;

List_node *p_node = NULL;

List_node *q_node = NULL;

if(!is_list_intersect(list1, list2)){ //判断两个链表是否有交点

return NULL;

}

list1_len = list1->count;

list2_len = list2->count;

p_node = list1->head;

q_node = list2->head;

//判断较长链表并首先进行移动

if(list1_len >= list2_len){

distance = list1_len - list2_len;

while(distance--){

p_node = p_node->next;

}

}else{

distance = list2_len - list1_len;

while(distance--){

q_node = q_node->next;

}

}

//依次对对应节点进行判断是否相等，如果相等则是第一个相交节点

while(p_node != q_node){

p_node = p_node->next;

q_node = q_node->next;

}

return p_node;

}

void delete_one_node(List *list, List_node *node) //在O（1）的时间复杂度删除节点

{

List_node *p_node = NULL;

if(list == NULL || node == NULL){

return ;

}

if(node != list->tail){ //不是最后一个节点

p_node = node->next;

node->data = p_node->data;

node->next = p_node->next;

free(p_node);

list->count--;

}else{ //最后一个节点

pop_back(list);

}

}

Boolean has_circle(List *list, List_node **intersect) //判断一个链表是否有环

{

List_node *fast = NULL;

List_node *slow = NULL;

if(list == NULL || list->count < TWO){

return FALSE;

}

fast = slow = list->head; //两者都先指向头节点

//定义两个指针，一快一慢，如果有环，则快指针先进入环

//等慢指针进入后，两者最终会相遇

while(fast != NULL && fast->next != NULL){

fast = fast->next->next;

slow = slow->next;

if(fast == slow){ //两者在环中相遇

if(intersect != NULL){

*intersect = fast;

}

return TRUE;

}

}

return FALSE;

}

List_node *find_circle_first_node(List *list) //找到带环链表的环入口节点

{

int list1_len = 0;

int list2_len = 0;

int distance = 0;

List_node *intersect = NULL;

List_node *list1_head = NULL;

List_node *list2_head = NULL;

List_node *p_node = NULL;

List_node *q_node = NULL;

if(!has_circle(list, &intersect)){

return NULL;

}

//把问题转为求两个相交链表的第一个节点

p_node = list1_head = list->head;

q_node = list2_head = intersect->next;

//统计两个链表的长度

while(p_node != intersect){

list1_len++;

p_node = p_node->next;

}

while(q_node != intersect){

list2_len++;

q_node = q_node->next;

}

p_node = list1_head;

q_node = list2_head;

//让较长链表先移动 |list1_len - list2_len| 步长

if(list1_len >= list2_len)

{

distance = list1_len - list2_len;

while(distance--){

p_node = p_node->next;

}

}else{

distance = list2_len - list1_len;

while(distance--){

q_node = q_node->next;

}

}

while(p_node != q_node){

p_node = p_node->next;

q_node = q_node->next;

}

return p_node;

}

#endif

int main(int argc, char **argv)

{

List *list1 = NULL;

List *list2 = NULL;

List *merge_list = NULL;

List_node *middle = NULL; //中间节点

List_node *revise = NULL; //倒数第n个节点

int i = 0;

list1 = init_list(); //链表初始化

list2 = init_list(); //链表初始化

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

push_back(list1, rand() % 200);

}

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

push_back(list2, rand() % 200);

}

show_list(list1); //显示链表信息

show_list(list2);

sort_list_ascend(list1);

sort_list_ascend(list2);

merge_list = merge_two_lists(list1, list2); //合并两个有序链表

printf("list1 :");

show_list(list1); //显示链表信息

printf("list2 :");

show_list(list2);

printf("merge list:\n");

show_list(merge_list);

middle = find_mid_node(merge_list);

if(middle != NULL){

printf("the mid of merge_list is:%d\n", middle->data);

}

revise = find_revise_node(merge_list, 5);

if(middle != NULL){

printf("the revise of merge_list is:%d\n", revise->data);

}

reverse_list(merge_list); //反转链表

printf("reverse list :\n");

show_list(merge_list);

printf("merge_list revese show:\n");

reverse_show_list(merge_list);

destroy_list(&list1); //链表的销毁

destroy_list(&list2); //链表的销毁

destroy_list(&merge_list);

return 0;

}