Chapter 3 List-Stack-and-Queue(1)

鏈表（單鏈表）

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

typedef int ElementType;
typedef struct Node
{
	ElementType Data;
	struct Node *Next;
}*List,*Position;

void Add(List L, ElementType X)
{
	Position P1 = (Node*)malloc(sizeof(Node));
	P1->Data = X;
	P1->Next = NULL;
	Position P2 = L;
	while (P2->Next)
		P2 = P2->Next;
	P2->Next = P1;
}

int Insert(List L, ElementType X, int i)
{
	Position P1 = L->Next;
	Position P2 = (Node*)malloc(sizeof(Node));//Creat
	int k = 0;
	while (P1)
	{
		k++;
		if (k == i)
			break;
		P1 = P1->Next;
	}
	if (P1)
	{
		P2->Data = X;
		P2->Next = P1->Next;
		P1->Next = P2;
		return 0;
	}
	return -1;
}

Position Find(List L, ElementType X)
{
	Position P = L->Next;
	while (P)
	{
		if (P->Data == X)
			return P;
		P = P->Next;
	}
	return NULL;
}

Position FindPrev(List L, ElementType X)
{
	Position P = L->Next;
	while (P->Next)
	{
		if (P->Next->Data == X)
			return P;
		P = P->Next;
	}
	return NULL;
}

int Delete(List L, ElementType X)
{
	Position P1 = FindPrev(L, X);
	if (P1)
	{
		Position P2 = P1->Next;
		P1->Next = P2->Next;
		free(P2);
		return 0;
	}
	return -1;
}

void PrintAll(List L)
{
	Position P;
	for (P = L->Next; P; P = P->Next)
		printf("%d ", P->Data);
	printf("\n");
}
int main()
{
	List L = (Node*)malloc(sizeof(Node));
	L->Next = NULL;
	for (int i = 0; i < 10; i++)
	{
		Add(L, i);
	}
	PrintAll(L);
	(Delete(L, 1) == 0) ? PrintAll(L) : printf("刪除失敗！\n");
	(Find(L, 11) == NULL) ? printf("找不到！\n") : printf("%d ", Find(L, 11)->Data);
	(Insert(L, 10, 9) == 0) ? PrintAll(L) : printf("插入失敗！\n");

	return 0;
}

鏈表（ 雙向循環鏈表）

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

typedef int ElementType;
typedef struct Node
{
	ElementType Data;
	struct Node *Next, *Prev;
}*List, *Position;

void Add(List L, ElementType X)
{
	Position P1 = (Node*)malloc(sizeof(Node));
	P1->Data = X;
	Position P2 = L->Next; //!!!
	if (P2) {
		while (P2->Next != L->Next) //!!!
			P2 = P2->Next;
		P2->Next = P1;
		P1->Prev = P2;
		P1->Next = L->Next;
		L->Next->Prev = P1;
	}
	else
	{
		L->Next = P1;
		P1->Next = P1;
		P1->Prev = P1;
	}
}

int Insert(List L, ElementType X, int i) 
{
	Position P1 = L->Next;
	Position P2 = (Node*)malloc(sizeof(Node));//!!!
	int k = 0;
	while (P1)
	{
		k++;
		if (k == i)
			break;
		P1 = P1->Next;
	}
	if (P1)
	{
		P2->Data = X;
		P2->Next = P1->Next;
		P1->Next->Prev = P2;
		P1->Next = P2;
		P2->Prev = P1;
		return 0;
	}
	return -1;
}

Position Find(List L, ElementType X)
{
	Position P = L->Next;
	while (P->Next != L->Next) //!!!
	{
		if (P->Data == X)
			return P;
		P = P->Next;
	}
	return NULL;
}

/*Position FindPrev(List L, ElementType X)
{
	Position P = L->Next;
	while (P->Next)
	{
		if (P->Next->Data == X)
			return P;
		P = P->Next;
	}
	return NULL;
}*/

int Delete(List L, ElementType X)
{
	Position P1 = Find(L, X);
	if (P1)
	{
		P1->Prev->Next = P1->Next;
		P1->Next->Prev = P1->Prev;
		free(P1);
		return 0;
	}
	return -1;
}

