单链表/单循环链表/双链表/双循环链表_C语言实现

最新推荐文章于 2023-04-19 10:32:00 发布
最新推荐文章于 2023-04-19 10:32:00 发布
阅读量442 收藏 1
点赞数
分类专栏： C语言 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37515325/article/details/114746701
版权

    本文对单链表/单循环链表/双链表/双循环链表_C语言进行实现。

    实现如下6个操作:

  1. 初始化init 
  2. 插入insert（指定插入位置和插入元素）
  3. 替换replace（用指定的元素替换某个位置的元素）
  4. del删除指定节点 
  5. find根据值查找某个节点，找到返回所在的pos，否则返回失败 
  6. prt打印整个链表

     首先对头结点、头指针的意义明确下：

头结点（大话数据结构P58对头结点和头指针的比较分析）：

头结点是为了操作的统一和方便设立的，放在第一元素的节点之前，其数据域一般无意义（也可存放链表长度）
头指针是指指向链表第一个节点的指针，如果没有头结点，头指针指向的就是第一个节点;如果有头结点，头指针指向的就是头结点。

    相关tips:

1.因为单链表必须要用头结点，否则在头位置的插入，删除都会很麻烦。--数据结构与算法分析C语言描述..P33页，

2.双链表也必须要用表头

3.对于init/insert/delete/prt/find 5个API,双链表在单链表的基础上只是需要修改insert(插入时要修改插入节点后一节点的prev指针)和delete(插入时要修改插入节点后一节点的prev指针)两个API

3.循环链表有没有表头都可以（数据结构与算法分析C语言描述..P38页），为了和单链表、双链表保持一致，使用带表头的版本

4.单链表和单循环链表的区别

  将单链表的最后一个元素的next指针指向头结点，就成了单循环链表。

  单循环链表可以表中任一位置出发即可访问全部节点。而单链表只能访问当前位置之后的节点。

  单链表的终止条件；p!=NULL或p->next!=NULL,而单循环链表的终止条件是：p!=head或者p->next!=head

5.单链表和双链表的区别

  双链表多了个指向前趋元素的prev指针，每个节点都比单链表多占用一个指针大小的空间

  单链表只能实现单向查找，而双链表可以实现双向查找，对于单链表而言，要查找上一节点必须要遍历链表，时间复杂度是O(n),而双链表就非常方便了。

6.insert操作有两种，一种是指定插入的pos和ele,要直接插入在指定位置，第二种是不指定插入位置，默认插入在最后。第二种比较简单，只实现第一种。

7.注意insert操作和replace操作，insert可以插入到链表末尾，比如链表的size=5，可以指定插入位置=6(插入到末尾)。而replace只能替换链表里已有的元素，所以终止条件有区别。这点在代码里要注意。

上传单链表/单循环链表/双链表/双循环链表C语言实现版本：

单链表：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>  //signal()
#include<string.h>
#include<sys/stat.h>
#include<time.h>
#include<stdarg.h>

#if 1
#define INFO_DEBUG    "%d lines in "__FILE__", complie time is "__TIME__" "__DATE__" \n",__LINE__
#define ADI_RUN_ERROR      1
#define ADI_NULL_POINTER  -1
#define ADI_OK             0
#define ADI_PRINT         printf("[%s][%d]:",__FUNCTION__,__LINE__);printf
#define ADI_ASSERT(c,prt,ret)       if(c) {printf(prt);return ret;}
#endif

typedef struct list{
    int elem;
    struct list *next;
}list;

#define PARAM_FAIL -1
#define P_NULL -2
#define SUCCESS 0

/*初始化：只创建头结点*/
list* initList()
{
    list *head = (list*)malloc(sizeof(list));
    if(NULL==head) {printf("NULL");return head;}
    head->next = NULL;
    return head;
}

/*pos从0开始，pos=0为第一个*/
int insertList(list *list_insert,int elem,int pos)
{
    int i=0;
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;//取头指针
    while(i<pos && NULL != head)//i比head快一个，i=1时p指向的是第0个元素
    {
        head = head->next;
        i++;
    }

    if(NULL != head)
    {
		list *node = (list*)malloc(sizeof(list));
		if(NULL==node) {printf("NULL");return P_NULL;}
		node->next = head->next;
		node->elem = elem;
		head->next = node;
		ADI_PRINT("insert elem = %d\n",elem);
    }
    else
    {
       ADI_PRINT("pos err\n");
       return PARAM_FAIL;
    }

    return SUCCESS;
}


/*pos从0开始，pos=0为第一个*/
int replaceList(list *list_insert,int elem,int pos)
{
    int i=0;
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;//取头指针
    while(i<pos && NULL != head)//i比head快一个，i=1时head指向的是第0个元素
    {
        head = head->next;
        i++;
    }

    if(NULL != head && NULL != head->next)
    {
		head->next->elem = elem;
		ADI_PRINT("change elem = %d,pos = %d\n",elem,pos);
    }
    else
    {
       ADI_PRINT("pos err\n");
       return PARAM_FAIL;
    }

    return SUCCESS;
}

int delList(list *list_insert,int elem)
{
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;
    while(NULL != head->next)
    {
		if(elem == head->next->elem)
		{
		    list *del = head->next;
        	head->next = head->next->next;
        	free(del);
        	ADI_PRINT("del ele = %d\n",elem);
        	return SUCCESS;
		}
		head = head->next;
    }

	ADI_PRINT("can not find ele = %d\n",elem);
    return PARAM_FAIL;
}

/*pos为在链表中的位置,ele为待查找的元素*/
int findList(list *listFind,int ele,int *pos)
{
    if(NULL == listFind)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    int i = 0;
    list *head = listFind;
    while(NULL != head->next)
    {
		if(ele == head->next->elem)
		{
        	*pos = i;
        	return SUCCESS;
		}
		i++;
		head = head->next;
    }

	ADI_PRINT("can not find ele = %d\n",ele);
    return PARAM_FAIL;
}

int printList(list *list_prt)
{
    if(NULL == list_prt)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }
    int i = 0;

    while(NULL != list_prt->next)
    { 
        list_prt = list_prt->next;
        ADI_PRINT("list[%d] = %d\n",i,list_prt->elem);
        i++;
    }


    return SUCCESS;
}

int main()
{
    int ret = 0,pos = 0;
    list *list_test = initList();
    if(NULL == list_test)
    {
        ADI_PRINT("err \n");
        return P_NULL;
    }

    ret = insertList(list_test,0,0);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,3,1);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,5,2);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,7,3);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,9,4);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    printList(list_test);

    ret = findList(list_test,9,&pos);
    if(SUCCESS != ret) {ADI_PRINT("find err\n");return PARAM_FAIL;}
    ADI_PRINT("ele=9 pos = %d\n",pos);
    
    ret = delList(list_test,3);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}  
    ret = delList(list_test,7);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}  
    ret = delList(list_test,9);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;} 
    printList(list_test);

    ret = replaceList(list_test,2,2);
    if(SUCCESS != ret) {ADI_PRINT("change err\n");return PARAM_FAIL;}  
    printList(list_test);    

    
    return SUCCESS;
}

单循环链表：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>  //signal()
#include<string.h>
#include<sys/stat.h>
#include<time.h>
#include<stdarg.h>

#if 1
#define INFO_DEBUG    "%d lines in "__FILE__", complie time is "__TIME__" "__DATE__" \n",__LINE__
#define ADI_RUN_ERROR      1
#define ADI_NULL_POINTER  -1
#define ADI_OK             0
#define ADI_PRINT         printf("[%s][%d]:",__FUNCTION__,__LINE__);printf
#define ADI_ASSERT(c,prt,ret)       if(c) {printf(prt);return ret;}
#endif

typedef struct list{
    int elem;
    struct list *next;
}list;

#define PARAM_FAIL -1
#define P_NULL -2
#define SUCCESS 0

/*初始化：只创建头结点*/
list* initList()
{
    list *head = (list*)malloc(sizeof(list));
    if(NULL==head) {printf("NULL");return head;}
    head->next = head;
    return head;
}

