General Dlist Implement by C

最新推荐文章于 2021-09-01 22:55:43 发布
最新推荐文章于 2021-09-01 22:55:43 发布
阅读量104 收藏
点赞数
原文链接：http://www.cnblogs.com/WIT-Evan/archive/2011/08/14/7291515.html
版权 
/*dlist.c by xianjimli*/
#include <stdio.h>
#include <stdlib.h>
#include "dlist.h"

typedef struct _DListNode
{
	struct _DListNode* next;
	struct _DListNode* prev;

	void* data;
} DListNode;

struct _DList
{
	DListNode* first;
	void* data_destroy_ctx;
	DListDataDestroyFunc data_destroy;
};

static void dlist_destroy_data(DList* thiz, void* data)
{
	if (NULL != thiz->data_destroy) {
		thiz->data_destroy(thiz->data_destroy_ctx, data);
	}
	
	return;
}

static DListNode* dlist_node_create(DList* thiz, void* data)
{
	DListNode* node	= (DListNode*)malloc(sizeof(DListNode));
	if (NULL != node) {
		node->next = NULL;
		node->prev = NULL;
		node->data = data;
	}
	
	return node;
}

static void dlist_node_destroy(DList* thiz, DListNode* node)
{
	if (NULL != node) {
		node->next = NULL;
		node->prev = NULL;
		dlist_destroy_data(thiz, node->data);
	}
	free(node);
	
	return;
}

DList* dlist_create(DListDataDestroyFunc data_destroy, void* data_destroy_ctx)
{
	DList* thiz = malloc(sizeof(DList));
	if (NULL != thiz) {
		thiz->first = NULL;
		thiz->data_destroy = data_destroy;
		thiz->data_destroy_ctx = data_destroy_ctx;
	}

	return thiz;
}

static DListNode* dlist_get_node(DList* thiz, size_t index, int fail_return_last)
{
	DListNode* iter = NULL;
	return_val_if_fail(thiz != NULL, NULL);
	
	iter = thiz->first;
	while (iter != NULL && iter->next != NULL && index > 0) {
		iter = iter->next;
		index--;
	}

	if (!fail_return_last) {
		iter = index > 0 ? NULL : iter;
	}

	return iter;
}

DListRet dlist_insert(DList* thiz, size_t index, void* data)
{
	DListNode* node = NULL;
	DListNode* cursor = NULL;

	return_val_if_fail(NULL != thiz, DLIST_RET_INVALID_PARAMS);
	
	if ((node = dlist_node_create(thiz, data)) == NULL) {
		return DLIST_RET_OOM;
	}	

	if (thiz->first == NULL) {
		thiz->first = node;
		return DLIST_RET_OK;
	}	

	cursor = dlist_get_node(thiz, index, 1);
	if (index < dlist_length(thiz)) {
		if (cursor == thiz->first) {
			thiz->first = node;
		} else {
			cursor->prev->next = node;
			node->prev = cursor->prev;
		}
		node->next = cursor;
		cursor->prev = node;
	} else {
		cursor->next = node;
		node->prev = cursor;
	}

	return DLIST_RET_OK;
}

DListRet dlist_prepend(DList* thiz, void* data)
{
	return dlist_insert(thiz, 0, data);
}

DListRet dlist_append(DList* thiz, void* data)
{
	return dlist_insert(thiz, -1, data);
}

DListRet dlist_delete(DList* thiz, size_t index)
{
	DListNode* cursor = dlist_get_node(thiz, index, 0);
	
	return_val_if_fail(NULL != thiz, DLIST_RET_INVALID_PARAMS);
	
	if (cursor != NULL) {
		if (cursor == thiz->first) {
			thiz->first = cursor->next;
		}
		if (cursor->next != NULL) {
			cursor->next->prev = cursor->prev;
		}
		if (cursor->prev != NULL) {
			cursor->prev->next = cursor->next;
		}
		
		dlist_node_destroy(thiz, cursor);
	}
	
	return DLIST_RET_OK;
}

DListRet dlist_get_by_index(DList* thiz, size_t index, void** data)
{
	DListNode* cursor = dlist_get_node(thiz, index, 0);
	
	return_val_if_fail(cursor != NULL, DLIST_RET_INVALID_PARAMS);
	
	*data = cursor->data;
	
	return DLIST_RET_OK;
}

