데이터 구조: 헤드 없 는 단 방향 비 순환 링크 의 간단 한 기능 활용

#pragma once

typedef int SLTDataType;

typedef struct slistNode{
	struct slistNode* next;
	SLTDataType data;

}slistNode;

typedef struct first{
	struct slistNode*first;
}slist;

void slistInIt(slist*list);

void slistDestory(slist* list);

slistNode* buyslistNode(SLTDataType data);

void slistPrint(slist* list);

//    

void slistPushFront(slist*list,SLTDataType data);
void slistPushBack(slist* list, SLTDataType data);

void slistPopFront(slist* list);
void slistPopBack(slist* list);

slistNode* slistFind(slist* list, SLTDataType data);

void slistModify(slist* list,SLTDataType data,SLTDataType x);

void SListInsertAfter(slistNode* pos, SLTDataType data);
void SListEraseAfter(slistNode* pos);

void SListRemove(slist* list, SLTDataType data);

void slistReverselist(slist* list);

#include "slist.h"
#include 
#include 
#include 

void slistInIt(slist*list)
{
	assert(list);
	list->first = NULL;
}

void slistDestory(slist* list)
{
	slistNode* temp;
	for (slistNode* cur=list->first; cur !=NULL; cur=temp)
	{
		temp = cur->next;
		free(cur);
	}
	list->first = NULL;
}

slistNode* buyslistNode(SLTDataType data)
{
	slistNode* p = (slistNode*)malloc(sizeof(slistNode));
	assert(p);
	p->data = data;
	return p;
}

void slistPushFront(slist*list, SLTDataType data)
{
	assert(list);
	slistNode* temp = list->first;
	list->first = buyslistNode(data);
	list->first->next = temp;
}

void slistPushBack(slist* list, SLTDataType data)
{
	assert(list);
	if (list->first==NULL)
	{
		slistPushFront(list, data);
		return;
	}
	slistNode* cur = list->first;
	for (; cur->next != NULL; cur = cur->next);
	cur->next = buyslistNode(data);
	cur->next->next = NULL;
}

void slistPopFront(slist* list)
{
	assert(list);
	assert(list->first != NULL);
	slistNode* temp = list->first;
	list->first = list->first->next;
	free(temp);
}

void slistPopBack(slist* list)
{
	assert(list);
	slistNode* cur = list->first;
	for (; cur->next->next != NULL; cur = cur->next);
	free(cur->next);
	cur->next = NULL;
}

void slistPrint(slist* list)
{
	assert(list);
	for (slistNode* cur = list->first; cur != NULL; cur = cur->next)
	{
		printf("%d -->", cur->data);
	}
	printf("NULL
");
}

slistNode* slistFind(slist* list, SLTDataType data)
{
	assert(list);
	for (slistNode* cur = list->first; cur != NULL; cur = cur->next)
	{
		if (cur->data==data)
		{
			return cur;
		}
	}
	return NULL;
}

void slistModify(slist* list, SLTDataType data,SLTDataType x)
{
	assert(list);
	slistNode* temp = slistFind(list,data);
	temp->data = x;
}

void SListInsertAfter(slistNode* pos, SLTDataType data)
{
	slistNode* temp =pos->next;
	pos->next = buyslistNode(data);
	pos->next->next = temp;
}

void SListEraseAfter(slistNode* pos)
{
	slistNode* temp = pos->next;
	pos->next = pos->next->next;
	free(temp);
}

void SListRemove(slist* list, SLTDataType data)
{
	assert(list);
	slistNode* prev=list->first;
	slistNode* cur = list->first->next;
	for (; cur != NULL; cur = prev->next)
	{	
		if (cur->data == data)
		{
			prev->next = cur->next;
			free(cur);	
		}
		else
		{
			prev = cur;
		}

	}
	if (list->first->data ==data);
	{
		slistPopFront(list);
	}
}

void slistReverselist(slist* list)
{
	assert(list);
	slistNode* head = NULL;
	slistNode* cur;
	while (list->first!= NULL)
	{
		cur = list->first;
		list->first = list->first->next;

		cur->next = head;
		head = cur;

	}
	list->first = head;
}

#include "slist.h"
#include 
#include 


test(slist* list)
{
	slistPushFront(list, 5);
	slistPushFront(list, 4);
	slistPushFront(list, 3);
	slistPushFront(list, 2);
	slistPushFront(list, 1);

	slistPrint(list);//12345

	slistPushBack(list, 6);
	slistPushBack(list, 7);
	slistPushBack(list, 8);
	slistPushBack(list, 9);
	slistPushBack(list, 10);

	slistPrint(list);//12345678910

	slistPopBack(list);
	slistPopBack(list);
	slistPopBack(list);

	slistPrint(list);//1234567

	slistPopFront(list);
	slistPopFront(list);
	slistPopFront(list);

	slistPrint(list);//4567

	printf("%p
", list->first->next);
	slistNode* cur=slistFind(list,5);
	printf("%p
",cur);

	slistModify(list,4,3);
	slistPrint(list);

	SListInsertAfter(cur, 0);
	slistPrint(list);
	SListEraseAfter(cur);
	slistPrint(list);//3567

	slistPushFront(list, 3);
	slistPushFront(list, 2);
	slistPushFront(list, 3);
	slistPrint(list); //3233567

	SListRemove(list, 3);
	slistPrint(list);//2567

	slistReverselist(list);
	slistPrint(list);//7652
}

int main()
{
	slist list;
	slistInIt(&list);
	test(&list);
	system("pause");
	return 0;
}