/*pos从0开始，pos=0为第一个*/
/*如果循环链表插入操作指定插入位置pos,会麻烦些，如下，如果不指定位置，默认插入到最后，会比较简单*/
int insertList(list *list_insert,int elem,int pos)
{
    int i=0;
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;//取头指针
    while(i<pos && list_insert != head->next)
    {
        head = head->next;
        i++;
        //i比head快一个，i=1时head指向的是第0个元素
    }

    if((list_insert==head->next)&&(i<pos))//已经到链表尾部，但是pos>i,说明指定的插入位置超过了链表的末尾位置
    {
		ADI_PRINT("pos = %d, list's last = %d,pos>i,insert err!\n",pos,i);
		return PARAM_FAIL;
    }
    else
    {
		list *node = (list*)malloc(sizeof(list));
		if(NULL==node) {printf("NULL");return P_NULL;}
		node->next = head->next;
		node->elem = elem;
		head->next = node;
		ADI_PRINT("insert elem = %d\n",elem);
    }

    return SUCCESS;
}


/*pos从0开始，pos=0为第一个*/
int replaceList(list *list_insert,int elem,int pos)
{
    int i=0;
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;//取头指针
    while(i<pos && list_insert != head->next)
    {
        head = head->next;
        i++;
        //i比head快一个，i=1时head指向的是第0个元素
    }

    if(list_insert==head->next)//已经到链表尾部，说明指定的修改位置超过了链表原有大小
    {
		ADI_PRINT("pos = %d, list's last = %d,change err!\n",pos,i);
		return PARAM_FAIL;
    }
    else
    {
		head->next->elem = elem;
		ADI_PRINT("change elem = %d,pos = %d\n",elem,pos);
    }

    return SUCCESS;
}

int delList(list *list_insert,int elem)
{
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;
    while(list_insert != head->next)
    {
		if(elem == head->next->elem)
		{
		    list *del = head->next;
        	head->next = head->next->next;
        	free(del);
        	ADI_PRINT("del ele = %d\n",elem);
        	return SUCCESS;
		}
		head = head->next;
    }

	ADI_PRINT("can not find ele = %d\n",elem);
    return PARAM_FAIL;
}

/*pos为在链表中的位置,ele为待查找的元素*/
int findList(list *listFind,int ele,int *pos)
{
    if(NULL == listFind)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    int i = 0;
    list *head = listFind;
    while(listFind != head->next)
    {
		if(ele == head->next->elem)
		{
        	*pos = i;
        	return SUCCESS;
		}
		i++;
		head = head->next;
    }

	ADI_PRINT("can not find ele = %d\n",ele);
    return PARAM_FAIL;
}

int printList(list *list_prt)
{
    if(NULL == list_prt)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }
    int i = 0;

    list *head = list_prt;
    while(head != list_prt->next)
    { 
        list_prt = list_prt->next;
        ADI_PRINT("list[%d] = %d\n",i,list_prt->elem);
        i++;
    }


    return SUCCESS;
}

int main()
{
    int ret = 0,pos = 0;
    list *list_test = initList();
    if(NULL == list_test)
    {
        ADI_PRINT("err \n");
        return P_NULL;
    }

    ret = insertList(list_test,0,0);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,3,1);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,5,2);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,7,3);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,9,4);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    printList(list_test);

    ret = findList(list_test,9,&pos);
    if(SUCCESS != ret) {ADI_PRINT("find err\n");return PARAM_FAIL;}
    ADI_PRINT("ele=9 pos = %d\n",pos);
    
    ret = delList(list_test,3);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}  
    ret = delList(list_test,7);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}  
    ret = delList(list_test,9);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;} 
    printList(list_test);

    ret = replaceList(list_test,2,2);
    if(SUCCESS != ret) {ADI_PRINT("change err\n");return PARAM_FAIL;}  
    printList(list_test);  

    
    return SUCCESS;
}

 

双链表：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>  
#include<string.h>
#include<sys/stat.h>
#include<time.h>
#include<stdarg.h>

#if 1
#define INFO_DEBUG    "%d lines in "__FILE__", complie time is "__TIME__" "__DATE__" \n",__LINE__
#define ADI_RUN_ERROR      1
#define ADI_NULL_POINTER  -1
#define ADI_OK             0
#define ADI_PRINT         printf("[%s][%d]:",__FUNCTION__,__LINE__);printf
#define ADI_ASSERT(c,prt,ret)       if(c) {printf(prt);return ret;}
#endif

