循环链表API

头文件声明:

#pragma once
#ifndef	_CIRCLELIST_H_
#define	_CIRCLELIST_H_


typedef void CircleList;
typedef struct _tag_CircleListNode
{
	struct _tag_CircleListNode* next;
}CircleListNode;


//-----------------------------------------API--------------------------------//
CircleList* CircleList_Create();

bool CricleList_Destroy(CircleList* list);

bool CircleList_Clear(CircleList* list);

int CircleList_Length(CircleList* list);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(CircleList* list, int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

//add

//删除游标指向的当前节点
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);

//游标重置
CircleListNode* CircleList_Reset(CircleList* list);

//返回游标当前指向的节点
CircleListNode* CircleList_Current(CircleList* list);

//游标下移
CircleListNode* CircleList_Next(CircleList* list);

#endif

函数实现：

#include <iostream>
#include <cstdlib>
#include "circlelist.h"

using namespace std;

//适配业务节点 
typedef struct _tag_CircleList
{
	CircleListNode header;
	CircleListNode* slider;
	int length;
}TCircleList;


CircleList* CircleList_Create()
{
	TCircleList *ret = (TCircleList *)malloc(sizeof(TCircleList));
	if (ret == NULL)
	{
		return NULL;
	}
	ret->header.next = NULL;
	ret->slider = NULL;
	ret->length = 0;
	cout << "构造循环链表成功！" << endl;
	return ret;

}

bool CricleList_Destroy(CircleList* list)
{
	if (list == NULL)
	{
		return false;
	}
	free(list);
	list = NULL;
	cout << "循环链表删除成功！" << endl;
	return true;
}

bool CircleList_Clear(CircleList* list)
{
	TCircleList *tmp = NULL;
	if (list == NULL)
	{
		return false;
	}
	tmp = (TCircleList *)list;
	tmp->header.next = NULL;
	tmp->slider = NULL;
	tmp->length = 0;
	return true;
}

int CircleList_Length(CircleList* list)
{
	int temp = 0;
	TCircleList *tmp = NULL;
	if (list == NULL)
	{
		return -1;
	}
	tmp = (TCircleList *)list;
	temp = tmp->length;
	return temp;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
	int ret = 0;
	int i = 0;
	TCircleList *q_tmp = NULL;
	if (list == NULL || node == NULL || pos < 0)
	{
		return -1;
	}
	q_tmp = (TCircleList*)list;
	CircleListNode *current = NULL;
	current = (CircleListNode *)q_tmp;

	for (i = 0; (i < pos) && (current->next != NULL); i++)
	{
		current = current->next;
	}

	node->next = current->next;
	current->next = node;

	// 若第一次插入节点
	if (q_tmp->length == 0)
	{
		q_tmp->slider = node;
	}
	q_tmp->length++;

	//若头插法	 需要求出尾节点，让尾部节点指向新节点
	if (current == (CircleListNode *)q_tmp)//判断条件：current没有变化
	{										 //跳0步，没有跳走
		//获取最后一个元素
		CircleListNode* last = CircleList_Get(q_tmp, q_tmp->length - 1);
		//正常的插入节点
		last->next = current->next;
	}
	return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos)
{
	TCircleList* q_tmp = (TCircleList*)list;
	CircleListNode* ret = NULL;
	int i = 0;

	if (list == NULL || pos < 0)
	{
		return NULL;
	}

	CircleListNode *current = NULL;
	current = (CircleListNode *)q_tmp;
	for (i = 0; i < pos; i++)
	{
		current = current->next;
	}
	ret = current->next;
	return ret;
}

CircleListNode* CircleList_Delete(CircleList* list, int pos)
{
	int i = 0;
	TCircleList *q_tmp = NULL;
	CircleListNode*ret = NULL;
	CircleListNode *last = NULL;
	if (list == NULL || pos < 0)
	{
		return NULL;
	}
	q_tmp = (TCircleList *)list;
	CircleListNode *current = NULL;
	current = (CircleListNode *)list;
	for (i = 0; i < pos; i++)
	{
		current = current->next;
	}

	//1.删除第一个节点
	if (current == (CircleListNode *)q_tmp)
	{
		CircleListNode *last = CircleList_Get(q_tmp, q_tmp->length - 1);;
	}
	ret = current->next;
	current->next = ret->next;
	q_tmp->length--;
	//判断链表是否为空
	if (last != NULL)
	{
		q_tmp->header.next = ret->next;
		last->next = ret->next;
	}
	//删除的元素为游标所指的函数
	if (q_tmp->slider == ret)
	{
		q_tmp->slider = ret->next;//更改游标的指向
	}
	//若删除元素后，链表长度为0
	if (q_tmp->length == 0)
	{
		q_tmp->header.next = NULL;
		q_tmp->slider = NULL;
	}
	return ret;
}

//add

//指定元素删除节点
CircleListNode* CircleList_DeleteNode(CircleList*list, CircleListNode* node)
{
	TCircleList *q_tmp = (TCircleList*)list;
	CircleListNode *ret = NULL;
	int i = 0;
	if (list == NULL || node == NULL)
	{
		return NULL;
	}
	CircleListNode*current = NULL;
	current = (CircleListNode *)q_tmp;
	for (i = 0; i < q_tmp->length; i++)
	{
		if (current->next == node)
		{
			ret = current->next;
			break;
		}
		current = current->next;
	}
	if (ret != NULL)
	{
		CircleList_Delete(list, i);
	}
	return ret;
}

CircleListNode* CircleList_Reset(CircleList* list)
{
	TCircleList *q_tmp = (TCircleList*)list;
	CircleListNode *ret = NULL;
	if (list == NULL)
	{
		return NULL;
	}
	q_tmp->slider = q_tmp->header.next;
	ret = q_tmp->slider;
	return ret;
}

CircleListNode* CircleList_Current(CircleList* list)
{
	TCircleList *q_tmp = (TCircleList*)list;
	CircleListNode *ret = NULL;
	if (list == NULL)
	{
		return NULL;
	}
	ret = q_tmp->slider;
	return ret;
}

//返回当前的位置并且游标下移
CircleListNode* CircleList_Next(CircleList* list)
{
	TCircleList *q_tmp = (TCircleList*)list;
	CircleListNode *ret = NULL;
	if (list != NULL && q_tmp->slider != NULL)
	{
		ret = q_tmp->slider;
		q_tmp->slider = ret->next;
	}
	return ret;
}