算法笔记10.31

循环链表
定义：将单链表中最后一个数据元素的next指针指向第一个元素
循环链表拥有单链表的所有操作——创建链表、销毁链表、获取链表长度、清空链表、获取第pos个元素操作、插入元素到位置pos、删除位置pos处的元素
新增功能：游标——在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，可以通过这个游标来遍历链表中的所有元素。（可以将游标当作迭代器）。

//circlelist.h
#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

typedef void CircleList;

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

CircleList* CircleList_Creat();

void CircleList_Destroy(CircleList* list);

void 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);

CircleListNode* CircleList_DeleteNode(CircleList* list,CircleListNode *node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

#endif //

#include <stdio.h>
#include "circlelist.h"
#include <stdlib.h>

typedef struct _tag_CircleList {
	CircleListNode * header;
	CircleListNode * slide;
	int length;
}TCircleList;

CircleList* CircleList_Creat() {
	TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));
	if (ret == NULL) {
		return NULL;
	}

	ret->length = 0;
	ret->header->next = NULL;
	ret->slide = NULL;

	return ret;
}

void CircleList_Destroy(CircleList* list) {
	if (list == NULL) {
		return;
	}
	free(list);
}

void CircleList_Clear(CircleList* list) {
	TCircleList* sList = (TCircleList*)list;
	if (sList == NULL) {
		return ;
	}
	sList->length = 0;
	sList->header->next = NULL;
	sList->slide = NULL;
}

int CircleList_Length(CircleList* list) {
	TCircleList* sList = (TCircleList*)list;
	int ret = -1;
}

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

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

		//current->next 0号节点的地址
		node->next = current->next;//1
		current->next = node;//2

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

		sList->length++;

		//若头插法，current仍指向头部，原因是没有跳走
		if (current == (CircleListNode*)sList) {
			//获取最后一个元素
			CircleListNode* last = CircleList_Get(sList,sList->length-1);
			last->next = current->next;
		}
	}

	return ret;
}

CircleListNode* CircleList_Get(CircleList* list, int pos) {
		TCircleList* sList = (TCircleList*)list;
		CircleListNode* ret = NULL;
		int i = 0;
		if (list == NULL || pos < 0) {
			return NULL;
		}
	//if ((sList != NULL) && (pos >= 0) && (sList->length > 0) 
	{
		CircleListNode* current = (CircleListNode*)sList;
		for (i = 0; i < pos; i++) {
			current = current->next;
		}
		ret = current->next;

	}
	return ret;
}

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

		//若删除链表第一个元素
		if (current == ((CircleList*)sList)) {
			last = (CircleListNode*)CircleList_Get(sList, sList->length - 1);
		}
		//求要删除的元素
		ret = current->next;
		current->next = ret->next;

		sList->length--;
		//判断链表是否为空
		if (last != NULL) {
			sList->slide = ret->next;
		}

		//若删除的元素为游标所指的元素
		if (sList->slide == ret) {
			sList->slide = ret->next;
		}

		//若删除元素后链表长度为0
		if (sList->length == 0) {
			sList->header->next = NULL;
			sList->slide = NULL;
		}

	}
	return ret;
}

CircleListNode * CircleList_DeleteNode(CircleList* list, CircleListNode* node) {
	TCircleList* sList = (TCircleList*)list;
	CircleListNode* ret = NULL;
	int i = 0;

	if (sList != NULL) {
		CircleListNode* current = (CircleListNode*)sList;

		//查找node在循环链表中的位置
		for (i = 0; i < sList->length; i++) {
			if (current->next == node) {
				ret = current->next;
				break;
			}

			current = current->next;
		}
		if (ret != NULL) {
			CircleList_Delete(sList, i);
		}
	}
	return ret;
}

CircleListNode* CircleList_Reset(CircleList* list) {
	TCircleList* sList = (TCircleList*)list;
	CircleListNode* ret = NULL;

	if (sList != NULL) {
		sList->slide = sList->header->next;
		ret = sList->slide;
	}

	return ret;
}

CircleListNode* CircleList_Current(CircleList* list) {
	TCircleList* sList = (TCircleList*)list;
	CircleList* ret = NULL;

	if (sList != NULL) {
		ret = sList->slide;
	}
	return (CircleListNode *)ret;
}

//把当前位置返回，并且游标下移
CircleListNode* CircleList_Next(CircleList* list) {

	TCircleList* sList = (TCircleList*)list;
	CircleList* ret = NULL;

	if ((sList != NULL) && (sList->slide != NULL) ){
		ret = sList->slide;
		sList->slide = ((CircleListNode*)ret)->next;
	}

	return (CircleListNode *)ret;
}

//test
#include <iostream>
#include <stdio.h>
#include "circlelist.h"
#include <stdlib.h>

struct Value {
    CircleListNode circlenode;
    int v;
};

int main()
{
    CircleList* list = CircleList_Creat();

    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;
    struct Value v6;
    struct Value v7;
    struct Value v8;

    int i = 0;

    v1.v = 1;
    v2.v = 2;
    v3.v = 3;
    v4.v = 4;
    v5.v = 5;
    v6.v = 6;
    v7.v = 7;
    v8.v = 8;

    CircleList_Insert(list, (CircleListNode*)&v1, 0);
    CircleList_Insert(list, (CircleListNode*)&v2, 0);
    CircleList_Insert(list, (CircleListNode*)&v3, 0);
    CircleList_Insert(list, (CircleListNode*)&v4, 0);

    for (i = 0; i < 2 * CircleList_Length(list); i++) {
        struct Value* pv = (struct Value*)CircleList_Get(list, i);

        printf("%d \n", pv->v);
    }
    while (CircleList_Length(list)>0)
    {
        CircleList_Delete(list, 0);
    }

    printf("\n");

    CircleList_Destroy(list);

    system("pause");

    return 0;
}