typedef struct list{
    int elem;
    struct list *prev;
    struct list *next;
}list;


#define PARAM_FAIL -1
#define P_NULL -2
#define SUCCESS 0

/*初始化：只创建头结点*/
list* initList()
{
    list *head = (list*)malloc(sizeof(list));
    if(NULL==head) {printf("NULL");return head;}
    head->prev = NULL;
    head->next = NULL;
    return head;
}

/*pos从0开始，pos=0为第一个*/
int insertList(list *list_insert,int elem,int pos)
{
    int i=0;
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;//取头指针
    while(i<pos && NULL != head)//i比head快一个，i=1时p指向的是第0个元素
    {
        head = head->next;
        i++;
    }

    if(NULL != head)
    {
		list *node = (list*)malloc(sizeof(list));
		if(NULL==node) {printf("NULL");return P_NULL;}
		if(NULL != head->next)
		{
			head->next->prev = node;//修改插入位置后一节点的prev指针
		}
		else//插入的是末尾位置，没有后一节点，不需要修该后一节点的prev指针
		{

		}
		node->next = head->next;
		node->prev = head;
		node->elem = elem;
		head->next = node;
		ADI_PRINT("insert elem = %d\n",elem);
    }
    else
    {
       ADI_PRINT("pos err\n");
       return PARAM_FAIL;
    }

    return SUCCESS;
}


/*pos从0开始，pos=0为第一个*/
int replaceList(list *list_insert,int elem,int pos)
{
    int i=0;
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;//取头指针
    while(i<pos && NULL != head)//i比head快一个，i=1时head指向的是第0个元素
    {
        head = head->next;
        i++;
    }

    if(NULL != head && NULL != head->next)
    {
		head->next->elem = elem;
		ADI_PRINT("change elem = %d\n",elem);
    }
    else
    {
       ADI_PRINT("pos err\n");
       return PARAM_FAIL;
    }

    return SUCCESS;
}

int delList(list *list_insert,int elem)
{
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;
    while(NULL != head->next)
    {
		if(elem == head->next->elem)
		{
		    list *del = head->next;
		    if(NULL != head->next->next) //如果删除的不是最后一个节点，要修改删除节点后一节点的前向指针
		    {
				head->next->next->prev = head;
		    }
        	head->next = head->next->next;
        	free(del);
        	ADI_PRINT("del ele = %d\n",elem);
        	return SUCCESS;
		}
		head = head->next;
    }

	ADI_PRINT("can not find ele = %d\n",elem);
    return PARAM_FAIL;
}

/*pos为在链表中的位置,ele为待查找的元素*/
int findList(list *listFind,int ele,int *pos)
{
    if(NULL == listFind)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    int i = 0;
    list *head = listFind;
    while(NULL != head->next)
    {
		if(ele == head->next->elem)
		{
        	*pos = i;
        	return SUCCESS;
		}
		i++;
		head = head->next;
    }

	ADI_PRINT("can not find ele = %d\n",ele);
    return PARAM_FAIL;
}

int printList(list *list_prt)
{
    if(NULL == list_prt)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }
    int i = 0;

    ADI_PRINT("head->back print \n");
    while(NULL != list_prt->next)
    { 
        list_prt = list_prt->next;
        ADI_PRINT("list[%d] = %d\n",i,list_prt->elem);
        i++;
    }

    ADI_PRINT("back->head print \n");
    while(NULL != list_prt->prev)
    { 
        ADI_PRINT("list[%d] = %d\n",i,list_prt->elem);
        list_prt = list_prt->prev;
        i--;
    }


    return SUCCESS;
}

