3-2-链表 链式表操作集 (20分)

总结一下：
1.将指针L传进去，在函数里面L的移动对主函数中L的指向不影响，L始终指向主函数里L指向的那块地方，如果要通过函数改变主函数中L的指向就需要传入指针的地址，用到二级指针。
2.但是在函数里面改变链表对主函数的链表是有影响的（修改值\删除\增加）

本题要求实现链式表的操作集。

函数接口定义：

Position Find( List L, ElementType X );
List Insert( List L, ElementType X, Position P );
List Delete( List L, Position P );

其中List结构定义如下：

typedef struct LNode *PtrToLNode;
struct LNode {
ElementType Data;
PtrToLNode Next; };
typedef PtrToLNode Position;
typedef PtrToLNode List;

各个操作函数的定义为：

Position Find( List L, ElementType X )：返回线性表中首次出现X的位置。若找不到则返回ERROR；

List Insert( List L, ElementType X, Position P
)：将X插入在位置P指向的结点之前，返回链表的表头。如果参数P指向非法位置，则打印“Wrong Position for
Insertion”，返回ERROR；

List Delete( List L, Position P
)：将位置P的元素删除并返回链表的表头。若参数P指向非法位置，则打印“Wrong Position for
Deletion”并返回ERROR。

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

#define ERROR NULL
typedef int ElementType;
typedef struct LNode* PtrToLNode;
struct LNode {
	ElementType Data;
	PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

Position Find(List L, ElementType X);
List Insert(List L, ElementType X, Position P);
List Delete(List L, Position P);

int main()
{
	List L;
	ElementType X;
	Position P, tmp;
	int N;

	L = NULL;
	scanf("%d", &N);
	while (N--) {
		scanf("%d", &X);
		L = Insert(L, X, L);//这边改变链表是因为把函数结束的头结点传给了L
		//所以函数里面的链表是什么，返回给L及L变化指向后的链表就是什么样
		if (L == ERROR) printf("Wrong Answer\n");
	}
	scanf("%d", &N);
	while (N--) {
		scanf("%d", &X);
		P = Find(L, X);
		if (P == ERROR)
			printf("Finding Error: %d is not in.\n", X);
		else {
			L = Delete(L, P);
			printf("%d is found and deleted.\n", X);
			if (L == ERROR)
				printf("Wrong Answer or Empty List.\n");
		}
	}
	L = Insert(L, X, NULL);
	if (L == ERROR) printf("Wrong Answer\n");
	else
		printf("%d is inserted as the last element.\n", X);
	P = (Position)malloc(sizeof(struct LNode));
	tmp = Insert(L, X, P);
	if (tmp != ERROR) printf("Wrong Answer\n");
	tmp = Delete(L, P);
	if (tmp != ERROR) printf("Wrong Answer\n");
	for (P = L; P; P = P->Next) printf("%d ", P->Data);
	return 0;
}

函数：

Position Find(List L, ElementType X)//写完试一下直接用L 不新设定一个指针 （不影响
//主函数头结点的指向
//因为传进来的L只是L指针的一个形参 在函数里改变L的指向，对主函数的L的指向并不影响
//但在这里修改链表里面的节点（修改值/增加/删除结点）是是有效果的
//要想改变主函数里头指针得传进指针的地址，也就用到了二级指针**
//但我个人觉得用个point指向L表意更明显
{
	PtrToLNode point = L;
	while (point)
	{
		if (point->Data == X)  return point;
		point = point->Next;
	}
	return ERROR;
}
List Insert(List L, ElementType X, Position P)
{
	if (P == L) {//开始输入链表的时候采用头插法（后输入的在前面）
		PtrToLNode head = (PtrToLNode)malloc(sizeof(struct LNode));
		head->Data = X;
		head->Next = L;
		return head;
	}
	else if (P == NULL&&P!=L) {
		//这里开始写的时候出现了一个逻辑错误
		//这样写5连不上去原来的链表
		//奇奇怪怪的错误 芜湖
 	/*	PtrToLNode head, tail;
		head = L, tail = L;
		while (tail) tail = tail->Next;
		tail=(PtrToLNode)malloc(sizeof(struct LNode));
		tail->Next=NULL;
		tail->Data=X;
		return head;*/
		PtrToLNode head, tail;
		head = L, tail = L;
		while (tail->Next) 
			tail = tail->Next;
		PtrToLNode temp = (PtrToLNode)malloc(sizeof(struct LNode));
		
		tail->Next = temp;
		temp->Next = NULL;
		temp->Data = X;
		tail = temp;
		return head;
	}
	else {
		PtrToLNode front = L;
		PtrToLNode after = front->Next;
		while (after) {
			if (after->Data == P->Data) {
				PtrToLNode m = (PtrToLNode)malloc(sizeof(struct LNode));
				m->Data = X;
				m->Next = after;
				front->Next = m;
				return L;
			}
			front = front->Next;
			after = front->Next;
		}
	}
	printf("Wrong Position for Insertion\n");
	return ERROR;
}
List Delete(List L, Position P)
{
	if (L == P) {
		PtrToLNode point = L;
		L = L->Next;
		free(point);
		return L;
	}
	else {
		PtrToLNode front = L;
		PtrToLNode after = front->Next;
		while (after)
		{
			if (after->Data == P->Data)
			{
				front->Next = after->Next;
				free(after);
				//tail=front->Next;
				return L;//返回变化后的指针
			}
			front = front->Next;
			after = front->Next;
		}
	}
	printf("Wrong Position for Deletion\n");
	return ERROR;
}