From 7a24d4e813c1ea4d8f91030f860f9d5e57a74a38 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BA=B7=E5=BB=BA=E4=BC=9F?= <kangjianwei1990@qq.com>
Date: Thu, 4 Jan 2018 20:18:48 +0800
Subject: [PATCH] =?UTF-8?q?:bulb:=20=E3=80=90=E6=95=99=E6=9D=90=E3=80=91?=
 =?UTF-8?q?=20=E2=96=B203=20=E6=A0=88=E5=92=8C=E9=98=9F=E5=88=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../01 SequenceStack/SequenceStack-main.c     | 110 ++++++++
 .../▲03 栈和队列/01 SequenceStack/SequenceStack.c | 106 +++++++
 .../▲03 栈和队列/01 SequenceStack/SequenceStack.h |  84 ++++++
 .../▲03 栈和队列/02 Conversion/Conversion-main.c |  22 ++
 .../▲03 栈和队列/02 Conversion/Conversion.c   |  41 +++
 .../▲03 栈和队列/02 Conversion/Conversion.h   |  23 ++
 .../▲03 栈和队列/03 LineEdit/LineEdit-main.c  |  26 ++
 .../▲03 栈和队列/03 LineEdit/LineEdit.c       |  67 +++++
 .../▲03 栈和队列/03 LineEdit/LineEdit.h       |  28 ++
 .../▲03 栈和队列/04 Maze/Maze-main.c          |  29 ++
 ▲课本算法实现/▲03 栈和队列/04 Maze/Maze.c     | 218 +++++++++++++++
 ▲课本算法实现/▲03 栈和队列/04 Maze/Maze.h     | 104 +++++++
 .../▲03 栈和队列/05 Expression/Expression-main.c |  23 ++
 .../▲03 栈和队列/05 Expression/Expression.c   | 180 ++++++++++++
 .../▲03 栈和队列/05 Expression/Expression.h   |  48 ++++
 .../▲03 栈和队列/06 Hanoi/Hanoi-main.c        |  27 ++
 ▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.c   |  37 +++
 ▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.h   |  30 ++
 .../▲03 栈和队列/07 LinkQueue/LinkQueue-main.c | 109 ++++++++
 .../▲03 栈和队列/07 LinkQueue/LinkQueue.c     | 133 +++++++++
 .../▲03 栈和队列/07 LinkQueue/LinkQueue.h     |  82 ++++++
 .../▲03 栈和队列/08 CylSeqQueue/CylSeqQueue-main.c | 109 ++++++++
 .../▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.c |  95 +++++++
 .../▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.h |  76 +++++
 .../▲03 栈和队列/09 BankQueuing/BankQueuing-main.c |  19 ++
 .../▲03 栈和队列/09 BankQueuing/BankQueuing.c | 260 ++++++++++++++++++
 .../▲03 栈和队列/09 BankQueuing/BankQueuing.h | 130 +++++++++
 27 files changed, 2216 insertions(+)
 create mode 100644 ▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack-main.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack.h
 create mode 100644 ▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion-main.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion.h
 create mode 100644 ▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit-main.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit.h
 create mode 100644 ▲课本算法实现/▲03 栈和队列/04 Maze/Maze-main.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/04 Maze/Maze.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/04 Maze/Maze.h
 create mode 100644 ▲课本算法实现/▲03 栈和队列/05 Expression/Expression-main.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/05 Expression/Expression.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/05 Expression/Expression.h
 create mode 100644 ▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi-main.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.h
 create mode 100644 ▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue-main.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue.h
 create mode 100644 ▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue-main.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.h
 create mode 100644 ▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing-main.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing.c
 create mode 100644 ▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing.h

