【2015/11/21】 数据结构学习日志_Day17 双端链表

/*************************************************************************
> File Name: ctr_list.c
> Author: khalil
> Mail: hsgwpj@gmail.com
> Created Time: Sat 21 Nov 2015 09:11:34 AM CST
************************************************************************/

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

// 《C语言接口与实现》 *
//  C的面向对象： lua
//  redis 键值对数据库

//比较优秀的网站：
//    stackoverflow
//    sourceforge

#if 1
//为bool类型宏定义
#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))

//链表控制信息：
//
// 1.头、尾节点位置
// 2.链表元素数量
//
//链表节点信息：
//
// 1.数据域
// 2.指针域

//节点：
typedef struct List_node
{
int               data;     //数据域
struct List_node *next;     //指针域
}List_node;

//控制：
typedef struct List
{
struct List_node *head;     //指向链表头部
struct List_node *tail;     //指向链表尾部
int              count;     //链表节点数量
}List;

typedef unsigned char bool;

static void *Malloc(size_t size); //包裹函数
static List_node *create_node(void);//创建节点
static void swap(void *a, void *b, int len);//交换data
static void reverse_show_list_node(List_node *p);//组件

static void swap(void *a, void *b, int len)
{
void *tmp = Malloc(len);
memcpy(tmp, a, len);
memcpy(a, b, len);
memcpy(b, tmp, len);

free(tmp);
}
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, "Memory Full!\n");
exit(1);
}
return result;
}

static void reverse_show_list_node(List_node *p)
{
if(p){
reverse_show_list_node(p->next);
printf("%d\t", p->data);
}
}

//链表接口：
List        *init_list(void);                       //链表的初始化
void        destory_list(List **);                  //链表的销毁
bool        push_front(List *list, int value);      //头部插入
bool        push_back (List *list, int value);      //尾部插入
bool        pop_front (List *list);                 //头部删除
bool        pop_back  (List *list);                 //尾部删除
void        show_list (List *list);                 //显示链表信息
void        sort_list_ascend (List *list);          //升序排列
void        sort_list_descend(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);                      //逆序输出一个链表
bool        is_lists_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)的时间复杂度下删除节点
bool        has_circle            (List *list, List_node **intersect);                 //判断一个链表是否有环
List_node   *find_circle_first_node(List *list);                //找到带环链表的环入口点

////////////////////////////////////////////////////////////
//////////////////////  接口实现  //////////////////////////
////////////////////////////////////////////////////////////

List        *init_list(void)                        //链表的初始化
{
List *list = (List *)Malloc(sizeof(List));
//    head && tail && count --> NULL/0
bzero(list, sizeof(List));
return list;
}

void        destory_list(List **list)                   //链表的销毁
{
if(list == NULL || *list == NULL){
return;
}
//遍历释放空间
//List *p_list = *list;
//List_node *p_node = p_list->head;
//List_node *q_node = NULL;
//删除链表节点信息
//while(p_node){
//    q_node = p_node;
//    p_node = p_node->next;
//    free(q_node);
//}

//删除链表节点信息
while((*list)->count){
pop_front(*list);
}
//删除链表控制信息
free(*list);
*list = NULL;
}

bool        push_front(List *list, int value)       //头部插入
{
if(list == NULL){
return false;
}

//创建节点并赋值
List_node *node = create_node();
node->data = value;

if(list->count == ZERO){

//  case 1:空链表
//  head && tail -> node_1; count = 1

list->head = list->tail = node;
}else{

// case 2:非空链表
// head -> node_1 ; tail -> node_n; count = n + 1

node->next = list->head;
list->head = node;
}
list->count++;
return true;
}

bool        push_back (List *list, int value)       //尾部插入
{
if(list == NULL){
return false;
}

List_node *node = create_node();
node->data = value;

if(list->count == ZERO){
//case 1: 空链表
list->head = list->tail = node;
}else{
//case 2: 非空链表
list->tail->next = node;
list->tail = node;
}
list->count++;
return true;
}

