双向链表的排序

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(&gt_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;
}