int main()
{
    int ret = 0,pos = 0;
    list *list_test = initList();
    if(NULL == list_test)
    {
        ADI_PRINT("err \n");
        return P_NULL;
    }

    ret = insertList(list_test,0,0);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,3,1);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,5,2);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,7,3);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,9,4);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    printList(list_test);

    ret = findList(list_test,9,&pos);
    if(SUCCESS != ret) {ADI_PRINT("find err\n");return PARAM_FAIL;}
    ADI_PRINT("ele=9 pos = %d\n",pos);
    
    ret = delList(list_test,3);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}  
    ret = delList(list_test,7);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}  
    ret = delList(list_test,9);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;} 
    printList(list_test);

    ret = replaceList(list_test,2,2);
    if(SUCCESS != ret) {ADI_PRINT("change err\n");return PARAM_FAIL;}  
    printList(list_test);    

    
    return SUCCESS;
}

双循环链表：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>  
#include<string.h>
#include<sys/stat.h>
#include<time.h>
#include<stdarg.h>

#if 1
#define INFO_DEBUG    "%d lines in "__FILE__", complie time is "__TIME__" "__DATE__" \n",__LINE__
#define ADI_RUN_ERROR      1
#define ADI_NULL_POINTER  -1
#define ADI_OK             0
#define ADI_PRINT         printf("[%s][%d]:",__FUNCTION__,__LINE__);printf
#define ADI_ASSERT(c,prt,ret)       if(c) {printf(prt);return ret;}
#endif

typedef struct list{
    int elem;
    struct list *prev;
    struct list *next;
}list;


#define PARAM_FAIL -1
#define P_NULL -2
#define SUCCESS 0

/*初始化：只创建头结点*/
list* initList()
{
    list *head = (list*)malloc(sizeof(list));
    if(NULL==head) {printf("NULL");return head;}
    head->prev = head;
    head->next = head;
    return head;
}

/*pos从0开始，pos=0为第一个*/
int insertList(list *list_insert,int elem,int pos)
{
    int i=0;
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;//取头指针
    while(i<pos && list_insert != head->next)//i比head快一个，i=1时p指向的是第0个元素
    {
        head = head->next;
        i++;
    }

    if((list_insert==head->next)&&(i<pos))//已经到链表尾部，但是pos>i,说明指定的插入位置超过了链表的末尾位置
    {
		return PARAM_FAIL;
    }
    else
    {
		list *node = (list*)malloc(sizeof(list));
		if(NULL==node) {printf("NULL");return P_NULL;}
		node->next = head->next;
		node->prev = head;
		node->elem = elem;
		head->next->prev = node;
		head->next = node;
		ADI_PRINT("insert elem = %d\n",elem);
    }

    return SUCCESS;
}


/*pos从0开始，pos=0为第一个*/
int replaceList(list *list_insert,int elem,int pos)
{
    int i=0;
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;//取头指针
    while(i<pos && list_insert != head->next)
    {
        head = head->next;
        i++;
        //i比head快一个，i=1时head指向的是第0个元素
    }

    if(list_insert==head->next)//已经到链表尾部，说明指定的修改位置超过了链表原有大小
    {
		ADI_PRINT("pos = %d, list's last = %d,change err!\n",pos,i);
		return PARAM_FAIL;
    }
    else
    {
		head->next->elem = elem;
		ADI_PRINT("change elem = %d,pos = %d\n",elem,pos);
    }


    return SUCCESS;
}

int delList(list *list_insert,int elem)
{
    if(NULL == list_insert)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    list *head = list_insert;
    while(list_insert != head->next)
    {
		if(elem == head->next->elem)
		{
		    list *del = head->next;
			head->next->next->prev = head;
        	head->next = head->next->next;
        	free(del);
        	ADI_PRINT("del ele = %d\n",elem);
        	return SUCCESS;
		}
		head = head->next;
    }

	ADI_PRINT("can not find ele = %d\n",elem);
    return PARAM_FAIL;
}

/*pos为在链表中的位置,ele为待查找的元素*/
int findList(list *listFind,int ele,int *pos)
{
    if(NULL == listFind)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }

    int i = 0;
    list *head = listFind;
    while(listFind != head->next)
    {
		if(ele == head->next->elem)
		{
        	*pos = i;
        	return SUCCESS;
		}
		i++;
		head = head->next;
    }

	ADI_PRINT("can not find ele = %d\n",ele);
    return PARAM_FAIL;
}

