双向链表 栈 双端栈 循环队列 链队 集合

//双向循环链表
#define ElementType int
typedef struct ListNode *List;
struct ListNode
{
	ElementType Data;
	List pNext;
	List pPrior;
};

List CreatList()
{
	List L = (List)malloc(sizeof(struct ListNode));
	L->pNext = L;
	L->pPrior =L;
	return L;
}

List pHead = CreatList();
List pRear = pHead;

void Insert(ElementType item)
{
	if (pHead)
	{
		List T = CreatList();
		T->Data = item;
		pRear->pNext = T;
		T->pPrior = pRear;
		pRear = T;
		pHead->pPrior = pRear;
		pRear->pNext = pHead;
	}
}

ElementType Delete()
{
	if (pHead)
	{
		ElementType T;
		List Temp = pRear;
		Temp->pPrior->pNext = Temp->pNext;
		Temp->pNext->pPrior = Temp->pPrior;
		pRear = Temp->pPrior;
		T=Temp->Data;
		free(Temp);
		return T;
	}
}

//栈
#define ElementTypye int
typedef struct StackNode *Stack;
struct StackNode
{
	ElementTypye Data;
	int iLength;
	Stack pTop;
};

Stack CreatStack()
{
	Stack S = (Stack)malloc(sizeof(struct StackNode));
	S->iLength = 0;
	S->pTop = NULL;
	return S;
}
int IsEmpty(Stack S)
{

	if (!S)
		return 1;
	else
		return 0;
}

void Push(Stack S,ElementTypye item)
{
	if (S)
	{
		Stack T = (Stack)malloc(sizeof(struct StackNode));
		T->Data = item;
		T->pTop = NULL;
		T->pTop = S->pTop;
		S->pTop = T;
		S->iLength++;
	}
}

ElementTypye Pop(Stack S)
{
	if (S->pTop)
	{
		Stack T = (Stack)malloc(sizeof(struct StackNode));
		T->pTop = NULL;
		T = S->pTop;
		S->pTop = T->pTop;
		ElementTypye X = T->Data;
		free(T);
		return X;
	}
}
//双端栈
#define ElementType int
#define MaxSize 7
typedef struct StackNode *Stack;
struct StackNode
{
	ElementType  Element[MaxSize];
	int iTop;
	int iTop2;
};

Stack CreatStack()
{
	Stack S=(Stack)malloc(sizeof(struct StackNode));
	S->iTop = -1;
	S->iTop2 = MaxSize;
	return S;
}

void Push(Stack S,ElementType T,int i)
{
	if (i==1&&S->iTop!=(S->iTop2-1))
	{
		S->Element[++(S->iTop)] = T;
	}
	else if (i == 2&&S->iTop2!=(S->iTop)+1)
	{
		S->Element[--(S->iTop2)] = T;
	}
}

ElementType Pop(Stack S,int i)
{
	if (i==1&&-1 != S->iTop)
	{
		ElementType T = S->Element[(S->iTop)--];
		return T;
	}
	else if (i == 2, S->iTop2 != MaxSize)
	{
		ElementType T = S->Element[(S->iTop2)++];
		return T;
	}
}

//循环队列
#define ElementType int
#define MaxSize 7
typedef struct QueueNode *Queue;
struct QueueNode
{
	ElementType Element[MaxSize];
	int front;
	int rear;
};

Queue CreatQueue()
{
	Queue Q = (Queue)malloc(sizeof(struct QueueNode));
	Q->front = 0;
	Q->rear = 0;
	return Q;
}

void Push(Queue Q, ElementType T)
{
	if (Q->rear!=MaxSize)
	{
		Q->Element[Q->rear] = T;
		Q->rear = (Q->rear + 1)%MaxSize;
	}
}

ElementType Pop(Queue Q)
{
	if (Q->front != Q->rear)
	{
		ElementType T = Q->Element[Q->front];
		Q->front = (Q->front + 1) % MaxSize;
		return T;
	}
}
//链队
#define ElementType int
typedef struct QueueNode *Node;
struct QueueNode
{
	ElementType Data;
	Node pNext;
};

typedef struct MyQueue *Queue;
struct MyQueue
{
	Node pFront;
	Node pRear;
};

Queue CreatQueue(Queue Q)
{
	Q->pFront = (Node)malloc(sizeof(struct QueueNode));
	Q->pFront->pNext = NULL;
	Q->pRear = Q->pFront;
	return Q;
}

void Push(Queue Q,ElementType T)
{
	if (Q)
	{
		Node Temp = (Node)malloc(sizeof(struct QueueNode));
		Temp->pNext = NULL;
		Temp->Data = T;
		Q->pRear->pNext = Temp;
		Q->pRear = Temp;
	}
}

ElementType Pop(Queue Q)
{
	if (Q->pFront->pNext)
	{
		ElementType T;
		Node Temp = Q->pFront->pNext;
		Q->pFront->pNext = Temp->pNext;
		T = Temp->Data;
		if (Temp == Q->pRear)
			Q->pFront == Q->pRear;
		return T;
		free(Temp);
	}
}