DListRet dlist_set_by_index(DList* thiz, size_t index, void* data)
{
	DListNode* cursor = dlist_get_node(thiz, index, 0);
	
	return_val_if_fail(cursor != NULL, DLIST_RET_INVALID_PARAMS);
	
	cursor->data = data;
	
	return DLIST_RET_OK;
}

size_t dlist_length(DList* thiz)
{
	size_t length = 0;
	DListNode* iter = NULL;
	
	return_val_if_fail(thiz != NULL, 0);
	
	iter = thiz->first;
	while (iter != NULL)
	{
		length++;
		iter = iter->next;
	}
	
	return length;
}

DListRet dlist_foreach(DList* thiz, DListDataVisitFunc visit, void* ctx)
{
	DListNode* iter = NULL;
	DListRet ret = DLIST_RET_OK;	

	return_val_if_fail(thiz != NULL && visit != NULL, DLIST_RET_INVALID_PARAMS);
	
	iter = thiz->first;
	while (iter != NULL) {
		ret = visit(ctx, iter->data);
		iter = iter->next;
	}
	
	return ret;
}

int dlist_find(DList* thiz, DListDataCompareFunc cmp, void* ctx)
{
	int index = 0;
	DListNode* iter = NULL;

	return_val_if_fail(thiz != NULL && cmp != NULL, -1);

	iter = thiz->first;
	while (iter != NULL) {
		if (0 == cmp(ctx, iter->data)) {
			break;
		}
		index++;
		iter = iter->next;
	}

	return index;
}	

void dlist_destroy(DList* thiz)
{
	DListNode* iter = NULL;
	DListNode* next = NULL;
	return_if_fail(thiz != NULL);
	
	iter = thiz->first;
	while (iter != NULL) {
		next = iter->next;
		dlist_destroy_data(thiz, iter);
		iter = next;
	}
	thiz->first = NULL;
	free(thiz);

	return;
}

#ifdef DLIST_TEST
#include <assert.h>
static void dlist_data_destroy(void* ctx, void* data)
{
	
}

static int dlist_data_cmp(void* ctx, void* data)
{
	return (int)ctx - (int)data;
}

static DListRet dlist_data_visit(void* ctx, void* data)
{
	int* expected = (int*)ctx;
	assert((*expected) == (int)data);
	(*expected)--;
	return DLIST_RET_OK;
}

void test_int_dlist(void)
{
	int i = 0;
	int data = 0;
	int n = 100;
	int s = 0;

	DList* dlist = dlist_create(NULL, NULL);
	for (i = 0; i < n; i++) {
		assert(DLIST_RET_OK == dlist_append(dlist, (void*)i));
		assert(dlist_length(dlist) == i+1);
		assert(DLIST_RET_OK == dlist_get_by_index(dlist, i, (void**)&data));
		assert(i == data);
		assert(DLIST_RET_OK == dlist_set_by_index(dlist, i, (void*)(i*2)));
		assert(DLIST_RET_OK == dlist_get_by_index(dlist, i, (void**)&data));
		assert(data == 2*i);
		assert(DLIST_RET_OK == dlist_set_by_index(dlist, i, (void*)i));
		assert(i == dlist_find(dlist, dlist_data_cmp, (void*)i));		
	}

	data = dlist_length(dlist);
	for (i = 0; i < n; i++) {
		assert(DLIST_RET_OK == dlist_get_by_index(dlist, 0, (void**)&data));
		assert(i == data);
		assert(dlist_length(dlist) == (n-i));
		assert(dlist_delete(dlist, 0) == DLIST_RET_OK);
		assert(dlist_length(dlist) == (n-i-1));
		if ((i + 1) < n) {
			assert(dlist_get_by_index(dlist, 0, (void**)&data) == DLIST_RET_OK);
			assert(data == (i+1));
		}
	}

	assert(dlist_length(dlist) == 0);
	for (i = 0; i < n; i++) {
		assert(dlist_prepend(dlist, (void*)i) == DLIST_RET_OK);
		assert(dlist_length(dlist) == i+1);
		assert(dlist_get_by_index(dlist, 0, (void**)&data) == DLIST_RET_OK);
		assert(data == i);
		assert(dlist_set_by_index(dlist, 0 ,(void*)(2*i)) == DLIST_RET_OK);
		assert(dlist_get_by_index(dlist, 0, (void**)&data) == DLIST_RET_OK);
		assert(data == 2*i);
		assert(DLIST_RET_OK == dlist_set_by_index(dlist, 0, (void*)i));
	}
	i = n - 1;
	assert(DLIST_RET_OK == dlist_foreach(dlist, dlist_data_visit, &i));

	s = dlist_length(dlist);
	for (i = 0; i < n; i++) {
		assert(dlist_insert(dlist, i, (void*)i) == DLIST_RET_OK);
		assert(dlist_length(dlist) == (s+i+1));
		assert(dlist_get_by_index(dlist, i, (void**)&data) == DLIST_RET_OK);
		assert(data == i);
		assert(dlist_set_by_index(dlist, i, (void*)(2*i)) == DLIST_RET_OK);
		assert(dlist_get_by_index(dlist, i, (void**)&data) == DLISech(NULL, NULL, NULL) == DLIST_RET_INVALID_RET_OK);
		assert(data == 2*i);
	}	
	dlist_destroy(dlist);
		
	return;
}

