专题二-可复用单链表

//main.c文件
#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

/*数据域结构体*/
struct Value {
	LinkListNode header;
	int v;
};

int main(int argc, char *argv[]) 
{
	LinkList* list = LinkList_Create();
	int i = 0;

	struct Value v1;
	struct Value v2;
	struct Value v3;
	struct Value v4;
	struct Value v5;
	
	v1.v = 1;
	v2.v = 2;
	v3.v = 3;
	v4.v = 4;
	v5.v = 5;
	
	/*
	//插入元素 头插法 
	LinkList_Insert(list, (LinkListNode*)&v1, 0);
	LinkList_Insert(list, (LinkListNode*)&v2, 0);
	LinkList_Insert(list, (LinkListNode*)&v3, 0);
	LinkList_Insert(list, (LinkListNode*)&v4, 0);
	LinkList_Insert(list, (LinkListNode*)&v5, 0);
	*/
	
	//插入元素 尾插法 
	LinkList_Insert(list, (LinkListNode*)&v1, LinkList_Length(list));
	LinkList_Insert(list, (LinkListNode*)&v2, LinkList_Length(list));
	LinkList_Insert(list, (LinkListNode*)&v3, LinkList_Length(list));
	LinkList_Insert(list, (LinkListNode*)&v4, LinkList_Length(list));
	LinkList_Insert(list, (LinkListNode*)&v5, LinkList_Length(list));
	

	//遍历单链表
	for (i=0; i<LinkList_Length(list); i++) {
		struct Value* pv = (struct Value*)LinkList_Get(list, i);
		
		printf("%d\n", pv->v);
	}
	
	printf("\n--------------------------------\n");	
	
	//反转单链表 
	LinkList_Reverse(list);
	
	//遍历单链表
	for (i=0; i<LinkList_Length(list); i++) {
		struct Value* pv = (struct Value*)LinkList_Get(list, i);
		
		printf("%d\n", pv->v);
	}
	
	printf("\n--------------------------------\n");	
	
	//删除结点 
	while (LinkList_Length(list) > 0) {
		struct Value* pv = (struct Value*)LinkList_Delete(list, LinkList_Length(list)-1);		
		
		printf("%d\n", pv->v);
	}
	
	//销毁单链表 
	LinkList_Destroy(list);
	
	return 0;
}

//LinkList.c文件
#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"

/*表头结点 结构体*/
typedef struct _tag_LinkList {
	LinkListNode header;
	int length;
} TLinkList;

/*创建单链表*/
LinkList* LinkList_Create()
{
	TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));
	
	if (ret != NULL) {
		ret->length = 0;
		ret->header.next = NULL;
	}	
	
	return ret;
}

/*销毁单链表*/
void LinkList_Destroy(LinkList* list)
{
	free(list);
}

/*清空单链表*/
void LinkList_Clear(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;
	
	if (sList != NULL) {
		sList->length = 0;
		sList->header.next = NULL;
	}
}

/*返回单链表长度*/
int LinkList_Length(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;
	int ret = -1;
	
	if (sList != NULL) {
		ret = sList->length;
	}	
	
	return ret;
}

/*插入结点*/
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
	TLinkList* sList = (TLinkList*)list;
	int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
	int i = 0;
	
	//开始插入结点 
	if (ret) {
		LinkListNode* current = (LinkListNode*)sList;	
		
		//找pos位置 
		for (i=0; (i<pos) && (current->next != NULL); i++) {
			current = current->next;
		}
		
		//插入结点 
		node->next = current->next;
		current->next = node;
		
		//长度自增 
		sList->length++;
	}
	
	return ret;
}

/*反转链表*/ //3个指针遍历链表
/* 
int LinkList_Reverse(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;
	int ret = (sList != NULL);
	LinkListNode* r = NULL;
	LinkListNode* p = sList->header.next;		//指向第1个结点 
	LinkListNode* q = sList->header.next->next;	//指向第2个结点 
	sList->header.next = NULL;			//头结点next->NULL 
	
	//开始反转 
	while (q != NULL) {
		r = q->next;
		q->next = p;
		p = q;
		q = r;	
	}

	sList->header.next = p;
	
	return ret;
}
*/

/*
/*反转链表*/ //类似插入法   12345 --> 13245 --> 14325 --> 15432 --> 54321 
int LinkList_Reverse(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;
	int ret = (sList != NULL);
	
	LinkListNode* p = NULL;		
	LinkListNode* q = NULL;
	
	p = sList->header.next->next;	//第一个数据结头 
	
	while (p->next != NULL) {
		q = p->next;
		p->next = q->next;
		q->next = sList->header.next->next;
		sList->header.next->next = q;	
	}
	
	p->next = sList->header.next;		//相当于成环
	sList->header.next = p->next->next;	//新header变为原来header的next 
	p->next->next = NULL;			//断掉环 
		
	return ret;
}

/*获取pos位置结点*/
LinkListNode* LinkList_Get(LinkList* list, int pos)
{
	TLinkList* sList = (TLinkList*)list;
	LinkListNode* ret = NULL;
	int i = 0;

	if ((sList != NULL) && (pos >= 0) && (pos < sList->length)) {
		LinkListNode* current = (LinkListNode*)sList;
		
		//开始找pos位置
		for (i=0; i<pos; i++) {
			current = current->next;
		}
		
		//返回pos位置的指针 
		ret = current->next;
	}
	
	return ret;
}

/*删除结点*/
LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
	TLinkList* sList = (TLinkList*)list;
	LinkListNode* ret = NULL;
	int i = 0;

	if ((sList != NULL) && (pos >= 0) && (pos < sList->length)) {
		LinkListNode* current = (LinkListNode*)sList;
		
		//开始找pos位置
		for (i=0; i<pos; i++) {
			current = current->next;
		}
		
		ret = current->next;
		current->next = ret->next;
		
		//长度自减 
		sList->length--;
	}
	
	return ret;
}

//LinkList.h文件
#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;
typedef struct _tag_LinkListNode LinkListNode;
/*指针域的结构体*/
struct _tag_LinkListNode {	
	LinkListNode* next;
};

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

int LinkList_Reverse(LinkList* list);

LinkListNode* LinkList_Get(LinkList* list, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif