list头文件
#ifndef _BILATE_LINKED_LIST_H
#define _BILATE_LINKED_LIST_H
#include <stdbool.h>
typedef struct _list_node{
void *_data;
struct _list_node *_next;
struct _list_node *_prev;
} list_node_t;
typedef struct _list_head{
int _lenght;
struct _list_node *_first;
struct _list_node *_last;
} list_t;
/*********************************** create **********************************/
// 创建一个带头节点的空链表
list_t *create_list(void);
/*********************************** destory **********************************/
// 删除一个带头节点的链表
void (*delete_data_function)(void *delete_data);
void destory_list(list_t *plist, void *delete_data);
// 显示链表所有节点的data
typedef void (*print_data_function_t)(void *print_data);
void (*print_data_function)(void *print_data);
void print_list(list_t *plist, print_data_function_t print_func);
/*********************************** insert **********************************/
// 从头部插入一个节点
bool insert_front_node(list_t *plist, list_node_t *pnode);
/********************************* sort ***************************************/
typedef int (*compare_func_t)(void *left, void *right);
int (*compare_func)(void *left, void *right);
void sort_insert(list_t *plist, compare_func_t fcompare);
#endif
list的实现
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include "comlist.h"
#include "comlog.h"
#define null NULL
/*********************************** create **********************************/
// 创建一个带头节点的空链表
list_t *create_list()
{
size_t size = sizeof(list_t);
list_t *head = (list_t *) malloc(size);
if (head != null)
{
LOG_INFO("create list success.");
memset(head, 0, size);
head->_lenght = 0;
head->_first = null;
head->_last = null;
return head;
}
return null;
}
/*********************************** destory **********************************/
// 删除一个带头节点的链表
void destory_list(list_t *plist, void *delete_data)
{
if (plist == null)
{
return;
}
list_node_t *node = plist->_first;
int i = 0;
for (; i < plist->_lenght; i++)
{
list_node_t *_next = node->_next;
delete_data_function = delete_data;
delete_data_function(node->_data);
free(node);
node = _next;
}
free(plist);
}
/*********************************** print ***********************************/
// 显示链表所有节点的data
void print_list(list_t *plist, print_data_function_t print_func)
{
if (plist == null)
{
LOG_WARN("list is null");
return;
}
if (plist->_lenght < 1)
{
LOG_INFO("list not node");
return;
}
list_node_t *node = plist->_first;
int i = 0;
for (; i < plist->_lenght; i++)
{
print_data_function = print_func;
print_data_function(node->_data);
node = node->_next;
}
}
/*********************************** insert **********************************/
// 从头部插入一个数据节点
bool insert_front(list_t *plist, void *data)
{
if (plist == NULL || data == NULL)
{
return false;
}
list_node_t *pnode = (list_node_t *) malloc(sizeof(list_node_t));
if (pnode == null)
{
LOG_WARN("inset front failed, malloc node failed.");
return false;
}
memset(pnode, 0, sizeof(list_node_t));
pnode->_data = data;
if (plist->_first == null && plist->_last == null)
{
pnode->_next = pnode;
pnode->_prev = pnode;
plist->_first = pnode;
plist->_last = pnode;
plist->_lenght ++;
return true;
}
plist->_last->_next = pnode;
plist->_first->_prev = pnode;
pnode->_next = plist->_first;
pnode->_prev = plist->_last;
plist->_first = pnode;
plist->_lenght ++;
return true;
}
/********************************* sort ***************************************/
void sort_insert(list_t *plist, compare_func_t fcompare)
{
LOG_DEBUG("start list sort insert.");
if (fcompare == null)
{
LOG_WARN("param compare function is null, sort failed.");
return;
}
if (plist == NULL)
{
LOG_WARN("list is null. sort failed.");
return;
}
if (plist->_lenght < 1)
{
return;
}
if (plist->_first == null || plist->_first->_data == null
|| plist->_last == null || plist->_last->_data == null)
{
LOG_WARN("list hava null node or data, sort failed.");
return;
}
list_node_t *node = plist->_first->_next;
compare_func = fcompare;
int i = 1;
for (; i < plist->_lenght; i++)
{
list_node_t *node_dup = node;
node = node->_next;
list_node_t *prev = node_dup->_prev;
while(prev != plist->_last)
{
if (compare_func(prev->_data, node_dup->_data) <= 0)
{
if (prev == node_dup->_prev)
{
break;
}
node_dup->_prev->_next = node_dup->_next;
node_dup->_prev->_next->_prev = node_dup->_prev;
node_dup->_next = prev->_next;
node_dup->_next->_prev = node_dup;
node_dup->_prev = prev;
node_dup->_prev->_next = node_dup;
break;
}
else if (prev == plist->_first)
{
// insert_front_node(plist, node_dup);
node_dup->_prev->_next = node_dup->_next;
node_dup->_next->_prev = node_dup->_prev;
node_dup->_next = prev;
node_dup->_prev = prev->_prev;
node_dup->_next->_prev = node_dup;
node_dup->_prev->_next = node_dup;
plist->_first = node_dup;
break;
}
prev = prev->_prev;
}
}
}
测试程序 test 的头文件
#ifndef _TEST_H
#define _TEST_H
typedef struct _time_interval_type{
char *_begin_time;
char *_end_time;
}time_interval_t;
#endif
测试程序test.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
// #define LOG_PRINT // 打印日志
#include "comlist.h"
#include "comlog.h"
#include "test.h"
#define null NULL
// 时间
static time_t g_time;
static char *_date();
time_interval_t *create_time_inter(const char *_begin_time, const char *_endtime);
void ptintf_data(void *data);
int compare( void *left, void *right);
void delete_data(void *data);
int main()
{
LOG_INFO("(%s) start main.", _date());
list_t *plist = create_list();
time_interval_t *tmp = null;
tmp = create_time_inter("00:01:00", "03:00:00");
insert_front(plist, tmp);
tmp = create_time_inter("02:00:00", "05:00:00");
insert_front(plist, tmp);
tmp = create_time_inter("07:00:00", "09:00:00");
insert_front(plist, tmp);
tmp = create_time_inter("17:00:00", "23:00:00");
insert_front(plist, tmp);
tmp = create_time_inter("18:00:00", "23:00:00");
insert_front(plist, tmp);
tmp = create_time_inter("08:00:00", "26:00:00");
insert_front(plist, tmp);
tmp = create_time_inter("02:00:00", "05:00:00");
insert_front(plist, tmp);
sort_insert(plist, compare);
union_node(plist);
print_list(plist, ptintf_data);
destory_list(plist, delete_data);
return 0;
}
void union_node(list_t *plist)
{
if (plist == null)
{
LOG_ERROR("list is null");
return;
}
list_node_t *node = plist->_first->_next;
int i = 1;
int len = plist->_lenght;
for(; i < len; i++)
{
list_node_t *tmp = node;
time_interval_t *pt = (time_interval_t *) (tmp->_prev->_data);
time_interval_t *ct = (time_interval_t *) (tmp->_data);
if (strcmp(pt->_end_time, ct->_begin_time) >= 0)
{
if (strcmp(ct->_end_time, pt->_end_time) > 0)
{
LOG_INFO("{ct end > pt end} | pt [%s-%s], ct[%s-%s].",
pt->_begin_time, pt->_end_time, ct->_begin_time, ct->_end_time);
free(pt->_end_time);
pt->_end_time = ct->_end_time;
free(ct->_begin_time);
free(ct);
}
else
{
LOG_INFO("{ct end <= pt end} | pt [%s-%s], ct[%s-%s].",
pt->_begin_time, pt->_end_time, ct->_begin_time, ct->_end_time);
free(ct->_begin_time);
free(ct->_end_time);
free(ct);
}
tmp->_next->_prev = tmp->_prev;
tmp->_prev->_next = tmp->_next;
node = node->_next;
free(tmp);
plist->_lenght--;
continue;
}
LOG_INFO("{ct begin > pt end} | pt [%s-%s], ct[%s-%s].",
pt->_begin_time, pt->_end_time, ct->_begin_time, ct->_end_time);
node = node->_next;
}
}
void delete_data(void *data)
{
time_interval_t *_data = (time_interval_t *) data;
free(_data->_begin_time);
free(_data->_end_time);
}
int compare(void *left, void *right)
{
if (left == null || right == null)
{
LOG_ERROR("compare function params is null.");
return 0;
}
time_interval_t *left_date = (time_interval_t *) left;
time_interval_t *right_data = (time_interval_t *) right;
LOG_DEBUG("call commpare. left:(%s) - right:(%s).", left_date->_begin_time, right_data->_begin_time);
size_t left_len = strlen(left_date->_begin_time);
size_t right_len = strlen(right_data->_begin_time);
size_t len = (left_len > right_len) ? left_len : right_len;
return strncmp(right_data->_begin_time, left_date->_begin_time, len);
}
time_interval_t *create_time_inter(const char *_begin_time, const char *_end_time)
{
LOG_INFO("create time interval node [%s-%s]", _begin_time, _end_time);
time_interval_t *ret = (time_interval_t *) malloc(sizeof(time_interval_t));
if (ret == null)
{
LOG_ERROR("create time interval node failed. [%s-%s]", _begin_time, _end_time);
return null;
}
size_t _begin_len = strlen(_begin_time);
char *_begin_t = (char *) malloc(_begin_len + 1);
if (_begin_t == null)
{
LOG_ERROR("create time interval begin time node failed. [%s]", _begin_time);
return null;
}
size_t _end_len = strlen(_end_time);
char *_end_t = (char *) malloc(_end_len + 1);
if (_end_t == null)
{
LOG_ERROR("create time interval end time node failed. [%s]", _end_time);
return null;
}
memset(_begin_t, 0, _begin_len + 1);
memset(_end_t, 0, _end_len + 1);
strncpy(_begin_t, _begin_time, _begin_len);
strncpy(_end_t, _end_time, _end_len);
ret->_begin_time = _begin_t;
ret->_end_time = _end_t;
return ret;
}
void ptintf_data(void *data)
{
time_interval_t *tm = (time_interval_t *) data;
LOG_INFO("[%s-%s]", tm->_begin_time, tm->_end_time);
}
char *_date()
{
g_time = time(NULL);
// struct tm *tm_time;
//tm_time = gmtime(>_time);
//格式化输出
// strftime(_date_cache, DATE_FORMAT_SIZE, "%F-%T", tm_time);
char *_dt = ctime(&g_time);
size_t len = strlen(_dt);
*(_dt + len - 1) = 0;
return _dt;
}