static void test_invalid_params(void)
{
	assert(dlist_length(NULL) == DLIST_RET_INVALID_PARAMS);
	assert(dlist_prepend(NULL, 0) == DLIST_RET_INVALID_PARAMS);
	assert(dlist_delete(NULL, 0) == DLIST_RET_INVALID_PARAMS);
	assert(dlist_insert(NULL, 0, NULL) == DLIST_RET_INVALID_PARAMS);
	assert(dlist_set_by_index(NULL, 0, NULL) == DLIST_RET_INVALID_PARAMS);
	assert(dlist_get_by_index(NULL, 0, NULL) == DLIST_RET_INVALID_PARAMS);
	assert(dlist_find(NULL, NULL, NULL) < 0);
	assert(dlist_append(NULL, 0) == DLIST_RET_INVALID_PARAMS);
	assert(dlist_foreach(NULL, NULL, NULL) == DLIST_RET_INVALID_PARAMS);
}

int main(int argc,char** argv)
{
	printf("%s\n", "test_dlist_begin");
	test_int_dlist();
	return 0;
}

#endif /*DLIST_TEST*/


/*dlist.h*/
#include <stdio.h>

#ifndef _DLIST_H
#define _DLIST_H

#ifdef __cplusplus
extern "c" {
#endif /*__cplusplus*/

typedef enum _DListRet
{
    DLIST_RET_OK,
    DLIST_RET_OOM,
    DLIST_RET_STOP,
    DLIST_RET_INVALID_PARAMS,
    DLIST_RET_FAIL
} DListRet;

struct _DList;
typedef struct _DList DList;

typedef void (*DListDataDestroyFunc)(void* ctx, void* data);
typedef int (*DListDataCompareFunc)(void* ctx, void* data);
typedef DListRet (*DListDataVisitFunc)(void* ctx, void* data);

DList* dlist_create(DListDataDestroyFunc data_destroy, void* data_destroy_ctx);
DListRet dlist_insert(DList* thiz, size_t index, void* data);
DListRet dlist_prepend(DList* thiz, void* data);
DListRet dlist_append(DList* thiz, void* data);
DListRet dlist_delete(DList* thiz, size_t index);
DListRet dlist_get_by_index(DList* thiz, size_t index, void** data);
DListRet dlist_set_by_index(DList* thiz, size_t index, void* data);

size_t     dlist_length(DList* thiz);
int     dlist_find(DList* thiz, DListDataCompareFunc cmp, void* ctx);
DListRet dlist_foreach(DList* thiz, DListDataVisitFunc visit, void* ctx);

void dlist_destroy(DList* thiz);

#define return_if_fail(p) if (!(p)) \
    {printf("%s:%d Warning:"#p" failed.\n", \
        __func__, __LINE__); return;}
#define return_val_if_fail(p, ret) if (!(p)) \
    {printf("%s:%d Warning:"#p" failed.\n", \
        __func__, __LINE__); return (ret);}

#ifdef __cplusplus
}
#endif /*__cplusplus*/