diff --git a/▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack-main.c b/▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack-main.c
new file mode 100644
index 0000000..be12b78
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack-main.c	
@@ -0,0 +1,110 @@
+/******************************************
+ *						      			  *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\01 SequenceStack *
+ * 						      			  *
+ * ÄÚ  ÈÝ: ˳ÐòÕ»Ïà¹Øº¯Êý²âÊÔ 			  *
+ *                            			  *
+ ******************************************/
+
+#include <stdio.h>
+#include "SequenceStack.c" 								//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+	
+void PrintElem(SElemType_Sq e);
+	//²âÊÔº¯Êý£¬´òÓ¡ÕûÐÍ 
+
+int main(int argc, char **argv)
+{
+	SqStack S;
+	int i;
+	SElemType_Sq e;
+	
+	printf("¨‹1\n¡øº¯Êý InitStack ²âÊÔ...\n");			//1.º¯ÊýInitStack²âÊÔ
+	{
+		printf("³õʼ»¯Ë³ÐòÕ» S ...\n");					 
+		InitStack_Sq(&S);
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹4\n¡øº¯Êý StackEmpty ²âÊÔ...\n");			//4.º¯ÊýStackEmpty²âÊÔ
+	{
+		StackEmpty_Sq(S) ? printf(" S Ϊ¿Õ£¡£¡\n") : printf(" S ²»Îª¿Õ£¡\n");
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹7\n¡øº¯Êý Push ²âÊÔ...\n");					//7.º¯ÊýPush²âÊÔ
+	{
+		for(i=1; i<=6; i++)									
+		{
+			printf("½« \"%2d\" ѹÈëÕ» S ", 2*i);
+			Push_Sq(&S, 2*i);
+			printf("£¨ÀÛ¼ÆµÚ %d ¸öÔªËØ£©...\n", S.top-S.base);
+		}
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹9\n¡øº¯Êý StackTraverse ²âÊÔ...\n");		//9.º¯ÊýStackTraverse²âÊÔ
+	{
+		printf(" S ÖеÄÔªËØΪ£ºS = ");						 
+		StackTraverse_Sq(S, PrintElem);
+		printf("\n\n");
+	}
+	PressEnter;
+	
+	printf("¨‹8\n¡øº¯Êý Pop ²âÊÔ...\n");					//8.º¯ÊýPop²âÊÔ
+	{
+		Pop_Sq(&S, &e);
+		printf("Õ»¶¥ÔªËØ \"%d\" ³öÕ»...\n", e);
+		printf(" S ÖеÄÔªËØΪ£ºS = ");						 
+		StackTraverse_Sq(S, PrintElem);
+		printf("\n\n");
+	}
+	PressEnter;
+	
+	printf("¨‹5\n¡øº¯Êý StackLength ²âÊÔ...\n");			//5.º¯ÊýStackLength²âÊÔ
+	{
+		i = StackLength_Sq(S);
+		printf(" S µÄ³¤¶ÈΪ %d \n", i);
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹6\n¡øº¯Êý GetTop ²âÊÔ...\n");				//6.º¯ÊýGetTop²âÊÔ
+	{
+		GetTop_Sq(S, &e);
+		printf("Õ»¶¥ÔªËصÄֵΪ \"%d\" \n", e);
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹3\n¡øº¯Êý ClearStack ²âÊÔ...\n");			//3.º¯ÊýClearStack²âÊÔ
+	{
+		printf("Çå¿Õ S Ç°£º");
+		StackEmpty_Sq(S) ? printf(" S Ϊ¿Õ£¡£¡\n") : printf(" S ²»Îª¿Õ£¡\n");
+		ClearStack_Sq(&S);
+		printf("Çå¿Õ S ºó£º");
+		StackEmpty_Sq(S) ? printf(" S Ϊ¿Õ£¡£¡\n") : printf(" S ²»Îª¿Õ£¡\n");
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹2\n¡øº¯Êý DestroyStack ²âÊÔ...\n");			//2.º¯ÊýDestroyStack²âÊÔ
+	{
+		printf("Ïú»Ù S Ç°£º");
+		S.base!=NULL && S.top!=NULL ? printf(" S ´æÔÚ£¡\n") : printf(" S ²»´æÔÚ£¡£¡\n");
+		DestroyStack_Sq(&S);
+		printf("Ïú»Ù S ºó£º");
+		S.base!=NULL && S.top!=NULL ? printf(" S ´æÔÚ£¡\n") : printf(" S ²»´æÔÚ£¡£¡\n");
+		printf("\n");
+	}
+	PressEnter;
+		
+	return 0;
+}
+
+void PrintElem(SElemType_Sq e)
+{
+	printf("%d ", e);
+}
diff --git a/▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack.c b/▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack.c
new file mode 100644
index 0000000..c977c4d
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack.c	
@@ -0,0 +1,106 @@
+/******************************************
+ *							  			  *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\01 SequenceStack *
+ * 							  			  *
+ * ÎļþÃû: SequenceStack.c    			  *
+ *                            			  *
+ ******************************************/
+
+#ifndef SEQUENCESTACK_C
+#define SEQUENCESTACK_C
+
+#include "SequenceStack.h" 						//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+Status InitStack_Sq(SqStack *S)
+{
+ 	(*S).base = (SElemType_Sq *)malloc(STACK_INIT_SIZE*sizeof(SElemType_Sq));
+	if(!(*S).base)
+		exit(OVERFLOW);
+		
+	(*S).top = (*S).base;
+	(*S).stacksize = STACK_INIT_SIZE;
+	
+	return OK;
+} 
+
+Status DestroyStack_Sq(SqStack *S)
+{
+	free((*S).base);
+	
+	(*S).base = NULL;
+	(*S).top = NULL;
+	(*S).stacksize = 0;
+	
+	return OK;
+} 
+
+Status ClearStack_Sq(SqStack *S)
+{
+	(*S).top = (*S).base;
+	
+	return OK;
+} 
+
+Status StackEmpty_Sq(SqStack S)
+{
+	if(S.top==S.base)
+		return TRUE;
+	else
+		return FALSE;
+} 
+
+int StackLength_Sq(SqStack S)
+{
+	return S.top - S.base;
+} 
+
+Status GetTop_Sq(SqStack S, SElemType_Sq *e)
+{
+	if(S.top==S.base)
+		return ERROR;
+		
+	*e = *(S.top - 1);							//²¢²»ÆÆ»µÕ» 
+	
+	return OK;
+
+} 
+
+Status Push_Sq(SqStack *S, SElemType_Sq e)
+{
+	if((*S).top-(*S).base>=(*S).stacksize)		//Õ»Âú£¬×·¼Ó´æ´¢¿Õ¼ä
+	{
+		(*S).base = (SElemType_Sq *)realloc((*S).base, ((*S).stacksize+STACKINCREMENT)*sizeof(SElemType_Sq));
+		if(!(*S).base)
+			exit(OVERFLOW);						//´æ´¢·ÖÅäʧ°Ü
+		(*S).top = (*S).base + (*S).stacksize;
+		(*S).stacksize += STACKINCREMENT;
+	}
+	
+	*(S->top) = e;								//½øÕ»Ïȸ³Öµ£¬Õ»¶¥Ö¸ÕëÔÙ×ÔÔö 
+	(S->top)++;
+
+	return OK;
+} 
+
+Status Pop_Sq(SqStack *S, SElemType_Sq *e)
+{
+	if((*S).top==(*S).base)
+		return ERROR;
+
+	(*S).top--;									//³öÕ»Õ»¶¥Ö¸ÕëÏȵݼõ£¬ÔÙ¸³Öµ 
+	*e = *((*S).top);
+
+	return OK;
+} 
+
+Status StackTraverse_Sq(SqStack S, void(Visit)(SElemType_Sq))
+{												//±éÀú²»Ó¦¸ÃÆÆ»µÕ» 
+	SElemType_Sq *p = S.base;
+	
+	while(p<S.top)
+		Visit(*p++);
+	
+	return OK;
+} 
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack.h b/▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack.h
new file mode 100644
index 0000000..016a987
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/01 SequenceStack/SequenceStack.h	
@@ -0,0 +1,84 @@
+/******************************************
+ *						      			  *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\01 SequenceStack *
+ * 							    		  *
+ * ÎļþÃû: SequenceStack.h    			  *
+ * 							  			  *
+ * ÄÚ  ÈÝ: ˳ÐòÕ»Ïà¹Ø²Ù×÷Áбí 			  *
+ *                            			  *
+ ******************************************/
+
+#ifndef SEQUENCESTACK_H
+#define SEQUENCESTACK_H
+
+#include <stdio.h>
+#include <stdlib.h>						//Ìṩmalloc¡¢realloc¡¢free¡¢exitÔ­ÐÍ
+#include "../../¡ø01 Ð÷ÂÛ/Status.h"		//**¡ø01 Ð÷ÂÛ**//
+
+/* ºê¶¨Òå */
+#define STACK_INIT_SIZE	100				//˳ÐòÕ»´æ´¢¿Õ¼äµÄ³õʼ·ÖÅäÁ¿
+#define STACKINCREMENT	10 				//˳ÐòÕ»´æ´¢¿Õ¼äµÄ·ÖÅäÔöÁ¿
+
+/* ˳ÐòÕ»ÀàÐͶ¨Òå */
+/*ÔÚÃÔ¹¬¡¢±í´ïʽ¡¢¶þ²æÊ÷¶þ²æÁ´±í¡¢º¢×ÓÐÖµÜÊ÷µÈËã·¨ÖУ¬´ËÀàÐÍÐèÒªÖØж¨Òå*/
+#if !defined MAZE_H				&&  \
+    !defined EXPRESSION_H		&&  \
+    !defined BINARYTREE_H		&&  \
+    !defined CHILDSIBLINGTREE_H	&&  \
+    !defined Question_8
+typedef int SElemType_Sq;
+#endif
+typedef struct
+{
+	SElemType_Sq *base;				//ÔÚÕ»¹¹Ôì֮ǰºÍÏú»ÙÖ®ºó£¬baseµÄֵΪNULL 
+	SElemType_Sq *top;				//Õ»¶¥Ö¸Õë 
+	int stacksize;					//µ±Ç°ÒÑ·ÖÅäµÄ´æ´¢¿Õ¼ä£¬ÒÔÔªËØΪµ¥Î» 
+}SqStack;
+
+/* ˳ÐòÕ»º¯ÊýÁбí */
+Status InitStack_Sq(SqStack *S);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(01)¹¹Ôì¿ÕÕ»S¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status DestroyStack_Sq(SqStack *S);
+/*©¥©¥©¥©¥©¥©¥©·
+©§(02)Ïú»ÙS¡£ ©§
+©»©¥©¥©¥©¥©¥©¥*/ 
+ 
+Status ClearStack_Sq(SqStack *S);
+/*©¥©¥©¥©¥©¥©¥©·
+©§(03)ÖÿÕS¡£ ©§
+©»©¥©¥©¥©¥©¥©¥*/
+
+Status StackEmpty_Sq(SqStack S);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(04)ÅжÏSÊÇ·ñΪ¿Õ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+int StackLength_Sq(SqStack S);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(05)·µ»ØSÔªËظöÊý¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+ 
+Status GetTop_Sq(SqStack S, SElemType_Sq *e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(06)ÓÃe»ñÈ¡Õ»¶¥ÔªËØ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status Push_Sq(SqStack *S, SElemType_Sq e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(07)ÔªËØe½øÕ»¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status Pop_Sq(SqStack *S, SElemType_Sq *e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(08)ÔªËØe³öÕ»¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status StackTraverse_Sq(SqStack S, void(Visit)(SElemType_Sq));
+/*©¥©¥©¥©¥©¥©¥©·
+©§(09)·ÃÎÊÕ»¡£©§
+©»©¥©¥©¥©¥©¥©¥*/
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion-main.c b/▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion-main.c
new file mode 100644
index 0000000..004a963
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion-main.c	
@@ -0,0 +1,22 @@
+/***************************************
+ *						        	   *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\02 Conversion *
+ * 						        	   *
+ * ÄÚ  ÈÝ: ½øÖÆת»»Ïà¹Øº¯Êý²âÊÔ		   *
+ *                              	   *
+ ***************************************/
+
+#include "Conversion.c"					//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+int main(int argc, char **argv)
+{
+	int i = 342391;
+		
+	printf("½«Ê®½øÖÆÊýת»»Îª°Ë½øÖÆÊý...\n");
+
+	conversion(i);
+	
+	printf("\n\n");
+	
+	return 0;
+}
diff --git a/▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion.c b/▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion.c
new file mode 100644
index 0000000..f45b527
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion.c	
@@ -0,0 +1,41 @@
+/***************************************
+ *					     			   *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\02 Conversion *
+ * 					     			   *
+ * ÎļþÃû: Conversion.c  			   *
+ * 				         			   *
+ * Ëã  ·¨: 3.1           			   * 
+ *                       			   *
+ ***************************************/
+
+#ifndef CONVERSION_C
+#define CONVERSION_C
+
+#include "Conversion.h"					//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+/*¨T¨T¨T¨T¨[
+¨U Ëã·¨3.1¨U 
+¨^¨T¨T¨T¨T*/
+void conversion(int i)
+{	
+	SqStack S; 
+	SElemType_Sq e;
+	
+	InitStack_Sq(&S);
+
+	printf("Ê®½øÖÆÊý %d ת»»Îª°Ë½øÖÆÊýºóΪ£º0", i);
+	
+	while(i)
+	{
+		Push_Sq(&S, i%8);				//½øջʱ´ÓµÍλµ½¸ßλ 
+		i = i/8;
+	}
+	
+	while(!StackEmpty_Sq(S))
+	{
+		Pop_Sq(&S, &e);					//³öջʱ´Ó¸ßλµ½µÍλ 
+		printf("%d", e);
+	}
+} 
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion.h b/▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion.h
new file mode 100644
index 0000000..4719e89
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/02 Conversion/Conversion.h	
@@ -0,0 +1,23 @@
+/***************************************
+ *							    	   *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\02 Conversion *
+ * 							    	   *
+ * ÎļþÃû: Conversion.h         	   *
+ * 							    	   *
+ * ÄÚ  ÈÝ: ½øÖÆת»»Ïà¹Ø²Ù×÷Áбí 	   *
+ *                              	   *
+ ***************************************/
+
+#ifndef CONVERSION_H
+#define CONVERSION_H
+
+#include <stdio.h> 
+#include "../01 SequenceStack/SequenceStack.c" 		//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+/* ½øÖÆת»»º¯ÊýÁбí */
+void conversion(int i);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(01)Ëã·¨3.1£ºÊ®½øÖÆÊýת°Ë½øÖÆÊý¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit-main.c b/▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit-main.c
new file mode 100644
index 0000000..b9f5222
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit-main.c	
@@ -0,0 +1,26 @@
+/*************************************
+ *						             *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\03 LineEdit *
+ * 						             *
+ * ÄÚ  ÈÝ: Ðб༭³ÌÐòÏà¹Øº¯Êý²âÊÔ    *
+ *                                   *
+ *************************************/
+
+#include "LineEdit.c"					//**¡ø03 Õ»ºÍ¶ÓÁÐ**//					
+
+int main(int argc, char *argv[])
+{
+	char *buf = "whli##ilr#e(s#*s)\noutcha@  putchar(*s=#++);"; //ÐèҪ¼ÈëµÄÄÚÈÝ 
+	
+	printf("×÷Ϊʾ·¶£¬Óû§ÊäÈëµÄÎı¾ÄÚÈÝΪ£º\n");
+	printf("%s\n", buf);
+	printf("\n");
+	printf("½øÈëÐб༭³ÌÐò...\n"); 
+	printf("ÌØÊâ·ûºÅ£º¡°#¡± ´ú±íɾ³ýÉÏÒ»ÔªËØ£¬¡°@¡±´ú±íɾ³ýµ±Ç°ÊäÈëÐУ¬\n");
+	printf("          ¡°\\n¡±´ú±íÈ·ÈÏ´ËÐÐÎÞÎ󣬡°\\0¡±´ú±íÊäÈë½áÊø¡£\n");
+	printf("×îÖÕ´æ´¢µÄÄÚÈÝΪ£º\n");
+	LineEdit(buf);
+	printf("\n\n");
+
+	return 0;
+}
diff --git a/▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit.c b/▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit.c
new file mode 100644
index 0000000..75472e0
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit.c	
@@ -0,0 +1,67 @@
+/*************************************
+ *					     			 *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\03 LineEdit *
+ * 					     			 *
+ * ÎļþÃû: LineEdit.c    			 *
+ * 				         			 *
+ * Ëã  ·¨: 3.2           			 *
+ *                       			 *
+ *************************************/
+
+#ifndef LINEEDIT_C
+#define LINEEDIT_C
+
+#include "LineEdit.h"				//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+/*¨T¨T¨T¨T¨[
+¨U Ëã·¨3.2¨U 
+¨^¨T¨T¨T¨T*/
+/* ÓëÑÏεÃô¿Î±¾ËùÊöËã·¨ÂÔÓвî±ð£¬µ«Ë㷨˼ÏëÒ»Ö */
+void LineEdit(char Buffer[])
+{
+	SqStack S;						//½ÓÊÕÊäÈëµÄ×Ö·û
+	SElemType_Sq e;
+	int i;
+	char ch;
+	
+	InitStack_Sq(&S);
+	
+	i = 0;
+	ch = Buffer[i++];
+	while(ch!='\0')
+	{
+		while(ch!='\0' && ch!='\n')
+		{
+			switch(ch)
+			{
+				case '#': Pop_Sq(&S, &e);
+					break;
+				case '@': ClearStack_Sq(&S);
+					break;
+				default : Push_Sq(&S, ch);
+			}
+			ch = Buffer[i++];
+		}
+		
+		if(ch=='\n')
+		{
+			Push_Sq(&S, ch);			
+			StackTraverse_Sq(S, Print);
+			ClearStack_Sq(&S);
+			ch = Buffer[i++];
+		}
+	}
+	
+	if(ch=='\0')
+	{
+		StackTraverse_Sq(S, Print);
+		DestroyStack_Sq(&S);
+	}
+}
+
+void Print(SElemType_Sq e)
+{
+	printf("%c", e);
+}
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit.h b/▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit.h
new file mode 100644
index 0000000..9a38b42
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/03 LineEdit/LineEdit.h	
@@ -0,0 +1,28 @@
+/*************************************
+ *							      	 *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\03 LineEdit *
+ * 							      	 *
+ * ÎļþÃû: LineEdit.h             	 *
+ * 							      	 *
+ * ÄÚ  ÈÝ: Ðб༭³ÌÐòÏà¹Ø²Ù×÷ÁÐ±í  	 *
+ *                                	 *
+ *************************************/
+
+#ifndef LINEEDIT_H
+#define LINEEDIT_H
+
+#include <stdio.h> 
+#include "../01 SequenceStack/SequenceStack.c" 		//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+/* Ðб༭³ÌÐòº¯ÊýÁбí */
+void LineEdit(char Buffer[]);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(01)Ëã·¨3.2£ºÐб༭³ÌÐò¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void Print(SElemType_Sq e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(02)´òÓ¡ÔªËØe¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/04 Maze/Maze-main.c b/▲课本算法实现/▲03 栈和队列/04 Maze/Maze-main.c
new file mode 100644
index 0000000..774137f
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/04 Maze/Maze-main.c	
@@ -0,0 +1,29 @@
+/*********************************
+ *						         *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\04 Maze *
+ * 						         *
+ * ÄÚ  ÈÝ: ÃÔ¹¬Ïà¹Øº¯Êý²âÊÔ      *
+ *                               *
+ *********************************/
+
+#include "Maze.c"						//**¡ø03 Õ»ºÍ¶ÓÁÐ**//					
+
+int main(int argc, char *argv[])
+{
+	MazeType maze[N][N];
+	PosType start, end;
+	SElemType_Sq e;
+	char Re = 'Y';
+	
+	while(Re=='Y' || Re=='y')
+	{ 
+		InitMaze(maze, &start, &end);	//³õʼ»¯ÃÔ¹¬£¬°üÀ¨³öÈë¿Ú 
+		ShowMaze(maze);					//ÏÔʾÃÔ¹¬µÄ³õʼ״̬ 
+		MazePath(maze,start,end);		//ÃÔ¹¬Ñ°Â·
+		
+		printf("ÖØÖã¿£¨Y/N£©£º");
+		scanf("%c", &Re);
+	}
+	
+	return 0;
+}
diff --git a/▲课本算法实现/▲03 栈和队列/04 Maze/Maze.c b/▲课本算法实现/▲03 栈和队列/04 Maze/Maze.c
new file mode 100644
index 0000000..fca412b
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/04 Maze/Maze.c	
@@ -0,0 +1,218 @@
+/*********************************
+ *					             *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\04 Maze *
+ * 					             *
+ * ÎļþÃû: Maze.c                *
+ * 				                 *
+ * Ëã  ·¨: 3.3                   *
+ *                               *
+ *********************************/
+
+#ifndef MAZE_C
+#define MAZE_C
+
+#include "Maze.h"							//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+/*¨T¨T¨T¨T¨[
+¨U Ëã·¨3.3¨U 
+¨^¨T¨T¨T¨T*/
+Status MazePath(MazeType maze[][N], PosType start, PosType end)
+{
+	SqStack S;
+	SElemType_Sq nodeInf;					//nodeInf´æ´¢µ±Ç°Í¨µÀ¿éÐÅÏ¢ 
+	PosType curPos;							//µ±Ç°Î»Öà 
+	int curStep;							//µ±Ç°Í¨µÀ¿éÐòºÅ 
+	
+	InitStack_Sq(&S);
+	curPos = start;							//É趨µ±Ç°Î»ÖÃΪ"³ö¿ÚλÖÃ" 
+	curStep = 1;
+	
+	do
+	{
+		if(Pass(curPos, maze))				//µ±Ç°Î»ÖÿÉͨ¹ý£¬¼´ÊÇδÔø·ÃÎʵÄͨµÀ¿é 
+		{
+			FootPrint(curPos, maze);		//ÁôÏÂ×ã¼£
+			ShowMaze(maze); 
+
+			SetSElemType(&nodeInf, curStep, curPos, East);	//ÉèÖÃͨµÀ¿éÐÅÏ¢
+			Push_Sq(&S, nodeInf); 			//¼ÓÈë·¾¶ 
+
+			if(EqualPosType(curPos, end))	//µ½´ïÖÕµã
+			{
+				printf("\nѰ·³É¹¦£¡£¡\n\n");
+				return TRUE;	
+			}
+			
+			curPos = NextPos(curPos, East);	//ÏÂһλÖÃÊǵ±Ç°Î»ÖõĶ«ÁÚ 
+			curStep++;						//̽Ë÷ÏÂÒ»²½ 
+		}
+		else								//µ±Ç°Î»Öò»ÄÜͨ¹ý 
+		{
+			if(!StackEmpty_Sq(S))
+			{
+				Pop_Sq(&S, &nodeInf);		//Ð޸ĽáµãÖ¸Ïò
+				 
+				while(nodeInf.di==North && !StackEmpty_Sq(S))	//´ËͨµÀ¿é4¸ö·½Ïò¶¼±éÀú¹ý 
+				{
+					MarkPrint(nodeInf.seat, maze);				//Áôϲ»ÄÜͨ¹ýµÄ±ê¼Ç£¬²¢ÍË»ØÒ»²½ 
+					ShowMaze(maze);
+
+					Pop_Sq(&S, &nodeInf);
+				}
+
+				if(nodeInf.di<North)
+				{
+					maze[nodeInf.seat.x][nodeInf.seat.y] = ++nodeInf.di;//¸Ä±ä̽Ë÷·½Ïò£¬ÔÚÃÔ¹¬Êý×éÖÐÁôϱê¼Ç	
+					ShowMaze(maze);
+
+					Push_Sq(&S, nodeInf);
+
+					curPos = NextPos(nodeInf.seat, nodeInf.di);
+				}
+			}
+		}		
+	}while(!StackEmpty_Sq(S));	
+	
+	printf("\nѰ·ʧ°Ü£¡£¡\n\n");
+	
+	return FALSE;	
+}
+
+void InitMaze(MazeType maze[][N], PosType *start, PosType *end) 
+{												//ÃÔ¹¬¹æģΪN¡ÁN 
+	int i, j, tmp;
+		
+	srand((unsigned)time(NULL));				//ÓÃϵͳʱ¼ä×öËæ»úÊýÖÖ×Ó 
+	
+	for(i=0; i<N; i++)
+	{
+		for(j=0; j<N; j++)
+		{
+			if(i==0 || j==0 || i==N-1 || j==N-1)
+				maze[i][j] = Wall;				//ÃÔ¹¬Íâǽ
+			else
+			{
+				tmp = rand()%X;					//Éú³ÉËæ»úÊýÌî³äÃÔ¹¬ 		
+				if(!tmp)
+					maze[i][j] = Obstacle;		//1/XµÄ¸ÅÂÊÉú³ÉÕÏ°­ 
+				else
+					maze[i][j] = Way;			//ÆäËüµØ·½¼ÓÈë·¾¶ 
+			}
+		}	
+	}
+	
+	(*start).x = 1;								//ÃÔ¹¬Èë¿Ú
+	(*start).y = 0;
+	(*end).x = N-2;								//ÃÔ¹¬³ö¿Ú 
+	(*end).y = N-1;	
+	
+	maze[1][0] = maze[N-2][N-1] = Way;			//¿ª·ÅÈë¿ÚºÍ³ö¿Ú 
+	maze[1][1] = maze[N-2][N-2] = Way;			//ΪÁËÌá¸ß³É¹¦ÂÊ£¬Èë¿Ú´¦ºÍ³ö¿Ú´¦ÁÙ½üµÄ½áµãÒ»Ö±ÉèΪͨ· 
+}
+
+void PaintMaze(MazeType maze[][N])
+{
+	int i, j;
+	
+	for(i=0; i<N; i++)
+		for(j=0; j<N; j++)
+		{
+			if(maze[i][j]==Wall)				//Íâǽ 
+				printf("¨~");
+			else if(maze[i][j]==Obstacle)		//ÄÚ²¿ÕÏ°­ 
+				printf("¨ˆ");
+			else if(maze[i][j]==East)			//³¯¶«Ì½Ë÷
+				printf("¡ú");
+			else if(maze[i][j]==South)			//³¯ÄÏ̽Ë÷
+				printf("¡ý");
+			else if(maze[i][j]==West)			//³¯Î÷̽Ë÷
+				printf("¡û");
+			else if(maze[i][j]==North)			//³¯±±Ì½Ë÷
+				printf("¡ü");
+			else if(maze[i][j]==DeadLock)		//·ÃÎʹýÇÒ²»ÄÜͨ¹ýµÄ½áµã 
+				printf("¡ï");
+			else								//δ·ÃÎʹýµÄ·¾¶½áµã 
+				printf("  ");
+
+			if(j!=0 && j%(N-1)==0)				//ÿ¸ôN¸ö½áµã»»ÐÐ 
+				printf("\n");
+		}
+}
+
+void ShowMaze(MazeType maze[][N])	//Ï൱ÓÚˢвÙ×÷ 
+{
+	Wait(SleepTime);				//ÔÝÍ£ 
+	system("cls");					//ÏÈÇå³ýÆÁÄ»ÏÖÓÐÄÚÈÝ 
+	PaintMaze(maze);				//ÔÚÆÁÄ»ÉÏ»­³öÃÔ¹¬ 
+} 
+
+Status EqualPosType(PosType seat1, PosType seat2)
+{
+	if(seat1.x==seat2.x && seat1.y==seat2.y)
+		return TRUE;	//Á½Í¨µÀ¿é×ø±êÏàµÈ·µ»Ø1 
+	else
+		return ERROR;
+}
+
+Status Pass(PosType seat, MazeType maze[][N])		 
+{
+	int x = seat.x;
+	int y = seat.y;
+	
+	if(!IsCross(seat) && maze[x][y]==Way)	//½áµã²»ÄÜÔ½½ç
+		return TRUE;
+	else
+		return ERROR;
+}
+
+void FootPrint(PosType seat, MazeType maze[][N])	//ËùνÁôÏÂ×ã¼£¼´ÉèÖÃÆäÏÂÒ»´Î·ÃÎÊ·½Ïò 
+{	
+	maze[seat.x][seat.y] = East; 					//³õʼÉèÖÃÏò¶«Ì½Ë÷ 
+} 
+
+void SetSElemType (SElemType_Sq *e, int ord, PosType seat, int di)
+{
+	(*e).ord = ord;
+	(*e).seat = seat;
+	(*e).di = di;
+}
+
+PosType NextPos(PosType seat, int di)
+{	
+	PosType tmp = seat;
+
+	switch(di)
+	{
+		case East:  tmp.y++;			//Ïò¶« 
+			break;	
+		case South: tmp.x++;			//ÏòÄÏ
+			break;
+		case West:  tmp.y--;			//ÏòÎ÷ 
+			break;
+		case North: tmp.x--;			//Ïò±±
+			break;
+	}
+	
+	return tmp;
+}
+
+Status IsCross(PosType seat)
+{
+	int x = seat.x;
+	int y = seat.y;
+	
+	if(x<0 || y<0 || x>N-1 || y>N-1)
+		return TRUE;					//Ô½½ç 
+	else
+		return FALSE; 
+}
+
+void MarkPrint(PosType seat, MazeType maze[][N])
+{
+	int x = seat.x;
+	int y = seat.y;
+	
+	maze[x][y] = DeadLock;			    //Áôϲ»ÄÜͨ¹ýµÄ±ê¼Ç 
+}
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/04 Maze/Maze.h b/▲课本算法实现/▲03 栈和队列/04 Maze/Maze.h
new file mode 100644
index 0000000..6af17df
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/04 Maze/Maze.h	
@@ -0,0 +1,104 @@
+/*********************************
+ *							     *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\04 Maze *
+ * 							     *
+ * ÎļþÃû: Maze.h                *
+ * 							     *
+ * ÄÚ  ÈÝ: ÃÔ¹¬Ïà¹Ø²Ù×÷ÁÐ±í      *
+ *                               *
+ *********************************/
+
+#ifndef MAZE_H
+#define MAZE_H
+
+#include <stdio.h>		
+#include <stdlib.h> 					//Ìṩsystem¡¢rand¡¢srandÔ­ÐÍ 
+#include <time.h>						//ÌṩtimeÔ­ÐÍ
+#include "../../¡ø01 Ð÷ÂÛ/Status.h"		//**¡ø01 Ð÷ÂÛ**//
+
+/* ºê¶¨Òå */ 
+#define N 15							//ÃÔ¹¬µÄ´óСΪN¡ÁN
+#define X 4								//XÓÃÓÚËæ»úÊýÈ¡Ó࣬ÆäÉú³ÉµÄËæ»úÊý·¶Î§ÊÇ0µ½X-1
+															//XÔ½´ó£¬Éú³É¿ÉͨÐÐÃÔ¹¬µÄ¸ÅÂʾÍÔ½´ó
+#define SleepTime 3						//SleepTime´ú±íÐÝÃßʱ¼ä¼ä¸ô
+
+/* ÃÔ¹¬ÀàÐͶ¨Òå */
+typedef enum							//ÃÔ¹¬Í¨µÀ¿éÀàÐÍ
+{ 
+	Wall,								//Íâǽ 
+	Obstacle,							//ÃÔ¹¬ÕÏ°­ 
+	Way,								//·¾¶ 
+	DeadLock,							//·¾¶Éϵġ°ËÀºúͬ¡± 
+	East,South,West,North				//·ÃÎÊ·½Ïò-¶«ÄÏÎ÷±± 
+}MazeNode;
+typedef struct							//ÃÔ¹¬Í¨µÀ¿é×ø±ê
+{
+	int x;								//ͨµÀ¿éµÄºá¡¢×Ý×ø±ê¶¨Òå 
+	int y;
+}PosType;
+typedef struct							//ͨµÀ¿éÐÅÏ¢ 
+{
+	int		ord;						//ͨµÀ¿éµÄ¡°ÐòºÅ¡± 
+	PosType seat;						//ͨµÀ¿éµÄ¡°×ø±êλÖá± 
+	int		di;							//ÏÂÒ»¸ö¸Ã·ÃÎʵġ°·½Ïò¡± 
+}SElemType_Sq;
+#include "../01 SequenceStack/SequenceStack.c" 	//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+typedef int MazeType;					//ÃÔ¹¬ÔªËØÀàÐÍ 
+
+/* ÃÔ¹¬º¯ÊýÁбí */ 
+Status MazePath(MazeType maze[][N], PosType start, PosType end); 
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(01)Ëã·¨3.3£ºÃÔ¹¬Ñ°Â·£¨Çî¾Ù·¨£© ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void InitMaze(MazeType maze[][N], PosType *start, PosType *end);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(02)ÃÔ¹¬µÄ³õʼ»¯,°üÀ¨³öÈë¿ÚµÄ³õʼ»¯ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void PaintMaze(MazeType maze[][N]);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(03)ÔÚÆÁÄ»ÉÏ»­³öÃÔ¹¬©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void ShowMaze(MazeType maze[][N]);
+/*©¥©¥©¥©¥©¥©¥©¥©·
+©§(04)ÃÔ¹¬µÄÏÔʾ©§
+©»©¥©¥©¥©¥©¥©¥©¥*/ 
+
+Status EqualPosType(PosType a, PosType b);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(05)±È½ÏÃÔ¹¬ÖÐÁ½¸öͨµÀ¿éÊÇ·ñΪͬһͨµÀ¿é©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/ 
+
+Status Pass(PosType seat, MazeType maze[][N]);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(06)Åж¨´ËͨµÀ¿éÊÇ·ñδ·ÃÎÊ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/ 
+
+void FootPrint(PosType seat, MazeType maze[][N]); 
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(07)Óöµ½Î´·ÃÎʽáµãʱÁôϳõʼ×ã¼£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/ 
+
+void SetSElemType(SElemType_Sq *e, int ord, PosType seat, int di);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(08)¸üÐÂͨµÀ¿éµÄÐÅÏ¢©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/ 
+
+PosType NextPos(PosType seat, int di); 
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(09)µ±Ç°Í¨µÀ¿éµÄºó¼Ì©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/ 
+
+Status IsCross(PosType seat);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(10)Åжϵ±Ç°Î»ÖÃÊÇ·ñÔ½½ç©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/ 
+
+void MarkPrint(PosType seat, MazeType maze[][N]);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(11)±ê¼Çµ±Ç°Î»ÖÃÉϵÄͨµÀ¿é²»¿É·ÃÎÊ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/  
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/05 Expression/Expression-main.c b/▲课本算法实现/▲03 栈和队列/05 Expression/Expression-main.c
new file mode 100644
index 0000000..ffe7f59
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/05 Expression/Expression-main.c	
@@ -0,0 +1,23 @@
+/***************************************
+ *						               *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\05 Expression *
+ * 						               *
+ * ÄÚ  ÈÝ: ±í´ïʽÇóÖµÏà¹Øº¯Êý²âÊÔ      *
+ *                                     *
+ ***************************************/
+
+#include "Expression.c"			//**¡ø03 Õ»ºÍ¶ÓÁÐ**//					
+
+int main(int argc, char **argv)
+{
+	char opnd;
+	char *exp = "(2+3)*4*6#";
+	
+	opnd = EvaluateExpression(exp);
+	
+	printf("×÷ΪʾÀý£¬%s µÄ¼ÆËã½á¹ûΪ£º%d\n", exp, opnd-'0');
+	
+	printf("\n");
+	
+	return 0;
+}
diff --git a/▲课本算法实现/▲03 栈和队列/05 Expression/Expression.c b/▲课本算法实现/▲03 栈和队列/05 Expression/Expression.c
new file mode 100644
index 0000000..1889498
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/05 Expression/Expression.c	
@@ -0,0 +1,180 @@
+/***************************************
+ *					                   *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\05 Expression *
+ * 					                   *
+ * ÎļþÃû: Expression.c                *
+ * 				                       *
+ * Ëã  ·¨: 3.4                         *
+ *                                     *
+ ***************************************/
+
+#ifndef EXPRESSION_C
+#define EXPRESSION_C
+
+#include "Expression.h"		//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+/*¨T¨T¨T¨T¨[
+¨U Ëã·¨3.4¨U 
+¨^¨T¨T¨T¨T*/
+OperandType EvaluateExpression(char exp[])	//´Óexp¶ÁÈë±í´ïʽ 
+{
+	SqStack OPTR, OPND;						//·ûºÅÕ»ºÍÊý×ÖÕ» 
+	SElemType_Sq e, ch;
+	OperatorType theta, x;					//·ûºÅ 
+	OperandType a, b;						//Êý×Ö 
+	int i;
+	
+	InitStack_Sq(&OPTR);	
+	Push_Sq(&OPTR, '#');
+	InitStack_Sq(&OPND);
+	
+	i = 0;
+	ch = exp[i++];
+	while(ch!='#' || GetTop_OPTR(OPTR)!='#')
+	{
+		if(!In(ch))							//c²»ÊÇ·ûºÅÔòÈëÕ» 
+		{
+			Push_Sq(&OPND, ch);
+		 	ch = exp[i++];		
+		}
+		else
+		{
+			switch(Precede(GetTop_OPTR(OPTR), ch))
+			{
+				case '<': 					//Õ»ÖзûºÅÓÅÏȼ¶µÍ£¬¼ÌÐø½øÕ» 
+					Push_Sq(&OPTR, ch);			
+			  		ch = exp[i++];
+ 					break;
+ 
+ 				case '=': 					//ÓÅÏȼ¶ÏàµÈʱ£¬ËµÃ÷Óöµ½À¨ºÅ£¬ÐèÒªÍÑÀ¨ºÅ
+					Pop_Sq(&OPTR, &x);			 
+				 	ch = exp[i++];
+			  		break;
+
+  			case '>': 
+					Pop_Sq(&OPTR, &theta);	//Õ»ÖвÙ×÷·ûÓÅÏȼ¶¸ßʱ£¬ÏȼÆË㣬ÔÙ½µ¼ÆËã½á¹ûѹÈëÕ»£¬ 
+		  		Pop_Sq(&OPND, &b);
+		  		Pop_Sq(&OPND, &a);
+		  		Push_Sq(&OPND, Operate(a, theta, b));	 
+			  	break;						//Õâ¶ùûÓжÁ×Ö·û£¬c±£ÁôµÄ»¹ÊǸղŶÁµ½µÄ×Ö·û 
+			}
+		}
+	}
+	
+	return GetTop_OPTR(OPND);	 
+} 
+
+OperatorType GetTop_OPTR(SqStack OPTR)
+{
+	SElemType_Sq e;
+	
+	GetTop_Sq(OPTR, &e);
+	
+	return e;
+}
+
+Status In(SElemType_Sq c)
+{
+	switch(c)
+	{
+		case '+':
+		case '-':
+		case '*':
+		case '/':
+		case '(':
+		case ')':
+		case '#': 
+			return TRUE;
+		default : 
+			return FALSE;
+   }
+}
+
+OperatorType Precede(OperatorType o1, OperatorType o2)
+{
+	OperatorType f;
+	
+	switch(o2)
+	{
+		case '+':
+		case '-': 
+			if(o1=='(' || o1=='#')
+				f = '<';
+			else
+				f = '>';
+			break;
+			
+		case '*':
+		case '/': 
+			if(o1=='*' || o1=='/' || o1==')')
+                f = '>';
+			else
+                f = '<';
+			break;
+              
+		case '(': 
+			if(o1==')')
+			{
+				printf("À¨ºÅÆ¥Åä´íÎó£¡\n");
+				exit(ERROR);
+			}
+			else
+				f = '<';
+			break;
+			
+		case ')': 
+			switch(o1)
+			{
+				case '(':
+					f = '=';
+					break;
+				case '#':
+					printf("ÊäÈëÁË´íÎóµÄÀ¨ºÅ£¡\n");
+					exit(ERROR);
+				default:
+					f = '>';
+			}
+			break;
+			
+		case '#': 
+			switch(o1)
+			{
+				case '#': 
+					f = '=';
+					break;
+				case '(': 
+					printf("±í´ïʽÖÐÓжàÓàÀ¨ºÅ£¡\n");
+     				exit(ERROR);
+				default:
+					f = '>';
+			}
+	}
+	
+	return f;
+}
+
+OperandType Operate(OperandType a, OperatorType theta, OperandType b)
+{
+	int x, y, z;
+	
+	x = a - 48;
+	y = b - 48;
+	
+	switch(theta)
+	{
+		case '+':
+			return x+y+48;
+			break;
+		case '-': 
+			return x-y+48;
+			break;
+		case '*':
+			return x*y+48;
+			break;
+		case '/':
+			return x/y+48;
+			break;
+	}
+}
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/05 Expression/Expression.h b/▲课本算法实现/▲03 栈和队列/05 Expression/Expression.h
new file mode 100644
index 0000000..10843f9
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/05 Expression/Expression.h	
@@ -0,0 +1,48 @@
+/***************************************
+ *							           *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\05 Expression *
+ * 							           *
+ * ÎļþÃû: Expression.h                *
+ * 							           *
+ * ÄÚ  ÈÝ: ±í´ïʽÇóÖµÏà¹Ø²Ù×÷ÁÐ±í      *
+ *                                     *
+ ***************************************/
+
+#ifndef EXPRESSION_H
+#define EXPRESSION_H
+
+#include <stdio.h> 
+
+/* ÀàÐͶ¨Òå */ 
+typedef char SElemType_Sq;
+#include "../01 SequenceStack/SequenceStack.c" 	//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+typedef SElemType_Sq OperandType;				//²Ù×÷ÊýÀàÐÍ
+typedef SElemType_Sq OperatorType;				//ÔËËã·ûÀàÐÍ 
+
+OperandType EvaluateExpression(char exp[]);	
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(01)Ëã·¨3.4£º±í´ïʽÇóÖµ£¬¼ÙÉè±í´ïʽÖвÙ×÷Êý¾ùÖ»ÓÐһλ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+OperatorType GetTop_OPTR(SqStack OPTR);	
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(02)»ñÈ¡²Ù×÷·ûÕ»µÄÕ»¶¥ÔªËØ¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status In(SElemType_Sq c); 
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(03)ÅжÏcÊÇ·ñÊôÓÚ²Ù×÷·û¼¯¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+OperatorType Precede(OperatorType o1, OperatorType o2);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(04)ÅжÏÕ»ÖвÙ×÷·ûo1Óë±í´ïʽÖеIJÙ×÷·ûo2µÄÓÅÏȼ¶¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+OperandType Operate(OperandType a, OperatorType theta, OperandType b);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(05)¼ÆËã±í´ïʽµÄÖµ¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi-main.c b/▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi-main.c
new file mode 100644
index 0000000..5374d42
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi-main.c	
@@ -0,0 +1,27 @@
+/**********************************
+ *                                *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\06 Hanoi *
+ *                                *
+ * ÄÚ  ÈÝ: ººÅµËþÏà¹Øº¯Êý²âÊÔ     *
+ *                               *
+ **********************************/
+
+#include "Hanoi.c"						//**03 Õ»ºÍ¶ÓÁÐ**//	
+			
+int main(int argc, char **argv)
+{
+	int n;
+	char x = 'x';
+	char y = 'y';
+	char z = 'z';
+	
+	n = 3;								//Ϊ¿ØÖÆʱ¼ä£¬n²»Òª³¬¹ý10 
+	
+	printf("×÷ΪʾÀý£¬¼ÙÉèÔ²Å̸öÊýΪ %d £¬²Ù×÷²½ÖèÈçÏÂ...\n", n);
+
+	hanoi(n,x,y,z);
+	
+	printf("\n");
+	
+	return 0;
+}
diff --git a/▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.c b/▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.c
new file mode 100644
index 0000000..cdb8b1d
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.c	
@@ -0,0 +1,37 @@
+/**********************************
+ *                                *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\06 Hanoi *
+ *                                *
+ * ÎļþÃû: Hanoi.c                *
+ *                                *
+ * Ëã  ·¨: 3.5                    * 
+ *                                *
+ **********************************/
+
+#ifndef HANOI_C
+#define HANOI_C
+
+#include "Hanoi.h"						//**03 Õ»ºÍ¶ÓÁÐ**//
+
+/*¨T¨T¨T¨T¨[
+¨U Ëã·¨3.5¨U 
+¨^¨T¨T¨T¨T*/
+void hanoi(int n, char x, char y, char z)
+{
+	if(n==1)							//ÓûÒƶ¯n¸öÔ²ÅÌ£¬ÐèÏÈÒƶ¯ÆäÉϵÄn-1¸öÔ²ÅÌ 
+		move(x, 1, z);					//½«±àºÅΪ1µÄÔ²ÅÌ´ÓxÒƵ½z 
+	else
+	{
+		hanoi(n-1, x, z, y);			//½«xÉϱàºÅΪ1ÖÁn-1µÄÔ²ÅÌÒƵ½y£¬z×÷¸¨ÖúËþ 
+		move(x, n, z);					//½«±àºÅΪnµÄÔ²ÅÌ´ÓxÒƵ½z 
+		hanoi(n-1, y, x, z);			//½«yÉϱàºÅΪ1ÖÁn-1µÄÔ²ÅÌÒƶ¯µ½z£¬x×÷¸¨ÖúËþ 
+	}	
+} 
+
+void move(char x, int n, char z)
+{
+	gStep++;							//stepΪȫ¾Ö±äÁ¿£¬ÔÚmainº¯ÊýÖ®ÍⶨÒå 
+	printf("µÚ%2d²½£º½«µÚ %d ¸öÔ²ÅÌ´Ó %c ÒƵ½ %c \n", gStep, n, x, z); 
+} 
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.h b/▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.h
new file mode 100644
index 0000000..d11e8e6
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/06 Hanoi/Hanoi.h	
@@ -0,0 +1,30 @@
+/**********************************
+ *                                *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\06 Hanoi *
+ *                                *
+ * ÎļþÃû: Hanoi.h                *
+ *                                *
+ * ÄÚ  ÈÝ: ººÅµËþÏà¹Ø²Ù×÷ÁÐ±í     *
+ *                                *
+ **********************************/
+
+#ifndef HANOI_H
+#define HANOI_H
+
+#include <stdio.h> 
+
+/* È«¾Ö±äÁ¿ */ 
+int gStep;								//ͳ¼ÆÒƶ¯²½Êý 
+
+/* ººÅµËþº¯ÊýÁбí */
+void hanoi(int n, char x, char y, char z); 
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(1)Ëã·¨3.5£ºººÅµËþÇó½â¡£ÒÔyΪ¸¨Öú£¬½«xÉÏÇ°n¸öÔ²ÅÌÒƶ¯µ½z¡£©§             
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void move(char x, int n, char z);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(2)½«µÚn¸öÔ²ÅÌ´ÓxÒƵ½z¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue-main.c b/▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue-main.c
new file mode 100644
index 0000000..6734b5e
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue-main.c	
@@ -0,0 +1,109 @@
+/**************************************
+ *                                    *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\07 LinkQueue *
+ *                                    *
+ * ÄÚ  ÈÝ: Á´¶ÓÏà¹Øº¯Êý²âÊÔ           *
+ *                                    *
+ *************************************/
+
+#include <stdio.h>
+#include "LinkQueue.c" 		//**03 Õ»ºÍ¶ÓÁÐ**//
+	
+void PrintElem(QElemType_L e);						//²âÊÔº¯Êý£¬´òÓ¡ÕûÐÍ 
+	
+int main(int argc, char **argv)
+{
+	LinkQueue Q;
+	int i;
+	QElemType_L e;
+	
+	printf("¨‹1\n¡øº¯Êý InitQueue_L ²âÊÔ...\n");	//1.º¯ÊýInitQueue_L²âÊÔ
+	{
+		printf("³õʼ»¯Á´¶Ó Q ...\n");					 
+		InitQueue_L(&Q);
+		printf("\n");
+	} 
+	PressEnter;
+	
+	printf("¨‹4\n¡øº¯Êý QueueEmpty_L ²âÊÔ...\n");	//4.º¯ÊýQueueEmpty_L²âÊÔ
+	{
+		QueueEmpty_L(Q) ? printf(" Q Ϊ¿Õ£¡£¡\n") : printf(" Q ²»Îª¿Õ£¡\n");
+		printf("\n");
+	} 
+	PressEnter;
+	
+	printf("¨‹7\n¡øº¯Êý EnQueue_L ²âÊÔ...\n");		//7.º¯ÊýEnQueue_L²âÊÔ
+	{
+		for(i=1; i<=6; i++)									
+		{
+			printf("ÔªËØ \"%2d\" Èë¶Ó£¬", 2*i);
+			EnQueue_L(&Q, 2*i);
+			printf("£¨ÀÛ¼ÆµÚ %d ¸öÔªËØ£©...\n", QueueLength_L(Q));
+		}
+		printf("\n");
+	} 
+	PressEnter;
+	
+	printf("¨‹9\n¡øº¯Êý QueueTraverse_L ²âÊÔ...\n");//9.º¯ÊýQueueTraverse_L²âÊÔ
+	{
+		printf(" Q ÖеÄÔªËØΪ£ºQ = ");						 
+		QueueTraverse_L(Q, PrintElem);
+		printf("\n\n");
+	} 
+	PressEnter;
+	
+	printf("¨‹8\n¡øº¯Êý DeQueue_L ²âÊÔ...\n");		//8.º¯ÊýDeQueue_L²âÊÔ
+	{
+		DeQueue_L(&Q, &e);
+		printf("¶ÓÍ·ÔªËØ \"%d\" ³ö¶Ó...\n", e);
+		printf(" Q ÖеÄÔªËØΪ£ºQ = ");						 
+		QueueTraverse_L(Q, PrintElem);
+		printf("\n\n");
+	} 
+	PressEnter;
+	
+	printf("¨‹5\n¡øº¯Êý QueueLength_L ²âÊÔ...\n");	//5.º¯ÊýQueueLength_L²âÊÔ
+	{
+		i = QueueLength_L(Q);
+		printf(" Q µÄ³¤¶ÈΪ %d \n", i);
+		printf("\n");
+	} 
+	PressEnter;
+	
+	printf("¨‹6\n¡øº¯Êý GetHead_L ²âÊÔ...\n");		//6.º¯ÊýGetHead_L²âÊÔ
+	{
+		GetHead_L(Q, &e);
+		printf("¶ÓÍ·ÔªËصÄֵΪ \"%d\" \n", e);
+		printf("\n");
+	} 
+	PressEnter;
+	
+	printf("¨‹3\n¡øº¯Êý ClearQueue_L ²âÊÔ...\n");	//3.º¯ÊýClearQueue_L²âÊÔ
+	{
+		printf("Çå¿Õ Q Ç°£º");
+		QueueEmpty_L(Q) ? printf(" Q Ϊ¿Õ£¡£¡\n") : printf(" Q ²»Îª¿Õ£¡\n");
+		ClearQueue_L(&Q);
+		printf("Çå¿Õ Q ºó£º");
+		QueueEmpty_L(Q) ? printf(" Q Ϊ¿Õ£¡£¡\n") : printf(" Q ²»Îª¿Õ£¡\n");
+		printf("\n");
+	} 
+	PressEnter;
+	
+	printf("¨‹2\n¡øº¯Êý DestroyQueue_L ²âÊÔ...\n");	//2.º¯ÊýDestroyQueue_L²âÊÔ
+	{
+		printf("Ïú»Ù Q Ç°£º");
+		Q.front!=NULL && Q.rear!=NULL ? printf(" Q ´æÔÚ£¡\n") : printf(" Q ²»´æÔÚ£¡£¡\n");
+		DestroyQueue_L(&Q);
+		printf("Ïú»Ù Q ºó£º");
+		Q.front!=NULL && Q.rear!=NULL ? printf(" Q ´æÔÚ£¡\n") : printf(" Q ²»´æÔÚ£¡£¡\n");
+		printf("\n");
+	} 
+	PressEnter;
+		
+	return 0;
+}
+
+void PrintElem(QElemType_L e)
+{
+	printf("%d ", e);
+}
diff --git a/▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue.c b/▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue.c
new file mode 100644
index 0000000..bbb390e
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue.c	
@@ -0,0 +1,133 @@
+/**************************************
+ *                                    *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\07 LinkQueue *
+ *                                    *
+ * ÎļþÃû: LinkQueue.c                *
+ *                                    *
+ *************************************/
+
+#ifndef LINKQUEUE_C
+#define LINKQUEUE_C
+
+#include "LinkQueue.h" 					//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+	
+Status InitQueue_L(LinkQueue *Q)
+{
+	(*Q).front = (*Q).rear = (QueuePtr)malloc(sizeof(QNode));
+	if(!(*Q).front)
+		exit(OVERFLOW);
+
+	(*Q).front->next = NULL;
+
+	return OK;
+}
+
+void ClearQueue_L(LinkQueue *Q)
+{
+	(*Q).rear = (*Q).front->next;
+	
+	while((*Q).rear)
+	{
+		(*Q).front->next = (*Q).rear->next;		
+		free((*Q).rear);		
+		(*Q).rear = (*Q).front->next;
+	}
+	
+	(*Q).rear = (*Q).front;
+}
+
+void DestroyQueue_L(LinkQueue *Q)
+{
+	while((*Q).front)
+	{
+		(*Q).rear = (*Q).front->next;
+		free((*Q).front);
+		(*Q).front = (*Q).rear;	
+	}
+}
+
+Status QueueEmpty_L(LinkQueue Q)
+{
+	if(Q.front==Q.rear)
+		return TRUE;
+	else
+		return FALSE;
+} 
+
+int QueueLength_L(LinkQueue Q)
+{
+	int count = 0;
+	QueuePtr p = Q.front;
+	
+	while(p!=Q.rear)
+	{
+		count++;
+		p = p->next;
+	}
+	
+	return count;
+} 
+
+Status GetHead_L(LinkQueue Q, QElemType_L *e)
+{
+	QueuePtr p;
+	
+	if(Q.front==Q.rear)
+		return ERROR;
+		
+	p = Q.front->next;
+	*e = p->data;
+	
+	return OK;
+} 
+
+Status EnQueue_L(LinkQueue *Q, QElemType_L e)
+{
+	QueuePtr p;
+	
+	p = (QueuePtr)malloc(sizeof(QNode));
+	if(!p)
+		exit(OVERFLOW);
+
+	p->data = e;
+	p->next = NULL;
+	
+	(*Q).rear->next = p;
+	(*Q).rear=p;
+
+	return OK;
+} 
+
+Status DeQueue_L(LinkQueue *Q, QElemType_L *e)
+{
+	QueuePtr p;
+	
+	if((*Q).front==(*Q).rear)
+		return ERROR;
+		
+	p = (*Q).front->next;
+	*e = p->data;
+	
+	(*Q).front->next = p->next;
+	if((*Q).rear==p)
+		(*Q).rear = (*Q).front;
+		
+	free(p);
+	
+	return OK;
+} 
+
+void QueueTraverse_L(LinkQueue Q, void (Visit)(QElemType_L))
+{
+	QueuePtr p;
+	
+	p = Q.front->next;
+	
+	while(p)
+	{
+		Visit(p->data);
+		p = p->next;
+	}
+} 
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue.h b/▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue.h
new file mode 100644
index 0000000..2447094
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/07 LinkQueue/LinkQueue.h	
@@ -0,0 +1,82 @@
+/**************************************
+ *                                    *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\07 LinkQueue *
+ *                                    *
+ * ÎļþÃû: LinkQueue.h                *
+ *                                    *
+ * ÄÚ  ÈÝ: Á´¶ÓÏà¹Ø²Ù×÷ÁÐ±í           *
+ *                                    *
+ *************************************/
+
+#ifndef LINKQUEUE_H
+#define LINKQUEUE_H
+
+#include <stdio.h>
+#include <stdlib.h>						//Ìṩmalloc¡¢realloc¡¢free¡¢exitÔ­ÐÍ
+#include "../../¡ø01 Ð÷ÂÛ/Status.h"		//**¡ø01 Ð÷ÂÛ**//
+
+/* Á´¶ÓÀàÐͶ¨Òå */
+/* ÔÚÄ£ÄâÒøÐÐÅŶӡ¢¶þ²æÊ÷Èý²æÁ´±í´æ´¢µÄËã·¨ÖУ¬QElemType_LÐèÖØж¨Òå*/
+#if !defined BANKQUEUING_H     &&  \
+    !defined TRI_BINARYTREE_H
+typedef int QElemType_L;
+#endif
+typedef struct QNode				 
+{
+	QElemType_L data;
+	struct QNode *next;
+}QNode;
+typedef QNode* QueuePtr;
+typedef struct
+{
+	QueuePtr front;					//Í·Ö¸Õë 
+	QueuePtr rear;					//βָÕë 
+}LinkQueue;							//¶ÓÁеÄÁ´Ê½´æ´¢±íʾ 
+
+/* Á´Õ»º¯ÊýÁбí */
+Status InitQueue_L(LinkQueue *Q);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(01)³õʼ»¯Á´¶ÓQ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void ClearQueue_L(LinkQueue *Q);
+/*©¥©¥©¥©¥©¥©¥©·
+©§(02)ÖÿÕQ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥*/
+
+void DestroyQueue_L(LinkQueue *Q);
+/*©¥©¥©¥©¥©¥©¥©·
+©§(03)Ïú»ÙQ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥*/
+
+Status QueueEmpty_L(LinkQueue Q);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(04)ÅжÏQÊÇ·ñΪ¿Õ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+int QueueLength_L(LinkQueue Q);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(05)·µ»ØQÔªËظöÊý¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status GetHead_L(LinkQueue Q, QElemType_L *e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(06)ÓÃe»ñÈ¡¶ÓÍ·ÔªËØ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status EnQueue_L(LinkQueue *Q, QElemType_L e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(07)ÔªËØeÈë¶Ó¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status DeQueue_L(LinkQueue *Q, QElemType_L *e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(08)ÔªËØe³ö¶Ó¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void QueueTraverse_L(LinkQueue Q, void(Visit)(QElemType_L));
+/*©¥©¥©¥©¥©¥©¥©¥©·
+©§(09)·ÃÎʶÓÁС£©§
+©»©¥©¥©¥©¥©¥©¥©¥*/
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue-main.c b/▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue-main.c
new file mode 100644
index 0000000..0dc52ab
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue-main.c	
@@ -0,0 +1,109 @@
+/****************************************
+ *                                      *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\08 CylSeqQueue *
+ *                                      *
+ * ÄÚ  ÈÝ: Ñ­»·¶ÓÁÐÏà¹Øº¯Êý²âÊÔ         *
+ *                                      *
+ ****************************************/
+
+#include <stdio.h>
+#include "CylSeqQueue.c"	//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+	
+void PrintElem(QElemType_CSq e);						//²âÊÔº¯Êý£¬´òÓ¡ÕûÐÍ 
+	
+int main(int argc, char **argv)
+{
+	CSqQueue Q;
+	int i;
+	QElemType_CSq e;
+	
+	printf("¨‹1\n¡øº¯Êý InitQueue_CSq ²âÊÔ...\n");		//1.º¯ÊýInitQueue_CSq²âÊÔ
+	{
+		printf("³õʼ»¯Ñ­»·Ë³Ðò¶ÓÁÐ Q ...\n");					 
+		InitQueue_CSq(&Q);
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹4\n¡øº¯Êý QueueEmpty_CSq ²âÊÔ...\n");		//4.º¯ÊýQueueEmpty_CSq²âÊÔ
+	{
+		QueueEmpty_CSq(Q) ? printf(" Q Ϊ¿Õ£¡£¡\n") : printf(" Q ²»Îª¿Õ£¡\n");
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹7\n¡øº¯Êý EnQueue_CSq ²âÊÔ...\n");		//7.º¯ÊýEnQueue_CSq²âÊÔ
+	{
+		for(i=1; i<=6; i++)									
+		{
+			printf("ÔªËØ \"%2d\" Èë¶ÓQ£¬", 2*i);
+			EnQueue_CSq(&Q, 2*i);
+			printf("£¨ÀÛ¼ÆµÚ %d ¸öÔªËØ£©...\n", QueueLength_CSq(Q));
+		}
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹9\n¡øº¯Êý QueueTraverse_CSq ²âÊÔ...\n");	//9.º¯ÊýQueueTraverse_CSq²âÊÔ
+	{
+		printf(" Q ÖеÄÔªËØΪ£ºQ = ");						 
+		QueueTraverse_CSq(Q, PrintElem);
+		printf("\n\n");
+	}
+	PressEnter;
+	
+	printf("¨‹8\n¡øº¯Êý DeQueue_CSq ²âÊÔ...\n");		//8.º¯ÊýDeQueue_CSq²âÊÔ
+	{
+		DeQueue_CSq(&Q, &e);
+		printf("¶ÓÍ·ÔªËØ \"%d\" ³ö¶Ó...\n", e);
+		printf(" Q ÖеÄÔªËØΪ£ºQ = ");						 
+		QueueTraverse_CSq(Q, PrintElem);
+		printf("\n\n");
+	}
+	PressEnter;
+	
+	printf("¨‹5\n¡øº¯Êý QueueLength_CSq ²âÊÔ...\n");	//5.º¯ÊýQueueLength_CSq²âÊÔ
+	{
+		i = QueueLength_CSq(Q);
+		printf(" Q µÄ³¤¶ÈΪ %d \n", i);
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹6\n¡øº¯Êý GetHead_CSq ²âÊÔ...\n");		//6.º¯ÊýGetHead_CSq²âÊÔ
+	{
+		GetHead_CSq(Q, &e);
+		printf("¶ÓÍ·ÔªËصÄֵΪ \"%d\" \n", e);
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹3\n¡øº¯Êý ClearQueue_CSq ²âÊÔ...\n");		//3.º¯ÊýClearQueue_CSq²âÊÔ
+	{
+		printf("Çå¿Õ Q Ç°£º");
+		QueueEmpty_CSq(Q) ? printf(" Q Ϊ¿Õ£¡£¡\n") : printf(" Q ²»Îª¿Õ£¡\n");
+		ClearQueue_CSq(&Q);
+		printf("Çå¿Õ Q ºó£º");
+		QueueEmpty_CSq(Q) ? printf(" Q Ϊ¿Õ£¡£¡\n") : printf(" Q ²»Îª¿Õ£¡\n");
+		printf("\n");
+	}
+	PressEnter;
+	
+	printf("¨‹2\n¡øº¯Êý DestroyQueue_CSq ²âÊÔ...\n");	//2.º¯ÊýDestroyQueue_CSq²âÊÔ
+	{
+		printf("Ïú»Ù Q Ç°£º");
+		Q.base!=NULL ? printf(" Q ´æÔÚ£¡\n") : printf(" Q ²»´æÔÚ£¡£¡\n");
+		DestroyQueue_CSq(&Q);
+		printf("Ïú»Ù Q ºó£º");
+		Q.base!=NULL ? printf(" Q ´æÔÚ£¡\n") : printf(" Q ²»´æÔÚ£¡£¡\n");
+		printf("\n");
+	}
+	PressEnter;
+		
+	return 0;
+}
+
+void PrintElem(QElemType_CSq e)
+{
+	printf("%d ", e);
+}
diff --git a/▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.c b/▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.c
new file mode 100644
index 0000000..766c781
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.c	
@@ -0,0 +1,95 @@
+/****************************************
+ *                                      *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\08 CylSeqQueue *
+ *                                      *
+ * ÎļþÃû: CylSeqQueue.c                *
+ *                                      *
+ ****************************************/
+
+#ifndef CYLSEQQUEUE_C
+#define CYLSEQQUEUE_C
+
+#include "CylSeqQueue.h" 				//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+Status InitQueue_CSq(CSqQueue *Q)
+{
+	(*Q).base = (QElemType_CSq *)malloc(MAXQSIZE*sizeof(QElemType_CSq));
+	if(!(*Q).base)
+		exit(OVERFLOW);
+
+	(*Q).front = (*Q).rear = 0;
+
+	return OK;
+}
+
+void ClearQueue_CSq(CSqQueue *Q)
+{
+	(*Q).front = (*Q).rear = 0;
+}
+
+void DestroyQueue_CSq(CSqQueue *Q)
+{
+	if((*Q).base)
+		free((*Q).base);
+		
+	(*Q).base = NULL;
+	(*Q).front = (*Q).rear = 0;
+}
+
+Status QueueEmpty_CSq(CSqQueue Q)
+{
+	if(Q.front==Q.rear) 						//¶ÓÁпյıêÖ¾
+		return TRUE;
+	else
+		return FALSE;
+}
+
+int QueueLength_CSq(CSqQueue Q)
+{
+	return (Q.rear-Q.front+MAXQSIZE) % MAXQSIZE;//¶ÓÁг¤¶È 
+}
+
+Status GetHead_CSq(CSqQueue Q, QElemType_CSq *e)
+{
+	if(Q.front==Q.rear)							//¶ÓÁпÕ
+		return ERROR;
+		
+	*e = Q.base[Q.front];
+	
+	return OK;
+}
+
+Status EnQueue_CSq(CSqQueue *Q, QElemType_CSq e)
+{
+	if(((*Q).rear+1)%MAXQSIZE == (*Q).front)	//¶ÓÁÐÂú
+		return ERROR;
+		
+	(*Q).base[(*Q).rear] = e;
+	(*Q).rear = ((*Q).rear+1)%MAXQSIZE;
+	
+	return OK;
+}
+
+Status DeQueue_CSq(CSqQueue *Q, QElemType_CSq *e)
+{
+	if((*Q).front==(*Q).rear)					//¶ÓÁпÕ
+		return ERROR;
+		
+	*e = (*Q).base[(*Q).front];
+	(*Q).front = ((*Q).front+1)%MAXQSIZE;
+	
+	return OK;
+}
+
+void QueueTraverse_CSq(CSqQueue Q, void(Visit)(QElemType_CSq))
+{
+	int i = Q.front;
+	
+	while(i!=Q.rear)
+	{
+		Visit(Q.base[i]);
+		i = (i+1)%MAXQSIZE;
+	}
+}
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.h b/▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.h
new file mode 100644
index 0000000..e436ff0
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/08 CylSeqQueue/CylSeqQueue.h	
@@ -0,0 +1,76 @@
+/****************************************
+ *                                      *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\08 CylSeqQueue *
+ *                                      *
+ * ÎļþÃû: CylSeqQueue.h                *
+ *                                      *
+ * ÄÚ  ÈÝ: Ñ­»·¶ÓÁÐÏà¹Ø²Ù×÷ÁÐ±í         *
+ *                                      *
+ ****************************************/
+
+#ifndef CYLSEQQUEUE_H
+#define CYLSEQQUEUE_H
+
+#include <stdio.h>
+#include <stdlib.h>						//Ìṩmalloc¡¢realloc¡¢free¡¢exitÔ­ÐÍ
+#include "../../¡ø01 Ð÷ÂÛ/Status.h"		//**¡ø01 Ð÷ÂÛ**//
+
+/* ºê¶¨Òå */
+#define MAXQSIZE 1000					//×î´ó¶ÓÁ㤶È
+
+/* Ñ­»·¶ÓÁÐÀàÐͶ¨Òå */
+typedef int QElemType_CSq;
+typedef struct							//¶ÓÁеÄ˳Ðò´æ´¢½á¹¹
+{
+	QElemType_CSq *base;				//³õʼ»¯µÄ¶¯Ì¬·ÖÅä´æ´¢¿Õ¼ä 
+	int front;							//Í·Ö¸Õ룬Èô¶ÓÁв»¿Õ£¬Ö¸Ïò¶ÓÍ·ÔªËØ 
+	int rear;							//βָÕ룬Èô¶ÓÁв»¿Õ£¬Ö¸Ïò¶ÓÁÐβԪËصÄÏÂÒ»¸öλÖà 
+}CSqQueue;
+
+/* Ñ­»·¶ÓÁк¯ÊýÁбí */
+Status InitQueue_CSq(CSqQueue *Q);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(01)³õʼ»¯Ñ­»·¶ÓÁÐQ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void ClearQueue_CSq(CSqQueue *Q);
+/*©¥©¥©¥©¥©¥©¥©·
+©§(02)ÖÿÕQ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥*/
+
+void DestroyQueue_CSq(CSqQueue *Q);
+/*©¥©¥©¥©¥©¥©¥©·
+©§(03)Ïú»ÙQ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥*/
+
+Status QueueEmpty_CSq(CSqQueue Q);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(04)ÅжÏQÊÇ·ñΪ¿Õ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+int QueueLength_CSq(CSqQueue Q);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(05)·µ»ØQÔªËظöÊý¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status GetHead_CSq(CSqQueue Q, QElemType_CSq *e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(06)ÓÃe»ñÈ¡¶ÓÍ·ÔªËØ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status EnQueue_CSq(CSqQueue *Q, QElemType_CSq e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(07)ÔªËØeÈë¶Ó¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status DeQueue_CSq(CSqQueue *Q, QElemType_CSq *e);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(08)ÔªËØe³ö¶Ó¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void QueueTraverse_CSq(CSqQueue Q, void(Visit)(QElemType_CSq));
+/*©¥©¥©¥©¥©¥©¥©¥©·
+©§(09)·ÃÎʶÓÁС£©§
+©»©¥©¥©¥©¥©¥©¥©¥*/
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing-main.c b/▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing-main.c
new file mode 100644
index 0000000..63fe55a
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing-main.c	
@@ -0,0 +1,19 @@
+/****************************************
+ *                                      *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\09 BankQueuing *
+ *                                      *
+ * ÄÚ  ÈÝ: Ä£ÄâÒøÐÐÅŶÓÏà¹Øº¯Êý²âÊÔ     *
+ *                                      *
+ ****************************************/
+
+#include "BankQueuing.c"			//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+int main(int argc, char **argv)
+{
+	getchar();
+	Bank_Simulation_1();			//Ëã·¨3.6	
+
+//	Bank_Simulation_2();			//Ëã·¨3.7£¬ÁíÒ»ÖÖËã·¨ 
+	
+	return 0;
+}
diff --git a/▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing.c b/▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing.c
new file mode 100644
index 0000000..0bdcd46
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing.c	
@@ -0,0 +1,260 @@
+/****************************************
+ *                                      *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\09 BankQueuing *
+ *                                      *
+ * ÎļþÃû: BankQueuing.c                *
+ *                                      *
+ * Ëã  ·¨: 3.6¡¢3.7                     * 
+ *                                      *
+ ****************************************/
+
+#ifndef BANKQUEUING_C
+#define BANKQUEUING_C
+
+#include "BankQueuing.h" 				//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+/*¨T¨T¨T¨T¨[
+¨U Ëã·¨3.6¨U 
+¨^¨T¨T¨T¨T*/
+void Bank_Simulation_1()				//ÒøÐÐÒµÎñÄ£Ä⣬ͳ¼ÆÒ»ÌìÄÚ¿Í»§ÔÚÒøÐжºÁôµÄƽ¾ùʱ¼ä 
+{
+	char eventType;
+	
+	OpenForDay();						//³õʼ»¯
+
+	while(MoreEvent())
+	{
+		EventDrived(&eventType);		//ʼþÇý¶¯
+		
+		switch(eventType)
+		{
+			case 'A': 
+				CustomerArrived();
+				break;
+			case 'D': 
+				CustomerDeparture();
+				break;
+			default : 
+				Invalid();
+		}
+	}
+	
+	CloseForDay();
+}
+ 
+void OpenForDay() 
+{	
+	int i;
+	
+	gTotalTime = 0;					//³õʼ»¯ÀÛ¼Æʱ¼äºÍ¿Í»§ÊýΪ0 
+	gCustomerNum = 0;
+			
+	InitList_L(&gEv);				//³õʼ»¯Ê¼þÁ´±íΪ¿Õ±í
+
+	gEn.OccurTime = 0;				//É趨µÚÒ»¸ö¿Í»§µ½´ïʼþ 
+	gEn.NType = Arrive;
+	 
+	OrderInsert(gEv, gEn, cmp);		//²åÈëʼþ±í
+	
+	for(i=1; i<=4; ++i) 
+		InitQueue_L(&gQ[i]);		//ÖÿնÓÁÐ
+
+	Show();
+}
+
+Status MoreEvent()
+{
+	if(!ListEmpty_L(gEv))
+		return TRUE;
+	else
+		return FALSE;
+}
+
+void EventDrived(char *event)
+{
+	ListDelete_L(gEv, 1, &gEn);
+	
+	if(gEn.NType==Arrive)
+		*event = 'A';
+	else
+		*event = 'D';
+}
+
+void CustomerArrived()							//´¦Àí¿Í»§µ½´ïʼþ£¬gEn.NType=0 
+{	
+	int durtime, intertime; 
+	int cur_LeftTime, suc_ArrivalTime;
+	int i;
+	
+	++gCustomerNum;								//×Ü¿Í»§ÊýÔöÒ» 
+	
+	Random(&durtime, &intertime);				//Éú³Éµ±Ç°¿Í»§°ìÀíÒµÎñÐèÒªµÄʱ¼äºÍÏÂÒ»¸ö¿Í»§´ïµ½Ê±¼ä¼ä¸ô
+	cur_LeftTime    = gEn.OccurTime + durtime;	//µ±Ç°¿Í»§µÄÀ뿪ʱ¼ä 
+	suc_ArrivalTime = gEn.OccurTime + intertime;//ÏÂÒ»¸ö¿Í»§µ½´ïʱ¼ä 
+			
+	gCustomerRcd.ArrivedTime = gEn.OccurTime;	//¼Ç¼µ±Ç°¿Í»§ÐÅÏ¢ 
+	gCustomerRcd.Duration    = durtime;
+	gCustomerRcd.Count       = gCustomerNum;
+
+	i = Minimum(gQ);							//Ç󳤶È×î¶Ì¶ÓÁÐ
+	EnQueue_L(&gQ[i], gCustomerRcd); 			//µ±Ç°¿Í»§½øÈë×î¶Ì¶ÓÁÐ
+	Show();
+	
+	if(suc_ArrivalTime<gCloseTime)				//ÒøÐÐÉÐδ¹ØÃÅ£¬½«ÏÂÒ»¿Í»§µ½´ïʼþ²åÈëʼþ±í
+	{
+		gEn.OccurTime = suc_ArrivalTime;		//gEnµÄ²ÎÊýÒѾ­¸Ä±ä 
+		gEn.NType = Arrive;
+		OrderInsert(gEv, gEn, cmp);
+	}
+
+	if(QueueLength_L(gQ[i])==1)					//É趨µÚi¶ÓÁеĶÓÍ·¿Í»§µÄÀ뿪ʼþ²¢²åÈëʼþ±í
+	{
+		gEn.OccurTime = cur_LeftTime;
+		gEn.NType = i;		
+		OrderInsert(gEv, gEn, cmp);					
+	}
+}
+
+void CustomerDeparture()						//´¦Àí¿Í»§À뿪ʼþ,gEn.NType>0
+{
+	int i = gEn.NType;
+	
+	DeQueue_L(&gQ[i], &gCustomerRcd);			//ɾ³ýµÚi¶ÓÁеÄÅÅÍ·¿Í»§
+	Show();
+		
+	gTotalTime += gEn.OccurTime - gCustomerRcd.ArrivedTime;	//Àۼƿͻ§¶ºÁôʱ¼ä
+	
+	if(!QueueEmpty_L(gQ[i]))					//É趨µÚi¶ÓÁеĵÚÒ»¸öÀ뿪ʼþ²¢²åÈëʼþ±í 
+	{
+		GetHead_L(gQ[i], &gCustomerRcd);
+		gEn.OccurTime += gCustomerRcd.Duration;
+		gEn.NType = i;
+		OrderInsert(gEv,gEn,cmp);
+	} 
+}
+
+void Invalid()
+{
+	printf("ÔËÐдíÎó£¡");
+		exit(OVERFLOW);
+}
+
+void CloseForDay()
+{
+	printf("µ±Ìì×ܹ²ÓÐ%d¸ö¿Í»§£¬Æ½¾ù¶ºÁôʱ¼äΪ%d·ÖÖÓ¡£\n",gCustomerNum,gTotalTime/gCustomerNum);
+}
+
+int cmp(Event a, Event b)					//±È½ÏÁ½Ê¼þ·¢Éú´ÎÐò 
+{
+	if(a.OccurTime<b.OccurTime)				//aÍíÓÚb·¢Éú 
+		return -1;
+	if(a.OccurTime==b.OccurTime)			//a¡¢bͬʱ·¢Éú 
+		return 0;
+	if(a.OccurTime>b.OccurTime)				//aÔçÓÚb·¢Éú 
+		return 1;
+}
+
+void Random(int *durtime, int *intertime)
+{
+	srand((unsigned)time(NULL));
+	*durtime = rand()%DurationTime+1;		//°ìÒµÎñʱ¼ä³ÖÐø1µ½20·ÖÖÓ
+	*intertime = rand()%IntervalTime+1; 	//ÏÂÒ»¸ö¹Ë¿ÍÀ´µÄʱ¼äΪ¼ä¸ô1µ½10·ÖÖÓ 
+}
+
+Status OrderInsert(EventList gEv, Event gEn, int (cmp)(Event,Event))
+{
+	int i;
+	EventList p, pre, s;
+	
+	pre = gEv;
+	p = gEv->next;							//pÖ¸ÏòµÚÒ»¸öʼþ 
+	
+	while(p && cmp(gEn, p->data)==1)		//²éÕÒgEnÔÚʼþ±íÖÐÓ¦¸Ã²åÈëµÄλÖÃ
+	{
+		pre = p;
+		p = p->next;
+	}
+	
+	s = (LinkList)malloc(sizeof(LNode));
+	if(!s)
+		exit(OVERFLOW);
+	
+	s->data = gEn;							//½«gEn²åÈëʼþ±í
+	s->next = pre->next;
+	pre->next = s;
+	
+	return OK;
+}
+
+int Minimum()
+{
+	int i1 = QueueLength_L(gQ[1]);
+	int i2 = QueueLength_L(gQ[2]);
+	int i3 = QueueLength_L(gQ[3]);
+	int i4 = QueueLength_L(gQ[4]);
+	
+	if(i1<=i2 && i1<=i3 && i1<=i4)
+		return 1;
+	if(i2<i1  && i2<=i3 && i2<=i4)
+		return 2;
+	if(i3<i1  && i3<i2  && i3<=i4)
+		return 3;
+	if(i4<i1  && i4<i2  && i4<i3 )
+		return 4;
+}
+
+void Show()
+{
+	int i;
+	QueuePtr p;								//¼Ç¼µ½À´µÄ¿Í»§Êǵڼ¸¸ö 
+	
+	system("cls");
+	
+	for(i=1; i<=4; i++)
+	{
+		for(p=gQ[i].front; p; p=p->next)
+		{
+			if(p==gQ[i].front)
+			{
+				if(i==1)
+					printf("¹ñ̨¢Ù¡ñ");
+				if(i==2)
+					printf("¹ñ̨¢Ú¡ñ");
+				if(i==3)
+					printf("¹ñ̨¢Û¡ñ");
+				if(i==4)
+					printf("¹ñ̨¢Ü¡ñ");
+			}
+			else
+				printf("£¨%03d£©",p->data.Count);			
+
+	
+			if(p==gQ[i].rear)
+				printf("\n"); 
+		}
+	}
+	
+	Wait(SleepTime);
+}
+
+/*¨T¨T¨T¨T¨[
+¨U Ëã·¨3.7¨U 
+¨^¨T¨T¨T¨T*/
+void Bank_Simulation_2()
+{
+	OpenForDay();							//³õʼ»¯
+	
+	while(!ListEmpty_L(gEv))
+	{
+		ListDelete_L(gEv, 1, &gEn);
+		
+		if(gEn.NType==Arrive)
+			CustomerArrived();				//´¦Àí¿Í»§µ½´ïʼþ 
+		else
+			CustomerDeparture();			//´¦Àí¿Í»§À뿪ʼþ 
+	}
+	
+	printf("µ±Ìì×ܹ²ÓÐ%d¸ö¿Í»§£¬Æ½¾ù¶ºÁôʱ¼äΪ%d·ÖÖÓ¡£\n",gCustomerNum,gTotalTime/gCustomerNum);//¼ÆËãƽ¾ù¶ºÁôʱ¼ä	
+}
+
+#endif
diff --git a/▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing.h b/▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing.h
new file mode 100644
index 0000000..7e32d8c
--- /dev/null
+++ b/▲课本算法实现/▲03 栈和队列/09 BankQueuing/BankQueuing.h	
@@ -0,0 +1,130 @@
+/****************************************
+ *                                      *
+ * Îļþ¼Ð: ¡ø03 Õ»ºÍ¶ÓÁÐ\09 BankQueuing *
+ *                                      *
+ * ÎļþÃû: BankQueuing.h                *
+ *                                      *
+ * ÄÚ  ÈÝ: Ä£ÄâÒøÐÐÅŶÓÏà¹Ø²Ù×÷ÁÐ±í     *
+ *                                      *
+ ****************************************/
+
+#ifndef BANKQUEUING_H
+#define BANKQUEUING_H
+
+#include <stdio.h>
+#include <stdlib.h>						//Ìṩmalloc¡¢realloc¡¢free¡¢exitÔ­ÐÍ
+#include <time.h>						//ÌṩtimeÔ­ÐÍ
+#include "../../¡ø01 Ð÷ÂÛ/Status.h"		//**¡ø01 Ð÷ÂÛ**//
+
+/* ºê¶¨Òå */
+#define SleepTime 1						//SleepTime´ú±íÐÝÃßʱ¼ä
+#define DurationTime 20					//°ìÀíÒµÎñ³ÖÐøʱ¼ä´Ó1µ½DurationTime·ÖÖÓ²»µÈ 
+#define IntervalTime 10					//ÏÂÒ»¸ö¿Í»§µ½À´Ê±¼ä¼ä¸ôΪ1µ½IntervalTime·ÖÖÓ²»µÈ 
+
+/* ÀàÐͶ¨Òå */
+typedef enum
+{
+	Arrive,Leave_1,Leave_2,Leave_3,Leave_4
+}EventType;								//ʼþÀàÐÍ£¬0´ú±íµ½´ïʼþ£¬1ÖÁ4±íʾËĸö´°¿ÚµÄÀ뿪ʼþ
+typedef struct         					//ʼþÁ´±í                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
+{
+	int OccurTime;						//ʼþ·¢Éúʱ¿Ì
+	EventType NType;					//ʼþÀàÐÍ
+}Event;
+typedef Event LElemType_L;				//ʼþÁ´±íÔªËØ 
+typedef struct LNode
+{
+	LElemType_L data;
+	struct LNode *next;
+}LNode; 
+typedef LNode* LinkList;
+typedef LinkList EventList;											//ʼþÁ´±íÀàÐÍ£¬¶¨ÒåΪÓÐÐòÁ´±í
+#include "../../¡ø02 ÏßÐÔ±í/04 SinglyLinkedList/SinglyLinkedList.c"	//**¡ø02 ÏßÐÔ±í**//
+typedef struct
+{
+	int ArrivedTime;					//¿Í»§µ½´ïʱ¼ä
+	int Duration;						//°ìÀíÊÂÎñËùÐèµÄʱ¼ä
+	int Count;							//´Ë±äÁ¿¼Ç¼À´µ½Ã¿¸ö¶ÓÁеĿͻ§Êǵڼ¸¸ö
+}QElemType_L;							//¶ÓÁеÄÊý¾ÝÔªËØÀàÐÍ 
+#include "../07 LinkQueue/LinkQueue.c"	//**¡ø03 Õ»ºÍ¶ÓÁÐ**//
+
+/* È«¾Ö±äÁ¿ */
+int gTotalTime, gCustomerNum;			//Àۼƿͻ§¶ºÁôʱ¼ä£¬¿Í»§Êý
+int gCloseTime = 480;					//¹ØÃÅʱ¼ä,¼ÙÉèÒøÐÐÿÌìÓªÒµ8Сʱ£¬480·Ö 
+EventList gEv;							//ʼþ±í
+Event gEn;								//ʼþ
+LinkQueue gQ[5];						//4¸ö¿Í»§¶ÓÁÐ,0ºÅµ¥ÔªÆúÓÃ
+QElemType_L gCustomerRcd;				//¿Í»§¼Ç¼ 
+ 
+/* Ä£ÄâÒøÐÐÅŶӺ¯ÊýÁбí */
+void Bank_Simulation_1();
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(01)Ëã·¨3.6£ºÄ£ÄâÒøÐÐÅŶÓʼþ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void OpenForDay();
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(02)ÒøÐпªÃÅ£¬³õʼ»¯¸÷±äÁ¿¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status MoreEvent();
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(03)ÅжÏʼþ±íÊÇ·ñΪ¿Õ¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void EventDrived(char *event);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(04)ʼþÇý¶¯£¬»ñÈ¡µ±Ç°Ê¼þÀàÐÍ¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void CustomerArrived();
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(05)´¦Àí¿Í»§µ½´ïʼþ¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void CustomerDeparture();
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(06)´¦Àí¿Í»§À뿪ʼþ¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void Invalid();
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(07)ʼþÀàÐÍ´íÎ󡣩§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void CloseForDay();
+/*©¥©¥©¥©¥©¥©¥©¥©·
+©§(08)ÒøÐйØÃÅ¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥*/
+
+int cmp(Event a, Event b);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(09)±È½ÏʼþaºÍb·¢ÉúµÄÏȺó´ÎÐò¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void Random(int *durtime, int *intertime);
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(10)Éú³ÉËæ»úÊý£¬°üÀ¨µ±Ç°¿Í·þ°ìÀíÒµÎñËùÐèʱ¼äºÍÏÂÒ»¿Í»§µ½´ï¼ä¸ôµÄʱ¼ä¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+Status OrderInsert(EventList gEv, Event gEn, int(cmp)(Event,Event));
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(11)½«Ê¼þ²åÈëʼþ±íÕýȷλÖᣩ§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+int Minimum();
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(12)Ç󳤶È×î¶Ì¶ÓÁеÄÐòºÅ¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void Show();
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(13)ÏÔʾµ±Ç°¶ÓÁеĿͻ§ÅŶÓÇé¿ö¡£©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+void Bank_Simulation_2();
+/*©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©·
+©§(14)Ëã·¨3.7£ºÄ£ÄâÒøÐÐÅŶÓʼþ¡£ ©§
+©»©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥©¥*/
+
+#endif