单向链表的实现

	单向链表函数表
1	create_Forward_list//创建头节点
2	insert_Node//插入新节点
3	delete_Node//删除节点
4	find_by_order//查找，返回第order位的指针
5	find_by_value//按值查找，返回指针
6	Forward_list_Length//返回链表的长度

#include<stdio.h>
//Forward_list
#define ElementType int
struct Forward_list;
typedef struct Forward_list* PtrToNode;//PtrToNode 是指向链表的指针
typedef PtrToNode forward_list；
//PtrToNode与forward_list都是指向链表的指针，forward_list用来定义头节点
forward_list create_Forward_list();
void insert_Node(forward_list s, int order, ElementType value);
void delete_Node(forward_list s, int order);
PtrToNode find_by_order(forward_list s, int order);
PtrToNode find_by_value(forward_list s, int value);
int Forward_list_Length(forward_list s);
struct Forward_list
{
	PtrToNode next;//指向下一个节点的指针
	ElementType Element;//元素值
};
int main()
{
	forward_list my_list = create_Forward_list();
	insert_Node(my_list, 1, 1);
	insert_Node(my_list, 2, 2);
	insert_Node(my_list,3 ,3);
	delete_Node(my_list,2);
	//delete_Node(my_list, 5);

	printf("%d",my_list->next->Element);
	printf("%d",my_list->next->next->Element);//输出Element值

}
forward_list create_Forward_list()//创建头节点
{
	forward_list s;
	s = (PtrToNode)malloc(sizeof(struct Forward_list));
	if (s == NULL)
	{
		std::cerr << "out of space";
		return NULL;
	}
	s->next = NULL;
	return s;
}
void insert_Node(forward_list s, int order, ElementType value)//插入新节点
{
	PtrToNode walker;//用来移动的结构体指针
	PtrToNode finded_Ptr = find_by_order(s, order);//简化形式
	forward_list new_Node = (PtrToNode)malloc(sizeof(struct Forward_list));
	if (new_Node == NULL) {
		printf("out of space");//错误提示
		return;//以下部分不执行
	}
	for (walker = s; walker->next != finded_Ptr; walker = walker->next)//遍历链表
	{

	}
	walker->next = new_Node;
	new_Node = walker->next;
	new_Node->Element = value;
	walker->next->next = NULL;

}
void delete_Node(forward_list s, int order)//删除节点
{
	PtrToNode walker;
	PtrToNode finded_Ptr = find_by_order(s, order);//简化形式
	if (finded_Ptr == NULL)
	{
		printf("erro in order");
		return;
	}
	forward_list new_Node = (PtrToNode)malloc(sizeof(struct Forward_list));
	if (new_Node == NULL) {
		printf("out of space");//错误提示
		return;//以下部分不执行
	}
	for (walker = s; walker->next != finded_Ptr; walker = walker->next)
	{

	}
	if (walker != NULL)
	{
		walker->next = finded_Ptr->next;
		finded_Ptr = NULL;
		free(finded_Ptr);
	}
}
PtrToNode find_by_order(forward_list s, int order)//查找，返回第order位的指针
{

	PtrToNode walker = s;
	if (order > Forward_list_Length(s) + 1)//判断是否可以插入
	{
		 printf( "please input the right order<<endl");
		return NULL;
	}
	for (int i = 1; i <= order; i++)
	{
			walker = walker->next；
	}
	return walker;
}
PtrToNode find_by_value(forward_list s, int value)//按值查找，返回指针
{
	PtrToNode walker;//
	for (walker = s; walker != NULL; walker = walker->next)
	{
		if (walker->Element == value)
		{
			return walker;
		}
	}
	printf("did't find it");
	return NULL;
}
int Forward_list_Length(forward_list s)//返回链表的长度
{
	PtrToNode walker;
	int cnt = 0;
	for (walker = s->next; walker != NULL; walker = walker->next)
	{
		cnt++;
	}
	return cnt;
}