int printList(list *list_prt)
{
    if(NULL == list_prt)
    {
        ADI_PRINT("err NULL\n");
        return P_NULL;
    }
    int i = 0;

    ADI_PRINT("head->back print \n");
    list *head = list_prt;
    while(list_prt != head->next)
    { 
        head = head->next;
        ADI_PRINT("list[%d] = %d\n",i,head->elem);
        i++;
    }

    ADI_PRINT("back->head print \n");
    while(list_prt != head)
    { 
        i--;
        ADI_PRINT("list[%d] = %d\n",i,head->elem);
        head = head->prev;
        
    }


    return SUCCESS;
}

int main()
{
    int ret = 0,pos = 0;
    list *list_test = initList();
    if(NULL == list_test)
    {
        ADI_PRINT("err \n");
        return P_NULL;
    }

    ret = insertList(list_test,0,0);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,3,1);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,5,2);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,7,3);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    ret = insertList(list_test,9,4);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}
    printList(list_test);

    ret = findList(list_test,9,&pos);
    if(SUCCESS != ret) {ADI_PRINT("find err\n");return PARAM_FAIL;}
    ADI_PRINT("ele=9 pos = %d\n",pos);
    
    ret = delList(list_test,3);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}  
    ret = delList(list_test,7);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;}  
    ret = delList(list_test,9);
    if(SUCCESS != ret) {ADI_PRINT("insert err\n");return PARAM_FAIL;} 
    printList(list_test);

    ret = replaceList(list_test,2,2);
    if(SUCCESS != ret) {ADI_PRINT("change err\n");return PARAM_FAIL;}  
    printList(list_test);    

    
    return SUCCESS;
}

 