void PrintAll(List L)
{
	Position P;
	for (P = L->Next; P->Next != L->Next; P = P->Next)
		printf("%d ", P->Data);
	printf("%d\n",P->Data);  //!!!
}
int main()
{
	List L = (Node*)malloc(sizeof(Node));
	L->Next = L->Prev = NULL;
	for (int i = 0; i < 10; i++)
	{
		Add(L, i);
	}
	PrintAll(L);
	(Delete(L, 1) == 0) ? PrintAll(L) : printf("刪除失敗！\n");
	(Find(L, 11) == NULL) ? printf("找不到！\n") : printf("%d ", Find(L, 11)->Data);
	(Insert(L, 10, 9) == 0) ? PrintAll(L) : printf("插入失敗！\n");

	return 0;
}

鏈表（遊標實現）

#include <stdio.h>
#include <stdlib.h>
#define SpaceSize 10

typedef int ElementType;
typedef int List;
typedef int Position;
struct Node CursorSpace[SpaceSize];
typedef struct Node
{
	ElementType Element;
	Position Next;
};

Position CursorAlloc()
{
	Position P;
	P = CursorSpace[0].Next;
	return P;
}

void CursorFree(Position P)
{
	CursorSpace[P].Next = CursorSpace[0].Next;
	CursorSpace[0].Next = P;
}

int IsEmpty(List L)
{
	return CursorSpace[L].Next == 0;
}

int IsLast(List L,Position P)
{
	return CursorSpace[P].Next == 0;
}

Position Find(List L, ElementType X)
{
	Position P;
	P = CursorSpace[L].Next;
	while (P && CursorSpace[P].Element != X)
		P = CursorSpace[P].Next;
	return P;
}

int Delete(List L, ElementType X)
{
	Position P, TmpCell;
	P = Find(L, X);
	if (!IsLast(L, P))
	{
		TmpCell = CursorSpace[P].Next; 
		CursorSpace[P].Next = CursorSpace[TmpCell].Next;
		CursorFree(TmpCell);
		return 0;
	}
	return -1;
}

int Insert(List L, ElementType X, Position P)
{
	Position TmpCell = CursorAlloc();
	if (TmpCell == 0)
		return -1;
	CursorSpace[TmpCell].Element = X;
	CursorSpace[TmpCell].Next = CursorSpace[P].Next;
	CursorSpace[P].Next = TmpCell;
}

鏈表（交併集）

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

typedef int ElementType;
typedef struct Node
{
	ElementType Data;
	struct Node *Next;
}*List, *Position;

void Add(List L, ElementType X)
{
	Position P1 = (Node*)malloc(sizeof(Node));
	P1->Data = X;
	P1->Next = NULL;
	Position P2 = L;
	while (P2->Next)
		P2 = P2->Next;
	P2->Next = P1;
}

void PrintAll(List L)
{
	Position P;
	for (P = L->Next; P; P = P->Next)
		printf("%d ", P->Data);
	printf("\n");
}

int CreatList(List &L, int a[], int n)
{
	L = (Node*)malloc(sizeof(Node));
	L->Next = NULL;
	Position P, TmpCell;
	P = L;
	for (int i = 0; i < n; i++)
		Add(L, a[i]);
	if (L->Next)
		return 0;
	else
		return -1;
}

List Union(List L1, List L2)
{
	List L3;
	L3 = (Node*)malloc(sizeof(Node));
	L3->Next = NULL;
	Position P1, P2;
	P1 = L1->Next;
	P2 = L2->Next;
	while (P1 != NULL && P2 != NULL)
	{
		if (P1->Data == P2->Data)
		{
			Add(L3, P1->Data);
			P1 = P1->Next;
			P2 = P2->Next;
		}
		else if (P1->Data > P2->Data)
		{
			Add(L3, P2->Data);
			P2 = P2->Next;
		}
		else if (P1->Data < P2->Data)
		{
			Add(L3, P1->Data);
			P1 = P1->Next;
		}
	}
	while (P1)
	{
		Add(L3, P1->Data);
		P1 = P1->Next;
	}
	while (P2)
	{
		Add(L3, P2->Data);
		P2 = P2->Next;
	}
	return L3;
}

List Intersection(List L1, List L2)
{

	List L3;
	L3 = (Node*)malloc(sizeof(Node));
	L3->Next = NULL;
	Position P1, P2;
	for (P1 = L1->Next; P1; P1 = P1->Next)
		for (P2 = L2->Next; P2; P2 = P2->Next)
			if (P1->Data == P2->Data)
				Add(L3, P1->Data);
	return L3;
}

int main()
{
	List L, P;
	int a[5] = { 2,4,6,8,10 };
	int b[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%d\n", CreatList(P, b, 10));
	printf("%d\n", CreatList(L, a, 5));
	List K = Intersection(L, P);
	PrintAll(K);
    K = Union(L, P);
	PrintAll(K);
	return 0;
}