bool        pop_front (List *list)                  //头部删除
{
if(list == NULL || list->count == ZERO){
return false;
}

List_node *p_node = list->head;

//case 1:只有一个节点
//case 2:大于一个节点

if(list->count == ONLY_ONE){
list->head = list->tail = NULL;
}else{
list->head = list->head->next;
}
free(p_node);
list->count--;
return true;
}

bool        pop_back  (List *list)                  //尾部删除
{
if(list == NULL || list->count == ZERO){
return false;
}

List_node *p_node = list->head;

//case 1:只有一个节点
//case 2:大于一个节点

if(list->count == ONLY_ONE){
list->head = list->tail = NULL;
free(p_node);
}else{
//遍历一遍链表 将p_node指向倒数第二个节点
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)                  //显示链表信息
{
if(list != NULL && list->count != ZERO){
List_node *p_node = list->head;
for( ; p_node; p_node = p_node->next ){
printf("%d\t",p_node->data);
}
printf("\n");
}
}

void        sort_list_ascend (List *list)           //升序排列
{
if(list == NULL || list->count < TWO){
return ;
}

List_node *p_node = NULL;
List_node *q_node = NULL;

unsigned long data_size = 0;
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_descend(List *list)           //降序排列
{
if(list == NULL || list->count < TWO){
return ;
}

List_node *p_node = NULL;
List_node *q_node = NULL;

unsigned long data_size = 0;
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;
}

List        *merge_two_lists       (List *list1, List *list2)   //合并两个有序链表
{
List *result = NULL;
if(list1 == NULL || list2 == NULL){
return result;
}

result = init_list();
List_node *p = list1->head;
List_node *q = list2->head;

// 如果两个链表都没有遍历完，则进行比较
while(p && q){
if(p->data < q->data){
push_back(result, p->data);
p = p->next;
}else{
push_back(result, q->data);
q = q->next;
}
}

//如果有一个比较完了，把另一个直接进行拷贝
if(p == NULL){
while(q){
push_back(result, q->data);
q = q->next;
}
}
if(q == NULL){
while(p){
push_back(result, p->data);
p = p->next;
}
}

return result;
}

List        *merge_two_lists_recure(List *list1, List *list2)   //合并两个有序链表(递归)
{
//使用组件来进行递归输出！
}

List_node   *find_revise_node(List *list, int num)             //找到链表的倒数第num个节点
{
if(list == NULL || num <= 0 && num > list->count){
return NULL;
}

List_node *p = list->head;
int time = list->count - num;

while(time--){
p = p->next;
}

return p;
}

List_node   *find_mid_node   (List *list)                      //找到链表的中间节点
{
// 1.快慢指针：
//  一个一次走两步 一个一次走一步
//
// 2.count/2找指针

if(list == NULL){
return NULL;
}

#if 1
List_node *p = list->head;
List_node *q = p;

while(p){
p = p->next;
if(p){
p = p->next;
}
q = q->next;
}

return q;
#endif

#if 0
List_node *p = list->head;
int time = list->count >> 1;
while(time--){
p = p->next;
}
return p;
#endif
}

List        *reverse_list    (List *list)                     //逆置一个链表
{
if(list == NULL || list->count < TWO){
return list;
}
#if 0
//创建一个新的链表 与数组
int datas[list->count];
List_node *p = list->head;
List *result = init_list();
int i = 0;
for( ; i < list->count; ++i ){
datas[i] = p->data;
p = p->next;
}

for( ; i; --i ){
push_back(result, datas[i-1]);
}
return result;
#endif

#if 1
//不创建新链表 使用三个指针进行赋值
if(list->count == TWO){
//如果只有两个节点
list->tail->next = list->head;
list->head->next = NULL;
return list;
}

List_node *p = list->head;
List_node *q = p->next;
List_node *r = q->next;
p->next = NULL;

do{
q->next = p;
p = q;
q = r;
r = r->next;
}while(r);

q->next = p;

swap(&(list->head), &(list->tail), sizeof(List_node *));
return list;
#endif
}

List        *list_dump       (List *list)                      //链表拷贝
{
if(list == NULL){
return NULL;
}

List *result = init_list();
List_node *p = list->head;

while(p){
push_back(result, p->data);
p = p->next;
}

return result;
}

void        reverse_show_list(List *list)                      //逆序输出一个链表
{
if(list == NULL){
return;
}
//递归逆序输出比较好
reverse_show_list_node(list->head);
//使用组件来输出
}

bool        is_lists_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)   //得到第一个交点
{
if(! is_lists_intersect(list1, list2)){
return NULL;
}

int list1_len = list1->count;
int list2_len = list2->count;
int distance  = 0;

List_node *p = list1->head;
List_node *q = list2->head;

//将始末差距移动到相同距离
if(list1_len > list2_len){
distance = list1_len - list2_len;
while(distance--){
p = p->next;
}
}else{
distance = list2_len - list1_len;
while(distance--){
q = q->next;
}
}

//依次对对应节点进行判断是否相等，相等则为第一个相交界点
while(p != q){
p = p->next;
q = q->next;
}

return p;
}

void        delete_one_node       (List *list, List_node *node)//在O(1)的时间复杂度下删除节点
{
if(list == NULL || node == NULL){
return ;
}

List_node *p = NULL;
if(node != list->tail){
//不是末尾
p = node->next;
node->data = p->data;
node->next = p->next;
free(p);
list->count--;
}else{
//是末尾
pop_back(list);
}
}

bool        has_circle            (List *list, List_node **intersect)                 //判断一个链表是否有环
{
if(list ==NULL || list->count < TWO){
return false;
}
//快慢指针跑环
//如果有环的话两者一定会相遇
List_node *fast = list->head;
List_node *slow = fast;

do{
fast = fast->next;
fast = fast->next;
slow = slow->next;
if(fast == slow){
if(intersect){
//将相交节点赋值给intersect
*intersect = fast;
}
return true;
}
}while(fast && fast->next);

return false;
}

List_node   *find_circle_first_node(List *list)                //找到带环链表的环入口点
{
List_node *intersect = NULL;
if(! has_circle(list, &intersect)){
return NULL;
}

//转化为求两个相交链表的第一个结点的问题
List_node *list1_head = list->head;
List_node *list2_head = intersect->next;

//求得二个链表的长度
List_node *p = list1_head;
List_node *q = list2_head;

int list1_len = 0;
int list2_len = 0;
int distance  = 0;

while(p != intersect){
list1_len++;
p = p->next;
}

while(q != intersect){
list2_len++;
q = q->next;
}

p = list1_head;
q = list2_head;

//移动较长的链表 移动距离为两个长度的差
if(list1_len > list2_len){
distance = list1_len - list2_len;
while(distance--){
p = p->next;
}
}else{
distance = list2_len - list1_len;
while(distance--){
q = q->next;
}
}

while(p != q){
p = p->next;
q = q->next;
}

return q;
}

/////////////////////////////// 测试 //////////////////////////////////////

int main(int argc, char **argv)
{
List* list = init_list();   //initialize
List* list1 = init_list();
List* tmp = NULL;
int i = 0;
for (i = 0; i < 10; ++i){
push_back(list, rand() % 200);
push_back(list1, rand() % 233);
}
printf("list:\n");
sort_list_ascend(list);
show_list(list);
printf("list1:\n");
sort_list_ascend(list1);
show_list(list1);

printf("\nmerge_result:\n");
List* result = merge_two_lists(list, list1);
show_list(result);

List_node *p = find_revise_node(list, 1);
printf("\nrevise_1_p:%d\n", p->data);

List_node *mid = find_mid_node(list);
printf("mid:%d\n", mid->data);

reverse_list(list1);
printf("reve:\n");
show_list(list1);

tmp = list_dump(list1);
printf("copy:\n");
show_list(tmp);
printf("reve_show:\n");
reverse_show_list(tmp);

destory_list(&tmp);
destory_list(&list);
destory_list(&list1);
destory_list(&result);
return 0;
}
#endif