小葫芦写代码
关注
专栏目录
【大话数据结构C语言】8 循环链表
CodeAllen嵌入式
10-13 901
系列文章参考资料为《大话数据结构》，源码为个人私有，未经允许不得转载 技术交流群或资料添加微信号：CoderAllen，回复关键字即可 将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾详解的单链表就是单循环链表，简称循环链表（circular linkedlist） 循环链表解决了一个单链表中很麻烦的问题 - 如何从当中一个结点出发，访问到链表的全部结点 循环链表带有头结点的空链表： 加粗样式 循环链表的非空链表： 其实循环链表和单链表的主要差异就在于循环的判断条件.
C语言实现单链表 && 双向链表
m0_64240499的博客
08-03 683
单链表&&双向链表
循环链表——循环单链表与循环双链表——相关C语言代码实现
qq_45965736的博客
09-16 694
本文是对数据结构中的循环单链表和循环双链表的学习。包括与普通链表的对比，初始化的定义代码实现，如何判空，表尾结点判断，以及循环双链表的插入，删除操作等原理，C语言实现。
（数据结构）C语言实现单链表，双向带头循环链表
qq_67887457的博客
04-19 190
C语言实现数据结构单链表，双向链表
c语言中双链表,C语言中，对链表（单链表、双链表）的基本操作
weixin_32734143的博客
05-21 150
本博客整理自网络，仅供学习参考，如有侵权，联系删除。邮箱：rom100@163.com。链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。单链表：typedef struct stude...
C语言之链表：单向链表，循环链表，双向链表
哒宰的博客
11-22 2276
C语言之链表：单向链表，循环链表，双向链表 提起链式存储结构，其与数组是两个非常基础的数据结构，每当提到链式存储结构时，一般情况下我们都会将其与数组放到一块儿来比较。 对于数组与链表，从结构上来看，数组是需要一块连续的内存空间来存储数据，对内存 的要求非常高，比如说我们申请一个100M大小的数组，而如果我们的内存可用空间大于100M，但是没有连续的100M可用空间，那即便是我们的内存空间充足，在申请空间时也会申请失败 而对于链表来说，他对内存空间的要求就不会有那么高，它并不需要一块连续的内存空间，只要内存空
list-2_单链表_speakgfp_数据结构_循环链表_
10-02
在IT领域，数据结构是计算机科学中的核心概念，它涉及到如何高效地组织和存储数据，以便于执行各种操作。...在这个项目中，通过实现和测试单链表、单向循环链表和双向循环链表，你将深化对这些概念的理解。
c/c++ 循环单链表变循环双链表
weixin_40971308的博客
05-13 2882
最近遇到了一个作业题目是：建立一个循环单链表，其节点有 prior，data 和 next 三个域，其中 data 为数据域，存放元素的有效信息，next 域为指针域，指向后继节点，prior 为指针域，它的值为 NULL。编写一个算法将此表改为循环双链表。看了一下感觉不难，好，开始动手。建立链表结构 链表在c语言建立是通过结构体建立，通过在结构体内部建立其结构体本身的指针类型指向下一个节点来实现...
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
最新发布
09-20
在本项目中，我们利用C语言构建了一个航空信息查询系统，该系统的核心数据结构是双向循环链表。双向循环链表是一种特殊的链式存储结构，它允许我们在链表的两个方向上进行遍历，这对于执行增删改查操作非常有用。...
循环链表C语言实现
02-03
代码包含以下功能，经过产品验证，代码运行可靠。 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素； 9.将游标重置指向链表中的第一个数据元素； 10.将游标移动指向到链表中的下一个数据元素； 11.直接指定删除链表中的某个数据元素。
C语言单链表，双向链表，循环单链表，循环双链表的基本操作
多反思，多回顾，要坚持。
10-25 1612
1.单链表的基本操作（C语言） 创建头节点 Linklist *Creat(Linklist *L) { L = (Linklist *)malloc(sizeof(Linklist)); if (L == NULL) return NULL; /*内存分配不成功,返回空指针*/ L -> next = NULL; return L; }
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5294
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
C语言-链表(单向链表、双向链表)
12-17 796
在前面章节已经学习了数组的使用，数组的空间是连续空间，数组的大小恒定的，在很多动态数据存储的应用场景下，使用不方便；而这篇文章介绍的链表结构，支持动态增加节点，释放节点，比较适合存储动态数据的应用场景，而且链表的空间是存储在堆上面的，可以动态分配，释放。从效率上来讲，数组的空间是连续的，查询、读取数据数组占优势；链表的优势在于节点可以动态增加、动态删除，删除支持任意位置的节点删除。
C语言实现 单链表和双链表 处理基本类型数据
jakercl的博客
01-17 422
C语言链表在开发过程十分重要，以下为详细的实现过程，包括单向链表、双向链表，含头节点链表，不含头节点链表，以及封装链表。如有错误，欢迎大家指出，一块学习交流。 1 单向链表实现（有表头--存储基本数据） 1.1 单项链表构造 typedef struct Node //单链表定义 { int data;//先以基本数据类型为例，后再分析复杂数据类型 struct Node *next; } Node; 1.2 创建单链表表头，此表头不含有效数据 Node *headNod
数据结构—单链表、双向循环链表的实现【C语言】
Che__dan的博客
07-29 1729
内有大量的图画，让它们解放你的大脑，来与我一起攻克链表吧！
数据结构C语言：单链表和双链表的实现（不带头节点的单链表、带头的双链表）
myscratch的博客
08-06 489
数据结构C语言：单链表和双链表的实现（不带头节点的单链表、带头的双链表）
C语言单、双、线性、循环链表及实例
热门推荐
qq_41853417的博客
03-11 2万+
C语言 链表 实例
C语言数据结构 2.2&2.3：单链表与双向链表
ss的博客
04-28 1487
概念： 链表是以链式结构存储数据的，其中的元素在存储器上的位置是任意的，既逻辑上的相邻在屋里位置上不一定相邻。 图示： 结点： 链表： 头指针是指向头结点的指针。 代码演示： 定义链表结点： /** * 定义链表结构体 */ typedef struct LinkNode { char data; struct LinkNode *next; } LNode, *LinkList, *NodePtr; 创建一个只含有一个节点且没有数据的链表: /*..
Java单/双链表操作详解及实现代码示例
链表的主要类型包括单链表、循环链表和双向链表，其中单链表每个节点只有一个指向前一个节点的引用，而双向链表则包含前后两个方向的指针。单链表和双链表的实现关键在于节点类的设计，如`SNode`类中包含字符串类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值