#endif /*_DLIST_H*/


 /*Makefile*/all:    gcc -g -shared dlist.c -o libdlist.so    gcc -g -DDLIST_TEST dlist.c -o dlist_testclean:    rm  *test *.exe *.so *.o 
 
 

 

转载于:https://www.cnblogs.com/WIT-Evan/archive/2011/08/14/7291515.html

                

        

        




    

  


    

      

        

            

              
                
                  weixin_30718391
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
【DS】带头双向循环链表之C语言实现

				
			

			

				

					进阶之路 
				

				

					02-03
					
					222
					
				

			

		

		

			
				
带头双向循环链表的实现
DList.h文件
#pragma once
#include <stdio.h>
#include <assert.h>
#include <malloc.h>

typedef int DLTDataType;

typedef struct DListNode    // 循环链表节点
{
	DLTDataType _data;
	...

			
		

	



                

              
                



	

		

			

				
					
数据结构-双向循环链表（实现增，删，改，查）

				
			

			

				

					Ray的博客
				

				

					07-12
					
					253
					
				

			

		

		

			
				
循环链表



			
		

	



                


  
              

                


	

		

			

				
					
c语言栈区循环,c语言之————有头循环双链表实现栈存储

				
			

			

				

					weixin_28913019的博客
				

				

					05-24
					
					206
					
				

			

		

		

			
				
栈的原理是先进的后出来1、链表的实现dlist.h/**dlist.h*描述：*有头循环双表*Data:*2014-07-21*/#pragma once#include #include #include struct node_info{struct node_info *prev;struct node_info *next;char par[];  /*0长数组，不占空间*/};struc...

			
		

	





	

		

			

				
					
循环链表出入队列c语言代码,c语言之————有头循环双链表实现队列存储

				
			

			

				

					weixin_32369749的博客
				

				

					05-21
					
					124
					
				

			

		

		

			
				
1、链表dlist.h/**dlist.h*描述：*有头循环双表*Data:*2014-07-21*/#pragma once#include #include #include struct node_info{struct node_info *prev;struct node_info *next;char par[];  /*0长数组，不占空间*/};struct list_info{st...

			
		

	



		

			
		



	

		

			

				
					
数据结构（3）——双链表的实现

				
			

			

				

					思い出·物语的第一篇博客
				

				

					09-01
					
					204
					
				

			

		

		

			
				
在数据结构（2）中，我实现了其中一种较为常用的链表形式-单向无头不循环链表。那在这篇博客中，我来实现另一种——双向有头循环链表。

结构示意图:

该链表

包含一个哨兵位的头结点，该结点的data成员不存储实际数值；
每一个结点都有两个指针，分别指向上一个结点的后指针和下一个结点的前指针；
最后一个结点的后指针指向哨兵位头结点的前指针，构成闭环；

双向有头循环链表结构较为复杂，实现起来也需要较多的思维量和代码量，但是在运用时会比单向链表方便很多。这次我们也是分为三个文件：


Dlist.h
Dlis.

			
		

	





	

		

			

				
					
functional programming

				
			

			

				

					leon3389的专栏
				

				

					05-22
					
					8108
					
				

			

		

		

			
				
 Why Functional Programming?Functional programs contain no assignment statements, so variables, once given a value, never change. More generally, functional programs contain no side-effects at all. A ...

			
		

	





	

		

			

				
					
Dlist2.rar_C/C++_

				
			

			

				

					08-11
				

			

		

		

			
				
标题中的"Dlist2.rar"可能是指一个C或C++编程项目，其中包含了名为"Dlist2"的数据结构或算法实现。这个项目的重点可能是关于双向链表（Doubly Linked List）的实现，因为“Dlist”通常代表“Doubly Linked List”。...

			
		

	





	

		

			

				
					
Dlist_链表_

				
			

			

				

					09-30
				

			

		

		

			
				
运算符重载部分，`Dlist operator+(const Dlist& other)`和`Dlist& operator+=(const Dlist& other)`实现了链表的合并操作，可能是通过创建新的节点将两个链表串联起来。  在`Dlist.cpp`中，会实现这些成员函数的...

			
		

	





	

		

			

				
					
Dlist.cpp

				
			

			

				

					10-27
				

			

		

		

			
				
Dlist.cpp

			
		

	





	

		

			

				
					
dlist：Haskell中的差异列表

				
			

			

				

					02-04
				

			

		

		

			
				
import Data.DList  -- 创建一个差异列表，表示在任何列表后面添加1,2,3 dl = singleton 1 <> singleton 2 <> singleton 3  -- 将差异列表应用于空列表，得到[1,2,3] normalList = execDList dl []  -- 使用差异列表...

			
		

	





	

		

			

				
					
zephyr学习笔记---双向链表dlist

				
			

			

				

					abatei的专栏
				

				

					04-20
					
					2599
					
				

			

		

		

			
				
现阶段学zephyr很困难，没有足够资料，东一锤子，西一榔头，转来转去还是转回数据结构。没办法，这几个数据结构是其它各类机制的基础，不研究一下还真不行。静下心来先搞数据结构吧。上次讲了单向链表slist，这次再弄个双向链表dlist。




先来看看结点的数据结构：





struct _dnode
{
    union
    {
        struc

			
		

	





	

		

			

				
					
c语言之————无头循环双链表

				
			

			

				

					long123bin的专栏
				

				

					07-21
					
					620
					
				

			

		

		

			
				
本例是用双链表实现的统计学生信息程序
dlist.h

			
		

	





	

		

			

				
					
C 算法精介----链表->双向链表

				
			

			

				

					TTc 's share
				

				

					02-02
					
					577
					
				

			

		

		

			
				
双向链表




双向链表,如同名字所暗示的那样，链表元素之间由2个指针链接，双向链表中的每一个元素都有3部分组成：除了数据成员和指针next外，新增加了一个指针prev，指向其前驱元素的指针。下图清晰绘出双向链表的结构：






//
//  DList.c
//  Algorithms&Data_structures
//
//  Created by TTc on

			
		

	





	

		

			

				
					
湖北工业大学在河南2021-2024各专业最低录取分数及位次表.pdf

					
最新发布

				
			

			

				

					09-16
				

			

		

		

			
				
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据

			
		

	





	

		

			

				
					
西南交通大学在河南2021-2024各专业最低录取分数及位次表.pdf

				
			

			

				

					09-16
				

			

		

		

			
				
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据

			
		

	





	

		

			

				
					
DAY27使用的实时脚本文件

				
			

			

				

					09-16
				

			

		

		

			
				
博客链接：https://blog.csdn.net/qq_47248729/article/details/142303818?spm=1001.2014.3001.5502

			
		

	





	

		

			

				
					
天水师范学院在河北2021-2024各专业最低录取分数及位次表.pdf

				
			

			

				

					09-16
				

			

		

		

			
				
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据

			
		

	





	

		

			

				
					
matlab simulink 双馈风机调频，风电调频，风火水调频，虚拟惯性控制，下垂控制
参与系统一次调频的Matlab Si

				
			

			

				

					09-16
				

			

		

		

			
				
matlab simulink 双馈风机调频，风电调频，风火水调频，虚拟惯性控制，下垂控制
参与系统一次调频的Matlab Simulink模型
系统为三机九节点模型，所有参数已调好且可调，可直接运行，风电渗透率20%
也可研究风火联合，火电调频等。有同步机调速器。
风电调频，IEEE9节点，双馈风机调频，一次调频，火电调频，同步机调频。
同步机部分带有调速器等部分。并网电压电流。
风电附带下垂控制，虚拟惯性控制，风电渗透率20%，有参考文献。也可研究风电并网，并网电压，电流波形



			
		

	





	

		

			

				
					
LEFT JOIN (select dl.DecHead_List_ID,count(dl.id) decListsCount from DecList dl group by dl.DecHead_List_ID) as dList on d.id=dList.DecHead_List_ID

				
			

			

				

					06-08
				

			

		

		

			
				
select dl.DecHead_List_ID,count(dl.id) decListsCount from DecList dl group by dl.DecHead_List_ID ```  这是一个子查询，它从 DecList 表中选取 DecHead_List_ID 和 id 两列数据，并按照 DecHead_List_ID 进行...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值