commit 22c59de0c3d2521cc7b3d67f4c7b96df31375e2b
Author: callmePicacho <18283847632~>
Date:   Wed May 8 19:49:54 2019 +0800

    Initial commit

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..dfe0770
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..9ad765b
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+# Data-Structres
diff --git a/上课Demo/1.计时实例.c b/上课Demo/1.计时实例.c
new file mode 100644
index 0000000..db21e08
--- /dev/null
+++ b/上课Demo/1.计时实例.c
@@ -0,0 +1,46 @@
+#include<stdio.h>
+#include<time.h>
+#include<math.h>
+clock_t start,end;
+/* clock_t �� clock()�������صı�������*/
+double duration;
+/* ���⺯������ʱ�䣬����Ϊ��λ*/
+#define MAXN 101 /* ����ʽ���������������ʽ����+1*/
+#define MAXK 1e5 /* ���⺯������ظ����ô���*/
+double f1(int n,double a[],double x);
+double f2(int n,double a[],double x);
+void run(double(*f)(int n,double *,double ),double a[],int func_n);
+int main(){
+	int i;
+	double a[MAXN]; /* �洢����ʽ��ϵ�� */
+	a[0]=1;
+	for(i=1;i<MAXN;i++)
+		a[i]=(double)(1.0/i);
+	run(f1,a,1);
+	run(f2,a,2);
+	return 0;
+} 
+double f1(int n,double a[],double x){
+	int i;
+	double p=a[0];
+	for(i=1;i<n;i++)
+		p+=(a[i]*pow(x,i));
+	return p;
+}
+double f2(int n,double a[],double x){
+	int i;
+	double p=a[0];
+	for(i=n;i>0;i--)
+		p=a[i-1]+x*p;
+	return p;
+}
+void run(double(*f)(int n,double *,double ),double a[],int func_n){
+	int i;
+	start = clock();
+	for(i=0;i<MAXK;i++)
+		f(MAXN-1,a,1.1);
+	end = clock();
+	duration = ((double)(end-start))/CLK_TCK;
+	printf("ticks%d=%f\n",func_n,(double)(end-start));
+	printf("duration%d=%6.2e\n",func_n,duration);
+}
diff --git a/上课Demo/1.计时实例.exe b/上课Demo/1.计时实例.exe
new file mode 100644
index 0000000..39019ed
Binary files /dev/null and b/上课Demo/1.计时实例.exe differ
diff --git a/上课Demo/10.堆的操作.cpp b/上课Demo/10.堆的操作.cpp
new file mode 100644
index 0000000..8b07141
--- /dev/null
+++ b/上课Demo/10.堆的操作.cpp
@@ -0,0 +1,150 @@
+#include<stdio.h>
+#include<malloc.h>
+#define MaxData 100000
+#define ERROR -1
+typedef int ElementType;
+typedef struct HeapStruct *MaxHeap;
+struct HeapStruct{
+	ElementType *Elements;   // �洢��Ԫ�ص����� 
+	int Size;      // �ѵĵ�ǰԪ�ظ��� 
+	int Capacity;  // �ѵ�������� 
+};
+
+MaxHeap Create(int MaxSize);  // ���� 
+bool IsFull(MaxHeap H);    // �ж϶��Ƿ���
+bool Insert(MaxHeap H,ElementType item);   // ����Ԫ��
+bool IsEmpty(MaxHeap H);    //  �ж϶��Ƿ�Ϊ��
+ElementType DeleteMax(MaxHeap H);  // ɾ�������ض������Ԫ��
+void LevelOrderTraversal(MaxHeap H);  // ������� 
+
+// ���� 
+MaxHeap Create(int MaxSize){
+	MaxHeap H = (MaxHeap)malloc(sizeof(struct HeapStruct));
+	// Elements[0] ��Ϊ�ڱ�����Ԫ�ش�  Elements[1] ��ʼ��� 
+	H->Elements = (ElementType *)malloc((MaxSize+1) * sizeof(ElementType));
+	H->Size = 0;
+	H->Capacity = MaxSize;
+	// "�ڱ�"���ڶ������п��ܵ�ֵ 
+	H->Elements[0] = MaxData;
+	return H;
+} 
+
+// ���룬����ȫ�����������һ��λ�ò��� 
+bool Insert(MaxHeap H,ElementType item){
+	if(IsFull(H)){
+		printf("���������޷����룡\n");
+		return false;
+	}
+	int i = ++H->Size;  // ָ��������һ��λ�� 
+	for(;H->Elements[i/2] < item;i/=2)    // �����ұ� item ��Ľ�� 
+		H->Elements[i] = H->Elements[i/2];  //  ���¸�ֵ 
+	H->Elements[i] = item;  // �ҵ��ˣ��� item ֵ�Ž�ȥ 
+	return true;
+}
+
+// ɾ�����Ӹ����ɾ�� 
+ElementType DeleteMax(MaxHeap H){
+	int parent,child;
+	ElementType Max,tmp;
+	if(IsEmpty(H)){
+		printf("��Ϊ�գ��޷�ɾ����\n");
+		return ERROR;
+	}
+	Max = H->Elements[1];  // �õ����ֵ
+	tmp = H->Elements[H->Size--];  // �õ���ȫ���������һ��ֵ 
+	// �б�������parent �Ƿ������ӽ�� 
+	for(parent=1;parent*2<=H->Size;parent=child){
+		// ���Һ��ӽ�����ҽϴ��ֵ 
+		child = 2 * parent;  // ���ӽ�� 
+		// child!=H->Size ��ʾ child ��Ϊ��ǰ���һ����㣬�� parent ���Һ��ӽ�� 
+		if((child!=H->Size) &&(H->Elements[child] < H->Elements[child+1]))
+			child++;  
+		// �� tmp �Ҹ����ʵ�λ�� 
+		// �����ǰ���Һ��ӽ��� tmp ��С��˵�� tmp λ���Ѿ����� 
+		if(H->Elements[child] <= tmp)
+			break;
+		else    // ����ѽϴ�ĺ��ӽ�����������Լ�������ȥ�� 
+			H->Elements[parent] = H->Elements[child];
+	}
+	H->Elements[parent] = tmp;  // �ں��ʵ�λ�ð� tmp �Ž�ȥ 
+	return Max;
+} 
+
+// �ж��Ƿ��Ѿ��� 
+bool IsFull(MaxHeap H){
+	return (H->Size == H->Capacity);
+}
+
+// �ж��Ƿ�Ϊ��
+bool IsEmpty(MaxHeap H){
+	return !H->Size;
+}
+
+// �������
+void LevelOrderTraversal(MaxHeap H){
+	int i;
+	printf("��������Ľ���ǣ�");
+	for(i = 1;i<=H->Size;i++){
+		printf("%d ",H->Elements[i]);
+	} 
+	printf("\n"); 
+} 
+
+int main(){
+	MaxHeap H;
+	int MaxSize = 100;
+	H = Create(MaxSize);
+	Insert(H,55);
+	Insert(H,66);
+	Insert(H,44);
+	Insert(H,33);
+	Insert(H,11);
+	Insert(H,22);
+	Insert(H,88);
+	Insert(H,99);
+	/*
+		 99
+		/  \
+	   88  66
+	  / \  / \
+	 55 11 22 44
+	/ 
+   33	  
+	*/
+	LevelOrderTraversal(H);
+	DeleteMax(H);
+	LevelOrderTraversal(H);
+	DeleteMax(H);
+	LevelOrderTraversal(H);
+	DeleteMax(H);
+	LevelOrderTraversal(H);
+	DeleteMax(H);
+	LevelOrderTraversal(H);
+	return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/上课Demo/10.堆的操作.exe b/上课Demo/10.堆的操作.exe
new file mode 100644
index 0000000..a702d68
Binary files /dev/null and b/上课Demo/10.堆的操作.exe differ
diff --git a/上课Demo/11.堆的两种建立方式.cpp b/上课Demo/11.堆的两种建立方式.cpp
new file mode 100644
index 0000000..059a704
--- /dev/null
+++ b/上课Demo/11.堆的两种建立方式.cpp
@@ -0,0 +1,120 @@
+#include<iostream>
+#include<malloc.h>
+const int MinData = -100000;  // �ڱ�ֵ
+const int MaxSize = 1005;   // ������ 
+using namespace std;
+typedef struct HeapStruct *Heap;
+struct HeapStruct{
+	int *data;   // ��ֵ������ 
+	int size;   // ��ǰԪ�ظ��� 
+	int capacity;  // ������� 
+};
+
+// ��ʼ����
+Heap Create(){
+	Heap H;
+	H = (Heap)malloc(sizeof(struct HeapStruct));
+	H->data = (int *)malloc(sizeof(int) * (MaxSize+1));
+	H->size = 0;
+	H->capacity = MaxSize;
+	H->data[0] = MinData;
+	return H;
+} 
+
+// �������ƶѵ�"ɾ������" 
+void sort(Heap H,int i){
+	int child,parent;
+	int tmp = H->data[i];  // �õ���ǰ"������ֵ" 
+	for(parent = i;parent*2<=H->size;parent = child){
+		child = 2 * parent;
+		if((child!=H->size) && (H->data[child+1] < H->data[child]))
+			child++;
+		if(H->data[child] >= tmp)
+			break;
+		else
+			H->data[parent] = H->data[child]; 
+	}
+	H->data[parent] = tmp;
+}
+// ����
+void adjust(Heap H){
+	int i= H->size/2;
+	for(;i>0;i--){
+		// ��ÿ���к��ӽ��Ľ����Ϊ����㣬�����������ж����� 
+		sort(H,i);
+	}
+} 
+
+// ���� 
+void bl(Heap H){
+	for(int i=1;i<=H->size;i++){
+		cout<<H->data[i]<<" ";
+	}
+	cout<<endl;
+}
+
+
+int main(){
+	Heap H;
+	H = Create();
+	int n;
+	cin>>n;
+	for(int i=0;i<n;i++)
+		cin>>H->data[++H->size];
+	adjust(H);
+	bl(H); 
+	return 0;
+}
+
+/*
+#include<iostream>
+#include<malloc.h>
+const int MinData = -100000;  // �ڱ�ֵ
+const int MaxSize = 1005;   // ������ 
+using namespace std;
+typedef struct HeapStruct *Heap;
+struct HeapStruct{
+	int *data;   // ��ֵ������ 
+	int size;   // ��ǰԪ�ظ��� 
+	int capacity;  // ������� 
+};
+
+// ��ʼ����
+Heap Create(){
+	Heap H;
+	H = (Heap)malloc(sizeof(struct HeapStruct));
+	H->data = (int *)malloc(sizeof(int) * (MaxSize+1));
+	H->size = 0;
+	H->capacity = MaxSize;
+	H->data[0] = MinData;
+	return H;
+} 
+
+// ����
+void Insert(Heap H,int x){
+	int i = ++H->size;  // ָ���������һ�� 
+	for(;H->data[i/2]>x;i/=2)
+		H->data[i] = H->data[i/2];
+	H->data[i] = x;
+} 
+
+// ���� 
+void bl(Heap H){
+	for(int i=1;i<=H->size;i++)
+		cout<<H->data[i];
+}
+
+int main(){
+	Heap H;
+	H = Create();
+	int n;
+	cin>>n;
+	for(int i=0;i<n;i++){
+		int t;
+		cin>>t;
+		Insert(H,t);
+	}
+	bl(H);
+	return 0;
+} 
+*/ 
diff --git a/上课Demo/11.堆的两种建立方式.exe b/上课Demo/11.堆的两种建立方式.exe
new file mode 100644
index 0000000..929d526
Binary files /dev/null and b/上课Demo/11.堆的两种建立方式.exe differ
diff --git a/上课Demo/12.哈夫曼树.cpp b/上课Demo/12.哈夫曼树.cpp
new file mode 100644
index 0000000..381ceb5
--- /dev/null
+++ b/上课Demo/12.哈夫曼树.cpp
@@ -0,0 +1,155 @@
+#include<iostream>
+#include<malloc.h>
+#define MaxSize 1000
+#define MinData -1000 
+int A[] = {13,1,45,7,20,4,19,13,40,33,38};  // Ԥ�ȶ����һ��Ȩֵ 
+int A_length = 11;  // �����䳤�� 
+typedef struct HeapStruct *MinHeap;   
+typedef struct TreeNode *HuffmanTree;
+struct HeapStruct{  // ��Ź��������Ķ� 
+	HuffmanTree *data;   // ��ֵ������  
+	int size;   // �ѵĵ�ǰ��С  
+	int capacity; // �������	
+};
+struct TreeNode{ // �������� 
+	int weight;  //Ȩֵ
+	HuffmanTree Left;  // ������ 
+	HuffmanTree right; // ������ 
+}; 
+using namespace std;
+
+MinHeap create(); // ��ʼ����
+HuffmanTree Create(); // ��ʼ���������� 
+void sort(MinHeap H,int i); // ���������� 
+void adjust(MinHeap H); // �������� 
+void BuildMinHeap(MinHeap H);  // ���� 
+HuffmanTree Delete(MinHeap H); // ɾ����С��Ԫ�� 
+void Insert(MinHeap H,HuffmanTree Huff);  // ������С��Ԫ�� 
+void PreOrderTraversal(HuffmanTree Huff); // ������� 
+HuffmanTree Huffman(MinHeap H); // ������������ 
+
+// ��ʼ����
+MinHeap create(){
+	MinHeap H;
+	HuffmanTree Huff;
+	H = (MinHeap)malloc(sizeof(struct HeapStruct));
+	H->data = (HuffmanTree *)malloc(sizeof(struct TreeNode) * (MaxSize+1));
+	H->capacity = MaxSize;
+	H->size = 0;
+	// �������ڱ� 
+	Huff = Create();
+	Huff->weight = MinData;
+	H->data[0] = Huff;
+	return H;
+} 
+
+// ��ʼ���������� 
+HuffmanTree Create(){
+	HuffmanTree Huff;
+	Huff = (HuffmanTree)malloc(sizeof(struct TreeNode));
+	Huff->weight = 0;
+	Huff->Left = NULL;
+	Huff->right = NULL;
+	return Huff;
+}
+
+// ���������� 
+void sort(MinHeap H,int i){
+	int parent,child;
+	int tmp = H->data[i]->weight; // ȡ����ǰ"�����"ֵ
+	for(parent=i;parent*2<=H->size;parent = child){
+		child = 2 * parent;
+		if((child!=H->size) && (H->data[child+1]->weight < H->data[child]->weight))
+			child++;
+		if(H->data[child]->weight >= tmp)
+			break;
+		else
+			H->data[parent] = H->data[child];
+	} 
+	H->data[parent]->weight = tmp;
+}
+
+// �������� 
+void adjust(MinHeap H){
+	for(int i =H->size/2;i>0;i--)
+		sort(H,i);// ÿ��"����С��"���� 
+}
+
+// ���� 
+void BuildMinHeap(MinHeap H){
+	// ��Ȩֵ�������
+	HuffmanTree Huff;  
+	for(int i=0;i<A_length;i++){
+		Huff = Create();
+		Huff->weight = A[i];
+		H->data[++H->size] = Huff;
+	}
+	// ������ 
+	adjust(H);
+}
+
+
+// ɾ����С��Ԫ��
+HuffmanTree Delete(MinHeap H){
+	int parent,child;
+	HuffmanTree T = H->data[1];  // ȡ�������Ĺ������� 
+	HuffmanTree tmp = H->data[H->size--]; // ȡ�����һ��������������Ȩֵ 
+	for(parent=1;parent*2<=H->size;parent = child){
+		child = 2 * parent;
+		if((child!=H->size) && (H->data[child+1]->weight < H->data[child]->weight))
+			child++;
+		if(H->data[child]->weight >= tmp->weight)
+			break;
+		else
+			H->data[parent] = H->data[child];
+	} 
+	H->data[parent] = tmp;
+	// ����һ�� HuffmanTree ��㣬���ϸղ�ȡ������Ȩֵ�����ظý�� 
+	return T;
+}
+
+// ����һ����������
+void Insert(MinHeap H,HuffmanTree Huff){
+	int weight = Huff->weight; // ȡ��Ȩֵ
+	int i = ++H->size;
+	for(;H->data[i/2]->weight > weight;i/=2)
+		H->data[i] = H->data[i/2];
+	H->data[i] = Huff;
+} 
+
+//���� 
+void PreOrderTraversal(HuffmanTree Huff){
+	if(Huff){
+		cout<<Huff->weight<<" ";
+		PreOrderTraversal(Huff->Left);
+		PreOrderTraversal(Huff->right);
+	}
+}
+
+// ������������ 
+HuffmanTree Huffman(MinHeap H){
+	HuffmanTree T;
+	BuildMinHeap(H); // ���� 
+	int times = H->size;
+	// �� times-1 �κϲ� 
+	for(int i=1;i<times;i++){
+		T = (HuffmanTree)malloc(sizeof(struct TreeNode));
+		T->Left = Delete(H);   // �Ӷ���ɾ��һ����㣬��Ϊ�� T �����ӽ�� 
+		T->right = Delete(H);  // �Ӷ���ɾ��һ����㣬��Ϊ�� T �����ӽ�� 
+		T->weight = T->Left->weight + T->right->weight; // ���¼���Ȩֵ 
+		Insert(H,T);  // �ټӽ����� 
+	}
+	T = Delete(H);
+	return T;
+} 
+
+
+
+int main(){
+	MinHeap H;
+	HuffmanTree Huff; 
+	H = create();
+	Huff = Huffman(H); 
+	PreOrderTraversal(Huff);
+	return 0;
+} 
diff --git a/上课Demo/12.哈夫曼树.exe b/上课Demo/12.哈夫曼树.exe
new file mode 100644
index 0000000..77d5f73
Binary files /dev/null and b/上课Demo/12.哈夫曼树.exe differ
diff --git a/上课Demo/13.并查集的表示.cpp b/上课Demo/13.并查集的表示.cpp
new file mode 100644
index 0000000..7a93bb8
--- /dev/null
+++ b/上课Demo/13.并查集的表示.cpp
@@ -0,0 +1,50 @@
+#include<iostream>
+#include<cstring>
+#define MaxSize 1000
+typedef int ElementType;
+typedef struct{
+	ElementType Data; // ��ֵ
+	int parent;  // ָ�򸸽�� 
+}SetType;
+using namespace std;
+
+// ���� 
+int Find(SetType s[],ElementType x){
+	int i;  
+	// �ҵ������и�ֵ��Ӧ���±� 
+	for(i=0;i<MaxSize && s[i].Data!=x;i++);
+	if(MaxSize <= i) // ���û���ҵ������� -1 
+		return -1;
+	// �ҵ��ý��ĸ���� 
+	for(;s[i].parent >= 0;i = s[i].parent); 
+	return i; // ���ظ���������� s �е��±� 
+}
+
+// �� 
+void Union(SetType s[],ElementType x1,ElementType x2){
+	int root1 = Find(s,x1);  // �ҵ� x1 �ĸ�����±� 
+	int root2 = Find(s,x2);  // �ҵ� x2 �ĸ�����±� 
+	// ����������±겻ͬ��˵������һ������
+	if(root1 != root2){   
+		s[root1].parent = root2;   // �� x1 �ҵ� x2 �ļ��� 
+	}
+}
+
+int main(){
+	SetType s[MaxSize];
+	// ��ʼ�����飬�����ȫ��ָ�� -1 
+	for(int i=0;i<MaxSize;i++){
+		s[i].Data = i+1;
+		s[i].parent = -1;
+	}
+	cout<<Find(s,5)<<endl;
+	Union(s,3,5);
+	cout<<Find(s,4)<<endl;
+	cout<<Find(s,3)<<endl;
+	Union(s,1,3);
+	Union(s,2,4);
+	Union(s,8,6);
+	cout<<Find(s,6)<<endl;
+	cout<<Find(s,8)<<endl;
+	return 0;
+}
diff --git a/上课Demo/13.并查集的表示.exe b/上课Demo/13.并查集的表示.exe
new file mode 100644
index 0000000..a1c74ad
Binary files /dev/null and b/上课Demo/13.并查集的表示.exe differ
diff --git a/上课Demo/14.排序算法的实现.cpp b/上课Demo/14.排序算法的实现.cpp
new file mode 100644
index 0000000..274dc53
--- /dev/null
+++ b/上课Demo/14.排序算法的实现.cpp
@@ -0,0 +1,300 @@
+#include<iostream>
+#include<cstdlib>
+#include<algorithm>
+#include<cmath> 
+#define NumSize 20
+int A[NumSize];
+using namespace std;
+
+// ��������� 
+void Random(){
+	for(int i=0;i<NumSize;i++)
+		A[i] = rand()%NumSize+1;
+}
+
+// ��� 
+void output(){
+	for(int i=0;i<NumSize;i++)
+		cout<<A[i]<<" ";
+	cout<<endl;
+}
+
+// ����
+void Bubble_sort(int N){
+	for(int p = N-1;p>=0;p--){    // �ܹ� n-1 �� 
+		bool flag = false;     
+		for(int j=0;j<p;j++){  // һ������ 
+			if(A[j+1] < A[j]){
+				swap(A[j],A[j+1]);
+				flag = true;
+			}
+		}
+		if(!flag)   // ���ȫ���޽��������Դ˴������� 
+			break;
+	}
+} 
+
+// �������� 
+void Insertion_sort(int A[],int N){
+	for(int p = 1;p<N;p++){
+		int tmp = A[p];   // ȡ��һ���� 
+		int j = p;
+		for(;tmp<A[j-1] && j > 0;j--)  // �ҵ�������ʺϵ�λ�� 
+			A[j] = A[j-1];  // ���ڡ���λ�� 
+		A[j] = tmp;  //  �Ѻ��ʴ�С�������� 
+	} 
+}
+
+// ԭʼϣ������ 
+void shell_sort(int N){
+	for(int D=N/2;D>0;D/=2){
+		for(int p=D;p<N;p+=D){
+			int tmp = A[p];
+			int j = p;
+			for(;j>=D && tmp<A[j-D] ;j-=D)  // j>=D ��ǰ����ΪҲ�� A[j-D]�Ѿ�Խ�� 
+				A[j] = A[j-D];
+			A[j] = tmp;
+		}
+	}
+} 
+
+// Hibbard��������ϣ������ 
+void Hibbard_shell_sort(int N){
+	int add[]={32767,16383,8191,4095,2047,1023,511,255,127,63,31,15,7,3,1,0};
+	int i=0;
+	for(int D=add[i];D>0;D=add[++i]){
+		for(int p=D;p<N;p++){
+			long tmp = A[p];
+			int k=p;
+			for(;k>=D && tmp<A[k-D] ;k-=D) // j>=D ��ǰ����ΪҲ�� A[j-D]�Ѿ�Խ�� 
+				A[k] = A[k-D];
+			A[k] = tmp;
+		}
+	}
+}
+
+// Sedgewick��������ϣ������
+void Sedgewick_shell_sort(int N){
+	int add[]= {587521,260609,146305,64769,36289,16001,8929,3905,2161,929,505,209,109,41,19,5,1,0};
+	int i=0;
+	for(int D=add[i];D>0;D=add[++i]){
+		for(int p=D;p<N;p++){
+			long tmp = A[p];
+			int k = p;
+			for(;k>=D && tmp<A[k-D];k-=D)
+				A[k] = A[k-D];
+			A[k] = tmp;
+		}
+	} 
+}
+
+/********************������ʼ******************************/ 
+// ���������� 
+void PrecDown(int i,int N){
+	int child,parent;
+	int tmp = A[i];  // �õ���ǰ"��"����ֵ
+	// �±�� 0 ��ʼ��ע�������Χ�͸��ӽ��֮��Ĺ�ϵ 
+	for(parent = i;parent*2+1<=N-1;parent = child){
+		child = 2*parent + 1;  
+		if((child!=N-1) && (A[child] < A[child+1])) // ѡ���� 
+			child++;
+		if(A[child] <= tmp)
+			break;
+		A[parent] = A[child];
+	}
+	A[parent] = tmp;
+}
+
+void swap(int &a,int &b){
+	int t =a;
+	a = b;
+	b = t;
+}
+
+// ������
+void Heap_sort(int N){
+	// buildHeap 
+	for(int i=N/2;i>=0;i--) 
+		PrecDown(i,N);
+	for(int i=N-1;i>0;i--){
+		swap(A[0],A[i]);
+		PrecDown(0,i);
+	} 
+} 
+/*******************���������******************************/ 
+
+
+/********************�鲢���򣨵ݹ飩��ʼ******************************/ 
+// �鲢����ʵ�� 
+void Merge(int A[],int tmpA[],int L,int R,int RightEnd){
+	// L = �����ʼλ�ã�R = �ұ���ʼλ�ã�RightEnd = �ұ��յ�λ�� 
+	int LeftEnd = R-1;   // ����յ�λ�� 
+	int tmp = L;   //  ��Ž���Ŀ�ʼλ�� 
+	int NumElements = RightEnd - L + 1;  // �鲢���� 
+	while(L<=LeftEnd && R<=RightEnd){
+		if(A[L] <= A[R])
+			tmpA[tmp++] = A[L++];
+		else
+			tmpA[tmp++] = A[R++];
+	}
+	// �����ʣ 
+	while(L<=LeftEnd)
+		tmpA[tmp++] = A[L++];
+	// �ұ���ʣ 
+	while(R<=RightEnd)
+		tmpA[tmp++] = A[R++];
+	//  ���ؽ�� 
+	for(int i=0;i<NumElements;i++,RightEnd--)
+		A[RightEnd] = tmpA[RightEnd];
+} 
+
+// ���� 
+void Msort(int A[],int tmpA[],int L,int RightEnd){
+	// L = �����ʼλ�ã�RightEnd = �ұ��յ�λ�� 
+	// �������Ԫ�� 
+	if( L < RightEnd){
+		int center = (L+RightEnd)/2;
+		Msort(A,tmpA,L,center);  // ���� 
+		Msort(A,tmpA,center+1,RightEnd);  // �Ұ��
+		Merge(A,tmpA,L,center+1,RightEnd);  // center+1 ���ұ���� 
+	}
+} 
+/*
+// �鲢���򣨵ݹ飩 
+void Merge_sort(int A[],int N){
+	int tmpA[N];
+	Msort(A,tmpA,0,N-1);
+}*/
+
+/********************�鲢���򣨵ݹ飩����******************************/ 
+
+/********************�鲢���򣨷ǵݹ飩����******************************/ 
+
+void Merge1(int A[],int tmpA[],int L,int R,int RightEnd){
+	// L = �����ʼλ�ã�R = �ұ���ʼλ�ã�RightEnd = �ұ��յ�λ�� 
+	int LeftEnd = R-1;   // ����յ�λ�� 
+	int tmp = L;   //  ��Ž���Ŀ�ʼλ�� 
+	int NumElements = RightEnd - L + 1;  // �鲢���� 
+	while(L<=LeftEnd && R<=RightEnd){
+		if(A[L] <= A[R])
+			tmpA[tmp++] = A[L++];
+		else
+			tmpA[tmp++] = A[R++];
+	}
+	// �����ʣ 
+	while(L<=LeftEnd)
+		tmpA[tmp++] = A[L++];
+	// �ұ���ʣ 
+	while(R<=RightEnd)
+		tmpA[tmp++] = A[R++];
+} 
+void Merge_pass(int A[],int tmpA[],int N,int length){
+	// length = ��ǰ�������г���
+	int i;
+	for(i=0;i<=N-2*length;i+=length*2)
+		Merge1(A,tmpA,i,i+length,i+2*length-1);
+	if(i+length<N)
+		Merge1(A,tmpA,i,i+length,N-1);
+	else
+		for(int j=i;j<N;j++)
+			tmpA[j] = A[j];
+}
+
+void Merge_sort(int A[],int N){
+	int length = 1;
+	int tmpA[N];
+	while(length<N){
+		Merge_pass(A,tmpA,N,length);
+		length *=2;
+		Merge_pass(tmpA,A,N,length);
+		length *=2;
+	}
+} 
+/********************�鲢���򣨷ǵݹ飩����******************************/ 
+
+/*********************��������ʼ*******************************************/ 
+
+// �����Ԫ 
+int GetPivot(int L,int R){
+	int center = (L+R)/2;
+	// ����  A[L] < A[center] < A[R] 
+	if(A[R] < A[center])
+		swap(A[R],A[center]);
+	if(A[R] < A[L])
+		swap(A[R],A[L]);
+	if(A[center] < A[L])
+		swap(A[L],A[center]);
+	// ����Ԫ���� R-1 
+	swap(A[center],A[R-1]);
+	return A[R-1];
+}
+
+// ����ʵ�� 
+void Quicksort(int Left,int Right){
+	int cutoff = 100;
+	if( cutoff <= Right-Left){
+		int Pivot = GetPivot(Left,Right);
+		int i = Left;
+		int j = Right-1;
+		while(1){
+			while(A[++i] < Pivot);
+			while(A[--j] > Pivot);
+			if(i < j)
+				swap(A[i],A[j]);
+			else
+				break;
+		}
+		swap(A[i],A[Right-1]);
+		Quicksort(Left,i-1);
+		Quicksort(i+1,Right);
+	}else
+		Insertion_sort(A+Left,Right-Left+1);
+}
+
+void Quick_sort(int N){
+	Quicksort(0,N-1);
+}
+/*********************�����������************************/ 
+
+/*********************Ͱ����ʼ********************/ 
+void Bucket_Sort(int N){
+	int count[1000];
+	// ��Χ���Ͱ�Ͷ��� 
+	for(int i=0;i<1000;i++){
+		count[i] = 0;
+	}
+	// ÿ��ֵ����Ͱ�� 
+	for(int i=0;i<N;i++)
+		count[A[i]]++;
+	// �ռ� 
+	for(int i=0;i<N;i++)
+		if(count[i]){
+			for(int j=0;j<count[i];j++)
+				cout<<i<<" ";
+		}
+}
+
+/*********************Ͱ����ʼ******************/ 
+
+int main(){
+	Random(); // ��������� 
+	output();  // �������Ԫ�� 
+//	Bubble_sort(NumSize);   // ���� 
+//	Insertion_sort(NumSize);   // �������� 
+//	shell_sort(NumSize);   // ϣ������  
+//	Heap_sort(NumSize);   // ������ 
+//	Merge_sort(A,NumSize);   // �鲢���� 
+//	Hibbard_shell_sort(NumSize);	
+//	Sedgewick_shell_sort(NumSize);
+//	Quick_sort(NumSize);
+	Bucket_Sort(NumSize);
+//	output(); 
+	return 0;
+}
+
+
+
+
+
+
+
diff --git a/上课Demo/14.排序算法的实现.exe b/上课Demo/14.排序算法的实现.exe
new file mode 100644
index 0000000..c51135a
Binary files /dev/null and b/上课Demo/14.排序算法的实现.exe differ
diff --git a/上课Demo/15.图的邻接矩阵实现.c b/上课Demo/15.图的邻接矩阵实现.c
new file mode 100644
index 0000000..fed172e
--- /dev/null
+++ b/上课Demo/15.图的邻接矩阵实现.c
@@ -0,0 +1,105 @@
+/*#include<stdio.h>
+#include<stdlib.h>
+#define MaxVertexNum 100
+typedef int weightType;
+typedef int Vertex;
+typedef int DataType;
+typedef struct GNode *ptrToGNode;
+struct GNode{   // ͼ 
+	int Nv;   // ������ 
+	int Ne;   // ����
+	weightType G[MaxVertexNum][MaxVertexNum];
+	DataType Data[MaxVertexNum]; // �涥������� 
+}; 
+typedef ptrToGNode MGraph;
+typedef struct ENode *ptrToENode;
+struct ENode{  // �� 
+	Vertex V1,V2;    // �����<V1,V2> 
+	weightType Weight;  // Ȩ�� 
+};
+typedef ptrToENode Edge;
+
+// ��ʼ��ͼ 
+MGraph Create(int VertexNum){
+	Vertex v,w;
+	MGraph Graph;
+	
+	Graph = (MGraph)malloc(sizeof(struct GNode));
+	Graph->Nv = VertexNum;
+	Graph->Ne = 0;
+	
+	for(v=0;v<VertexNum;v++)
+		for(w=0;w<VertexNum;w++)
+			Graph->G[v][w] = 0;
+	return Graph;
+}
+
+// ����� 
+MGraph Insert(MGraph Graph,Edge E){
+	
+	// ����� <V1,V2>
+	Graph->G[E->V1][E->V2] = E->Weight;
+	
+	// ���������ͼ������Ҫ����� <V2,V1>
+	Graph->G[E->V2][E->V1] = E->Weight;
+	
+} 
+
+// ��ͼ 
+MGraph BuildGraph(){
+	MGraph Graph;
+	Edge E;
+	Vertex V;
+	int Nv,i;
+	scanf("%d",&Nv);   // ���붥���� 
+	Graph = Create(Nv);
+	scanf("%d",&(Graph->Ne));  // ������� 
+	if(Graph->Ne != 0){   
+		E = (Edge)malloc(sizeof(struct ENode));
+		for(i=0;i<Graph->Ne;i++){
+			scanf("%d %d %d",&E->V1,&E->V2,&E->Weight);  // ����ÿ���ߵ����� 
+			Insert(Graph,E);
+		}
+	}
+	return Graph;
+}
+*/ 
+
+#include<stdio.h>
+#include<stdlib.h>
+#define MAXN 100
+int G[MAXN][MAXN],Nv,Ne;
+
+void BuildGraph(){
+	int i,j,v1,v2,w;
+	
+	scanf("%d",&Nv);
+	// ��ʼ��ͼ 
+	for(i=0;i<Nv;i++) 
+		for(j=0;j<Nv;j++)
+			G[i][j] = 0;
+	scanf("%d",&Ne);
+	// ����� 
+	for(i=0;i<Ne;i++){
+		scanf("%d %d %d",&v1,&v2,&w);
+		G[v1][v2] = w;
+		G[v2][v1] = w;
+	}
+}
+
+
+// ����ͼ
+void print(){
+	int i,j;
+	for(i=0;i<Nv;i++){
+		for(j=0;j<Nv;j++)
+			printf("%d ",G[i][j]);
+		printf("\n");
+	}
+} 
+
+int main(){
+	BuildGraph();
+	print();
+	return 0;
+}
diff --git a/上课Demo/15.图的邻接矩阵实现.exe b/上课Demo/15.图的邻接矩阵实现.exe
new file mode 100644
index 0000000..429d887
Binary files /dev/null and b/上课Demo/15.图的邻接矩阵实现.exe differ
diff --git a/上课Demo/16.图的邻接表实现.c b/上课Demo/16.图的邻接表实现.c
new file mode 100644
index 0000000..4bf1398
--- /dev/null
+++ b/上课Demo/16.图的邻接表实现.c
@@ -0,0 +1,176 @@
+/*#include<stdio.h>
+#include<stdlib.h>
+#define MaxVertexNum 100
+typedef int Vertex; 
+typedef int DataType; 
+typedef int weightType;  
+
+typedef struct ENode *ptrToENode;
+struct ENode{  // �� 
+	Vertex V1,V2;    // �����<V1,V2> 
+	weightType Weight;  // Ȩ�� 
+};
+typedef ptrToENode Edge;
+
+typedef struct AdjVNode *ptrToAdjVNode;
+struct AdjVNode{  // �ڽӱ���Ԫ�� 
+	Vertex AdjV;  // �ڽӵ��±� 
+	weightType Weight;  // Ȩֵ 
+	ptrToAdjVNode Next;  // ��һ�� 
+};
+
+typedef struct VNode{  // �ڽӱ�ͷ 
+	ptrToAdjVNode FirstEdge;  // ��ÿ������ָ��
+	DataType Data;  // �������� 
+}AdjList[MaxVertexNum];
+
+typedef struct GNode *ptrToGNode;
+struct GNode{  // ͼ 
+	int Nv;  // ����
+	int Ne;  // ���� 
+	AdjList G; // �ڽӱ� 
+}; 
+typedef ptrToGNode LGraph;
+
+// ��ʼ�� 
+LGraph create(int VertexNum){
+	Vertex v,w;
+	LGraph Graph;
+	
+	Graph = (LGraph)malloc(sizeof(struct GNode));
+	Graph->Nv = VertexNum;  // ��ʼ����
+	Graph->Ne = 0;   // ��ʼ����
+	
+	// ÿ���ߵ� FirstEdge ָ�� NULL 
+	for(v=0;v<Graph->Nv;v++)
+		Graph->G[v].FirstEdge = NULL;
+	return Graph;
+}
+
+
+// ����һ���ߵ��ڽӱ��Ķ���ָ��֮�� 
+void InsertEdge(LGraph Graph,Edge E){
+	ptrToAdjVNode newNode; 
+	
+	            //   �����<V1,V2> 
+	// Ϊ V2 �����µĽ�� 
+	newNode = (ptrToAdjVNode)malloc(sizeof(struct AdjVNode));
+	newNode->AdjV = E->V2;
+	newNode->Weight = E->Weight;
+	
+	// �� V2 ���뵽�ڽӱ�ͷ 
+	newNode->Next = Graph->G[E->V1].FirstEdge;
+	Graph->G[E->V1].FirstEdge = newNode;
+	
+	          //   ��Ϊ����ͼ�������<V2,V1>
+	newNode = (ptrToAdjVNode)malloc(sizeof(struct AdjVNode));
+	newNode->AdjV = E->V1;
+	newNode->Weight = E->Weight;
+	
+	newNode->Next = Graph->G[E->V2].FirstEdge;
+	Graph->G[E->V2].FirstEdge = newNode;
+} 
+
+// ��ͼ
+LGraph BuildGraph(){
+	LGraph Graph;
+	Edge E;
+	Vertex V;
+	int Nv,i;
+	scanf("%d",&Nv);
+	Graph = create(Nv);
+	scanf("%d",&(Graph->Ne));
+	if(Graph->Ne != 0){
+		for(i=0;i<Graph->Ne;i++){
+			E = (Edge)malloc(sizeof(struct ENode));
+			scanf("%d %d %d",&E->V1,&E->V2,&E->Weight);
+			InsertEdge(Graph,E);
+		}
+	}
+	return Graph;
+} 
+
+// ��ӡ 
+void print(LGraph Graph){
+	Vertex v;
+	ptrToAdjVNode tmp;
+	for(v=0;v<Graph->Nv;v++){
+		tmp = Graph->G[v].FirstEdge;
+		printf("%d ",v);
+		while(tmp){
+			printf("%d ",tmp->AdjV);
+			tmp = tmp->Next;
+		}
+		printf("\n");
+	}
+}
+
+int main(){
+	LGraph Graph;
+	Graph = BuildGraph();
+	print(Graph);
+	return 0;
+}*/ 
+
+#include<stdio.h>
+#include<stdlib.h>
+#define MaxVertexNum 100
+typedef struct AdjVNode *AdjList;
+struct AdjVNode{
+	int weight;  // Ȩֵ 
+  	int adjv;   // �±� 
+	AdjList next;  // ���һ�� 
+};
+AdjList Graph[MaxVertexNum];
+int Ne,Nv;
+
+// ��ͼ
+void BuildGraph(){
+	int i;
+	int v1,v2,w;
+	AdjList NewNode;
+	scanf("%d",&Nv);
+	for(i=0;i<Nv;i++){
+		Graph[i] = (AdjList)malloc(sizeof(struct AdjVNode));
+		Graph[i]->adjv = i;
+		Graph[i]->next = NULL;
+	}
+	scanf("%d",&Ne);
+	for(i=0;i<Ne;i++){
+		scanf("%d %d %d",&v1,&v2,&w);
+		NewNode = (AdjList)malloc(sizeof(struct AdjVNode));
+		NewNode->adjv = v1;
+		NewNode->weight = w;
+		
+		NewNode->next = Graph[v2]->next;
+		Graph[v2]->next = NewNode;
+		
+		NewNode = (AdjList)malloc(sizeof(struct AdjVNode));
+		NewNode->adjv = v2;
+		NewNode->weight = w;
+		
+		NewNode->next = Graph[v1]->next;
+		Graph[v1]->next = NewNode;
+	}
+} 
+
+void print(){
+	AdjList tmp;
+	int i;
+	for(i=0;i<Nv;i++){
+		tmp = Graph[i];
+		while(tmp){
+			printf("%d ",tmp->adjv);
+			tmp = tmp->next;
+		}
+		printf("\n");
+	}
+}
+
+int main(){
+	
+	BuildGraph();
+	print();
+	return 0;
+}
+
diff --git a/上课Demo/16.图的邻接表实现.exe b/上课Demo/16.图的邻接表实现.exe
new file mode 100644
index 0000000..bcc3bea
Binary files /dev/null and b/上课Demo/16.图的邻接表实现.exe differ
diff --git a/上课Demo/17.图的迷宫遍历.cpp b/上课Demo/17.图的迷宫遍历.cpp
new file mode 100644
index 0000000..e20e446
--- /dev/null
+++ b/上课Demo/17.图的迷宫遍历.cpp
@@ -0,0 +1,97 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<queue>
+#define col 12
+#define row 10
+int Graph[row][col];  // ���ͼ 
+bool visit[row][col];  // �����״̬ 
+int times[row][col];   // ����ʴ��� 
+typedef struct Node *coordinate;
+struct Node{    // ���� 
+	int hor; // ������ 
+	int ver; // ������ 
+};
+using namespace std;
+
+// ��ʼ��ͼ 
+void Init(){
+	int tmp[row][col]= {{1,1,1,0,1,1,1,0,1,1,1,0},
+				        {1,0,1,1,0,0,1,0,1,0,0,0},
+				        {1,0,0,0,1,0,0,0,1,0,1,1},
+				        {1,0,1,1,1,1,1,1,1,0,0,1},
+				        {0,0,1,0,0,1,0,1,1,1,1,0},
+				        {1,1,1,0,1,1,0,0,0,1,1,1},
+				        {1,1,0,1,1,1,1,0,0,1,0,0},
+				        {0,0,0,1,0,0,1,0,1,0,1,1},
+				        {0,1,1,0,1,1,1,0,1,0,1,0},
+				        {0,0,0,0,0,1,1,0,1,0,1,1}};
+	for(int i=0;i<row;i++)
+		for(int j=0;j<col;j++){
+			times[i][j] = 1000;  // ��ʼ���ɴ�������С���� 
+			Graph[i][j] = tmp[i][j];
+			if(Graph[i][j])  // Ϊ 1 ���Է��� 
+				visit[i][j] = true;
+			else
+				visit[i][j] = false;
+		}
+}
+
+
+// ��ʼ������ 
+coordinate create(int i,int j){
+	coordinate C = (coordinate)malloc(sizeof(struct Node));
+	C->hor = i;
+	C->ver = j;
+	return C;
+}
+
+int min(int t1,int t2){
+	return t1<t2?t1:t2;
+}
+
+// ���� �����ϡ����ҡ��ҡ����¡��¡����¡��� �˸�λ�� 
+
+int x[] = {-1,-1,-1,0,1,1,1,0};
+int y[] = {-1,0,1,1,1,0,-1,-1};
+void BFS(){
+	queue<coordinate> q;
+	coordinate tmp;
+	// �������� 
+	tmp = create(0,0);
+	visit[0][0] = false;
+	times[0][0] = 0;
+	q.push(tmp);
+	while(!q.empty()){
+		 // ȡ�������е��±�Ͳ��� 
+		 coordinate nowNode = q.front();
+		 int xx = nowNode->hor;
+		 int yy = nowNode->ver;
+		 int nowtimes = times[xx][yy];
+		 q.pop();  // ���� 
+		 // �õ�����Χ�˸�������� 
+		 for(int i=0;i<8;i++){
+		 	int newx = xx + x[i];
+		 	int newy = yy + y[i];
+		 	// ����ڷ�Χ�� 
+		 	if((newx>=0 && newx<row) &&(newy>=0 && newy<col) && visit[newx][newy] ){ 
+		 		visit[newx][newy] = false;  // ����״̬ 
+	 			tmp = create(newx,newy);   
+	 			times[newx][newy] = min(times[newx][newy],nowtimes+1);  // ���²��� 
+	 			q.push(tmp);  // ��� 
+		 	}
+		 }
+	}
+}
+int main(){
+	Init();
+	BFS();
+	for(int i=0;i<row;i++){
+		for(int j=0;j<col;j++)
+			if(times[i][j]==1000)
+				printf(" -1");
+			else 
+				printf("%3d",times[i][j]);
+		printf("\n");
+	}
+	return 0;
+}
diff --git a/上课Demo/17.图的迷宫遍历.exe b/上课Demo/17.图的迷宫遍历.exe
new file mode 100644
index 0000000..97830bf
Binary files /dev/null and b/上课Demo/17.图的迷宫遍历.exe differ
diff --git a/上课Demo/18.无权图的最短路径问题.cpp b/上课Demo/18.无权图的最短路径问题.cpp
new file mode 100644
index 0000000..3e28491
--- /dev/null
+++ b/上课Demo/18.无权图的最短路径问题.cpp
@@ -0,0 +1,88 @@
+#include<iostream>
+#include<stdlib.h>
+#include<cstdlib>
+#include<queue>
+#include<stack>
+#define Init -1
+#define MaxVertex  100
+int path[MaxVertex];  // �洢·��
+int dist[MaxVertex];  // �洢·������
+int G[MaxVertex][MaxVertex]; // ͼ
+int Ne;  // ������ 
+int Nv;  // �� 
+typedef int Vertex;
+using namespace std;
+
+
+void build(){
+	int v1,v2;
+	// ��ʼ���� 
+	cin>>Nv;
+	for(int i=1;i<=Nv;i++)
+		for(int j=1;j<=Nv;j++)
+		 	G[i][j] = 0;
+	// ��ʼ��·��
+	for(int i=1;i<=Nv;i++)
+		path[i] = Init;
+	// ��ʼ��·������
+	for(int i=1;i<=Nv;i++)
+		 dist[i] = Init;
+	// ��ʼ���� 
+	cin>>Ne;
+	for(int i=0;i<Ne;i++){
+		cin>>v1>>v2;
+		G[v1][v2] = 1; // ����ͼ�� 
+	}
+}
+
+void Unweighted(Vertex v){
+	queue<Vertex> q;
+	dist[v] = 0;  // ���Լ��ľ����� 0 
+	Vertex w;
+	q.push(v);
+	while(!q.empty()){
+		 w = q.front();
+		 q.pop();
+		 for(int i=1;i<=Nv;i++)
+		 	// ���û�����ʹ�������ͨ 
+		 	if(dist[i]==Init && G[w][i]){
+		 		dist[i] = dist[w]+1;  // ����һ���ľ��� + 1 
+		 		path[i] = w;  // w ����һ��Ҫ��·������һ��·�� 
+		 		q.push(i);
+		 	}
+	}
+}
+
+// ��ȡ·�� 
+void getTail(Vertex v){
+	for(int i=1;i<=Nv;i++){
+		if(i==v)
+			continue;
+		stack<Vertex> s;
+		cout<<v<<"��"<<i<<"����̾����ǣ�"<<dist[i];
+		Vertex w = i;
+		// ��û������ʼ���ǰһֱ��ѭ�� 
+		while(path[w]!=Init){
+			s.push(w);  // ��ջ 
+			w = path[w];
+		}
+		// ���������ջԪ�أ��õ�·�� 
+		cout<<"    ��·��Ϊ��";
+		if(v != i)
+			cout<<v;
+		while(!s.empty()){
+			// ���ջ��Ԫ�� 
+			cout<<"��"<<s.top();
+			s.pop(); // ��ջ 
+		}
+		cout<<endl;
+	}
+}
+
+
+int main(){
+	build();
+	Unweighted(3);
+	getTail(3); 
+	return 0;
+}
diff --git a/上课Demo/18.无权图的最短路径问题.exe b/上课Demo/18.无权图的最短路径问题.exe
new file mode 100644
index 0000000..ff38355
Binary files /dev/null and b/上课Demo/18.无权图的最短路径问题.exe differ
diff --git a/上课Demo/19.Dijkstra.cpp b/上课Demo/19.Dijkstra.cpp
new file mode 100644
index 0000000..26f4a5c
--- /dev/null
+++ b/上课Demo/19.Dijkstra.cpp
@@ -0,0 +1,94 @@
+#include<iostream>
+#include<stdlib.h>
+#define Inf 1000000
+#define Init -1
+#define MaxVertex 100
+typedef int Vertex;
+int G[MaxVertex][MaxVertex];
+int dist[MaxVertex];  // ���� 
+int path[MaxVertex];  // ·�� 
+int collected[MaxVertex];  // ����¼���� 
+int Nv;   // ���� 
+int Ne;   // �� 
+using namespace std;
+
+// ��ʼ��ͼ��Ϣ 
+void build(){
+	Vertex v1,v2;
+	int w;
+	cin>>Nv;
+	// ��ʼ��ͼ 
+	for(int i=1;i<=Nv;i++)
+		for(int j=1;j<=Nv;j++)
+			G[i][j] = 0;
+	// ��ʼ��·�� 
+	for(int i=1;i<=Nv;i++)
+		path[i] = Init;
+	// ��ʼ������
+	for(int i=0;i<=Nv;i++)
+		dist[i] = Inf;
+	// ��ʼ����¼��� 
+	for(int i=1;i<=Nv;i++)
+		collected[i] = false;
+	cin>>Ne;
+	// ��ʼ����
+	for(int i=0;i<Ne;i++){
+		cin>>v1>>v2>>w;
+		G[v1][v2] = w;  // ����ͼ 
+	}
+}
+
+// ��ʼ�������·����Ϣ 
+void crate(Vertex s){
+	dist[s] = 0;
+	collected[s] = true;
+	for(int i=1;i<=Nv;i++)
+		if(G[s][i]){
+			dist[i] = G[s][i];
+			path[i] = s;
+		}
+}
+
+// ����δ��¼������dist��С��
+Vertex FindMin(Vertex s){
+	int min = 0;  // ֮ǰ�صذ� dist[0] ��ʼ��Ϊ������ 
+	for(Vertex i=1;i<=Nv;i++)
+		if(i != s && dist[i] < dist[min] && !collected[i])
+			min = i;
+	return min;
+}
+
+
+void Dijkstra(Vertex s){
+	crate(s); 
+	while(true){
+		Vertex V = FindMin(s);   // �ҵ� 
+		if(!V)
+			break;
+		collected[V] = true;  //��¼
+		for(Vertex W=1;W<=Nv;W++)
+			if(!collected[W] && G[V][W]){  // ���δ����¼
+				if(dist[V] + G[V][W] < dist[W]){
+					dist[W] = G[V][W] + dist[V];
+					path[W] = V;
+				}
+			}
+	}
+}
+
+void output(){
+	for(int i=1;i<=Nv;i++)
+		cout<<dist[i]<<" ";
+	cout<<endl;
+	for(int i=1;i<=Nv;i++)
+		cout<<path[i]<<" ";
+	cout<<endl;
+}
+
+
+int main(){
+	build();
+	Dijkstra(1);
+	output();
+	return 0;
+}
diff --git a/上课Demo/19.Dijkstra.exe b/上课Demo/19.Dijkstra.exe
new file mode 100644
index 0000000..31f1d03
Binary files /dev/null and b/上课Demo/19.Dijkstra.exe differ
diff --git a/上课Demo/2.数组存储的线性表.c b/上课Demo/2.数组存储的线性表.c
new file mode 100644
index 0000000..ad67bff
--- /dev/null
+++ b/上课Demo/2.数组存储的线性表.c
@@ -0,0 +1,111 @@
+#include<stdio.h>
+#include<malloc.h>
+#define MAXSIZE 100  // MAXSIZE ����Ϊ Data ����Ĵ�С
+typedef int ElementType;  // ElementType �ɶ���Ϊ��������
+typedef struct LNode *List; 
+struct LNode{
+   ElementType Data[MAXSIZE]; 
+   int Last;  // Last �������Ա������һ��Ԫ��
+};
+List L;
+//�����±�Ϊ i ��Ԫ�أ�L->Data[i]
+//���Ա��ij��ȣ�L->Last+1
+
+List MakeEmpty(); //��ʼ��˳��� 
+int Find(ElementType X,List L); //���� X ��һ�γ��ֵ��±� 
+void Insert(ElementType X,int i,List L); //���±�Ϊ i �ĵط����� X 
+void Delete(int i,List L);   //ɾ���±�Ϊ i �ĵ�ǰֵ 
+ElementType FindKth(int K,List L);  //�����±�Ϊ K �ĵ�ǰֵ
+int Length(List L);  //����˳����ij��� 
+ 
+//��ʼ�� 
+List MakeEmpty(){
+    List L;
+    L = (List)malloc(sizeof(struct LNode));
+    L->Last = -1;
+    return L;
+}
+
+// ��ֵ���� 
+int Find(ElementType X,List L){
+    int i=0;
+    while(i <= L->Last && L->Data[i] != X)  
+        i++;
+    if(L->Last < i)  //���û�ҵ������� -1
+        return -1; 
+    else    // �ҵ��󷵻��±� 
+        return i;
+}
+
+// ����
+void Insert(ElementType X,int i,List L){
+    int j;
+    if(L->Last == MAXSIZE-1){  //����� 
+        printf("����");
+        return;
+    }
+    if(i < 0 || L->Last+1 < i){  //λ��Խ�磬����������� L->Data[L->Last+1]�����涼������λ���� 
+        printf("λ�ò��Ϸ�");
+        return;
+    }
+    for(j=L->Last;j>=i;j--)   // �Ӻ���ǰ�������Ųһ������ a[i]�ڳ�λ��     
+        L->Data[j+1] = L->Data[j];   
+    L->Data[i] = X;    //��Ԫ�ز���
+    L->Last++;    // Last��Ȼָ�����Ԫ��
+    return;
+} 
+
+//ɾ��
+void Delete(int i,List L){
+    int j;
+    if(i < 0 || L->Last <i){  //λ��Խ�磬��ɾ����ൽ L->Data[L->Last]
+        printf("L->Data[%d]������Ԫ��",i);
+        return;
+    }
+    for(j=i;j<=L->Last;j++)   // ��ǰ����������ǰŲһ������ a[i] ������ 
+        L->Data[j-1] = L->Data[j];
+    L->Last--;  // Last��Ȼָ�����Ԫ��
+    return;
+}
+
+// �������
+ElementType FindKth(int K,List L){
+	if(K < 0 || L->Last < K){  //λ��Խ��
+        printf("L->Data[%d]������Ԫ��",K);
+        return;
+    }
+    return L->Data[K];
+}
+
+//����
+int Length(List L){
+	return L->Last+1;
+} 
+
+int main(){
+	int i=0;
+	L = MakeEmpty();
+	Insert(11,0,L);
+	printf("�����Ա�L-Data[0]����11\n");
+	Insert(25,0,L);
+	printf("�����Ա�L-Data[0]����25\n");
+	Insert(33,0,L);
+	printf("�����Ա�L-Data[0]����33\n");
+	Insert(77,0,L);
+	printf("�����Ա�L-Data[0]����77\n");
+	printf("��ʱ�����Ա�Ϊ��"); 
+	for(i=0;i<Length(L);i++)
+		printf("%d ",L->Data[i]);
+	printf("\n");
+	printf("����ֵΪ12���±��ǣ�%d\n",Find(12,L));
+	printf("�±�Ϊ3�����Ա���ֵ�ǣ�%d\n",FindKth(3,L));
+	Delete(2,L);
+	printf("ɾ�����Ա����±�Ϊ2��Ԫ��\n");
+	Delete(2,L);
+	printf("ɾ�����Ա����±�Ϊ2��Ԫ��\n");
+	printf("��ʱ�����Ա�Ϊ��"); 
+	for(i=0;i<Length(L);i++)
+		printf("%d ",L->Data[i]);
+	printf("\n"); 
+	return 0;
+} 
diff --git a/上课Demo/2.数组存储的线性表.exe b/上课Demo/2.数组存储的线性表.exe
new file mode 100644
index 0000000..36be838
Binary files /dev/null and b/上课Demo/2.数组存储的线性表.exe differ
diff --git a/上课Demo/20.Floyd.cpp b/上课Demo/20.Floyd.cpp
new file mode 100644
index 0000000..f7bc25f
--- /dev/null
+++ b/上课Demo/20.Floyd.cpp
@@ -0,0 +1,66 @@
+#include<iostream>
+#include<stdlib.h>
+#define INF 1000000
+#define MaxVertex 100
+typedef int Vertex;
+int G[MaxVertex][MaxVertex];
+int dist[MaxVertex][MaxVertex];  // ���� 
+int path[MaxVertex][MaxVertex];  // ·�� 
+int Nv;   // ���� 
+int Ne;   // �� 
+using namespace std;
+
+// ��ʼ��ͼ��Ϣ 
+void build(){
+	Vertex v1,v2;
+	int w;
+	cin>>Nv;
+	// ��ʼ��ͼ 
+	for(int i=1;i<=Nv;i++)
+		for(int j=1;j<=Nv;j++)
+			G[i][j] = INF;
+	cin>>Ne;
+	// ��ʼ����
+	for(int i=0;i<Ne;i++){
+		cin>>v1>>v2>>w;
+		G[v1][v2] = w;  
+		G[v2][v1] = w;
+	}
+}
+
+void Floyd(){
+	for(Vertex i=1;i<=Nv;i++)
+		for(Vertex j=1;j<=Nv;j++){
+			dist[i][j] = G[i][j];
+			path[i][j] = -1;
+		}
+	for(Vertex k=1;k<=Nv;k++)
+		for(Vertex i=1;i<=Nv;i++)
+			for(Vertex j=1;j<=Nv;j++)
+				if(dist[i][k] + dist[k][j] < dist[i][j]){
+					dist[i][j] = dist[i][k] + dist[k][j];
+					path[i][j] = k;
+				}
+} 
+
+void output(){
+	for(Vertex i=1;i<=Nv;i++){ 
+		for(Vertex j=1;j<=Nv;j++)
+			cout<<dist[i][j]<<" ";	
+		cout<<endl;
+	}
+	cout<<endl;
+	for(Vertex i=1;i<=Nv;i++){ 
+		for(Vertex j=1;j<=Nv;j++)
+			cout<<path[i][j]<<" ";	
+		cout<<endl;
+	}
+}
+
+
+int main(){
+	build();
+	Floyd();
+	output();
+	return 0;
+}
diff --git a/上课Demo/20.Floyd.exe b/上课Demo/20.Floyd.exe
new file mode 100644
index 0000000..cebd08f
Binary files /dev/null and b/上课Demo/20.Floyd.exe differ
diff --git a/上课Demo/21.Prim.cpp b/上课Demo/21.Prim.cpp
new file mode 100644
index 0000000..fa5708f
--- /dev/null
+++ b/上课Demo/21.Prim.cpp
@@ -0,0 +1,91 @@
+#include<iostream>
+#include<vector>
+#define INF 100000
+#define MaxVertex 105
+typedef int Vertex; 
+int G[MaxVertex][MaxVertex];
+int parent[MaxVertex];   // ���鼯 
+int dist[MaxVertex]; // ���� 
+int Nv;    // ��� 
+int Ne;    // �� 
+int sum;  // Ȩ�غ� 
+using namespace std; 
+vector<Vertex> MST;  // �������� 
+
+// ��ʼ��ͼ��Ϣ 
+void build(){
+	Vertex v1,v2;
+	int w;
+	cin>>Nv>>Ne;
+	for(int i=1;i<=Nv;i++){
+		for(int j=1;j<=Nv;j++)
+			G[i][j] = 0;  // ��ʼ��ͼ 
+		dist[i] = INF;   // ��ʼ������
+		parent[i] = -1;  // ��ʼ�����鼯 
+	}
+	// ��ʼ����
+	for(int i=0;i<Ne;i++){
+		cin>>v1>>v2>>w;
+		G[v1][v2] = w;
+		G[v2][v1] = w;
+	}
+}
+
+// Prim�㷨ǰ�ij�ʼ�� 
+void IniPrim(Vertex s){
+	dist[s] = 0;
+	MST.push_back(s);
+	for(Vertex i =1;i<=Nv;i++)
+		if(G[s][i]){
+			dist[i] = G[s][i];
+			parent[i] = s;
+		} 
+}
+
+// ����δ��¼��dist��С�ĵ� 
+Vertex FindMin(){
+	int min = INF;
+	Vertex xb = -1;
+	for(Vertex i=1;i<=Nv;i++)
+		if(dist[i] && dist[i] < min){ 
+			min = dist[i];
+			xb = i;
+		}
+	return xb;
+}
+
+void output(){
+	cout<<"����¼˳��"<<endl; 
+	for(Vertex i=1;i<=Nv;i++)
+		cout<<MST[i]<<" ";
+	cout<<"Ȩ�غ�Ϊ��"<<sum<<endl; 
+	cout<<"����������"<<endl; 
+	for(Vertex i=1;i<=Nv;i++)
+		cout<<parent[i]<<" ";
+}
+
+void Prim(Vertex s){
+	IniPrim(s);
+	while(1){
+		Vertex v = FindMin();
+		if(v == -1)
+			break;
+		sum += dist[v];
+		dist[v] = 0;
+		MST.push_back(v);
+		for(Vertex w=1;w<=Nv;w++)
+			if(G[v][w] && dist[w])
+				if(G[v][w] < dist[w]){
+					dist[w] = G[v][w];
+					parent[w] = v;
+				}
+	}
+}
+
+
+int main(){
+	build();
+	Prim(1);
+	output();
+	return 0;
+} 
diff --git a/上课Demo/21.Prim.exe b/上课Demo/21.Prim.exe
new file mode 100644
index 0000000..176f7e6
Binary files /dev/null and b/上课Demo/21.Prim.exe differ
diff --git a/上课Demo/22.Kruskal.cpp b/上课Demo/22.Kruskal.cpp
new file mode 100644
index 0000000..febadf4
--- /dev/null
+++ b/上课Demo/22.Kruskal.cpp
@@ -0,0 +1,98 @@
+#include<iostream>
+#include<string>
+#include<vector>
+#include<queue>
+#define INF 100000
+#define MaxVertex 105
+typedef int Vertex; 
+int G[MaxVertex][MaxVertex];
+int parent[MaxVertex];   // ���鼯��С������ 
+int Nv;    // ��� 
+int Ne;    // �� 
+int sum;  // Ȩ�غ� 
+using namespace std; 
+struct Node{
+	Vertex v1;
+	Vertex v2;
+	int weight; // Ȩ�� 
+	// ��������������� 
+	bool operator < (const Node &a) const
+	{
+		return weight>a.weight;
+	}
+};
+vector<Node> MST;  // �������� 
+priority_queue<Node> q;   // ���� 
+
+// ��ʼ��ͼ��Ϣ 
+void build(){
+	Vertex v1,v2;
+	int w;
+	cin>>Nv>>Ne;
+	for(int i=1;i<=Nv;i++){
+		for(int j=1;j<=Nv;j++)
+			G[i][j] = 0;  // ��ʼ��ͼ
+		parent[i] = -1;
+	}
+	// ��ʼ����
+	for(int i=0;i<Ne;i++){
+		cin>>v1>>v2>>w;
+		struct Node tmpE;
+		tmpE.v1 = v1;
+		tmpE.v2 = v2;
+		tmpE.weight = w;
+		q.push(tmpE); 
+	}
+}
+
+//  ·��ѹ������ 
+int Find(int x){
+	if(parent[x] < 0)
+		return x;
+	else
+		return parent[x] = Find(parent[x]);
+} 
+
+//  ���ȹ鲢 
+void Union(int x1,int x2){
+	if(parent[x1] < parent[x2]){
+		parent[x1] += parent[x2];
+		parent[x2] = x1;
+	}else{
+		parent[x2] += parent[x1];
+		parent[x1] = x2;
+	}
+} 
+
+void Kruskal(){
+	// ��С�������ı߲��� Nv-1 ���һ��б� 
+	while(MST.size()!= Nv-1 && !q.empty()){
+		Node E = q.top();  // ����С��ȡ��һ��Ȩ����С�ı�
+		q.pop(); // ���������� 
+		if(Find(E.v1) != Find(E.v2)){  // ����������Ƿ���ͬһ���� 
+			sum += E.weight; 
+			Union(E.v1,E.v2);     // ������ 
+			MST.push_back(E);
+		}
+	}
+	
+} 
+
+
+void output(){
+	cout<<"����¼˳��"<<endl; 
+	for(Vertex i=0;i<Nv;i++)
+		cout<<MST[i].weight<<" ";
+	cout<<"Ȩ�غ�Ϊ��"<<sum<<endl; 
+	for(Vertex i=1;i<=Nv;i++)
+		cout<<parent[i]<<" ";
+	cout<<endl;
+}
+
+
+int main(){
+	build();
+	Kruskal();
+	output();
+	return 0;
+} 
diff --git a/上课Demo/22.Kruskal.exe b/上课Demo/22.Kruskal.exe
new file mode 100644
index 0000000..2a0bdbe
Binary files /dev/null and b/上课Demo/22.Kruskal.exe differ
diff --git a/上课Demo/23.散列表数组实现.cpp b/上课Demo/23.散列表数组实现.cpp
new file mode 100644
index 0000000..8566b8d
--- /dev/null
+++ b/上课Demo/23.散列表数组实现.cpp
@@ -0,0 +1,119 @@
+#include<iostream>
+#include<stdlib.h>
+#include<cmath>
+#define MAXTABLESIZE 100000   // �����������ٵ����ɢ�б����� 
+typedef int Index;
+typedef int ElementType; 
+typedef Index Position;
+typedef enum{   // �ֱ��Ӧ���кϷ�Ԫ�ء��ա�����ɾ��Ԫ�� 
+	Legitimate,Empty,Deleted
+} EntryType;  // ���嵥Ԫ״̬���� 
+
+typedef struct HashEntry Cell;
+struct HashEntry{   //  ��ϣ����ֵ��Ԫ 
+	ElementType Data;  // ���Ԫ��
+	EntryType Info;  // ��Ԫ״̬	
+};
+
+typedef struct HashTbl *HashTable;
+struct HashTbl{  // ��ϣ���ṹ�� 
+	int TableSize;   // ��ϣ����С 
+	Cell *Cells;   // ��ϣ����ֵ��Ԫ���� 
+};
+
+using namespace std;
+
+int NextPrime(int N);  // �������� 
+HashTable CreateTable( int TableSize); // ������ϣ�� 
+Index Hash(int Key,int TableSize);   // ��ϣ���� 
+
+// �������� 
+int NextPrime(int N){
+	int p = (N%2)?N+2:N+1;  // �Ӵ��� N ���¸�������ʼ
+	int i;
+		
+	while(p <= MAXTABLESIZE){
+		for(i = (int)sqrt(p);i>2;i--)
+			if(!(p%i))  // p �������� 
+				break;
+		if(i==2) 
+			break; 
+		p += 2;  // ������̽�¸����� 
+	}
+	return p;
+}
+
+// ������ϣ�� 
+HashTable CreateTable( int TableSize){
+	HashTable H;
+	int i;
+	H = (HashTable)malloc(sizeof(struct HashTbl));
+	// ��֤��ϣ����󳤶������� 
+	H->TableSize = NextPrime(TableSize);
+	// ��ʼ����Ԫ����
+	H->Cells = (Cell *)malloc(sizeof(Cell)*H->TableSize);
+	// ��ʼ����Ԫ����״̬ 
+	for(int i=0;i<H->TableSize;i++)
+		H->Cells[i].Info = Empty;
+	return H;
+}
+
+// ƽ��̽����� 
+Position Find(HashTable H,ElementType Key){
+	Position CurrentPos,NewPos; 
+	int CNum = 0 ;   // ��¼��ͻ����
+	CurrentPos = NewPos = Hash(Key,H->TableSize);
+	// �����ǰ��Ԫ״̬��Ϊ�գ�����ֵ���ȣ���һֱ�� 
+	while(H->Cells[NewPos].Info != Empty && H->Cells[NewPos].Data != Key){
+		if(++CNum % 2 ){ // ��ͻ�����η��� 
+			NewPos = CurrentPos + (CNum+1)/2*(CNum+1)/2;
+			// ���Խ�磬һֱ��ֱ���ٴν���߽� 
+			while(H->TableSize <= NewPos){
+				NewPos -= H->TableSize; 
+			}
+		}else{  // ��ͻż���η��� 
+			NewPos = CurrentPos - CNum/2*CNum/2;
+			// ���Խ�磬һֱ��ֱ���ٴν���߽� 
+			while(NewPos < 0){
+				NewPos += H->TableSize; 
+			}
+		}
+	} 
+	return NewPos;
+}
+
+// ����
+bool Insert( HashTable H,ElementType Key,int i){
+	Position Pos = i;
+	Pos = Find(H,Key);
+	// �����Ԫ��״̬����"���ںϷ�Ԫ��" 
+	if( H->Cells[Pos].Info != Legitimate){
+		H->Cells[Pos].Info = Legitimate;
+		H->Cells[Pos].Data = Key;
+	}
+	return true;
+} 
+
+// ������������ϣ���� 
+Index Hash(int Key,int TableSize){
+	return Key % TableSize;
+}
+
+
+void output(HashTable H){
+	for(int i=0;i<H->TableSize;i++)
+		cout<<i<<" "<<H->Cells[i].Data<<endl;
+} 
+
+int main(){
+	HashTable H = CreateTable(9);
+	int N;
+	cin>>N;
+	for(int i=0;i<N;i++){
+		int tmp;
+		cin>>tmp;
+		Insert(H,tmp,i);
+	}
+	output(H);
+	return 0;
+}
diff --git a/上课Demo/23.散列表数组实现.exe b/上课Demo/23.散列表数组实现.exe
new file mode 100644
index 0000000..8707ee5
Binary files /dev/null and b/上课Demo/23.散列表数组实现.exe differ
diff --git a/上课Demo/24.散列表链表实现.cpp b/上课Demo/24.散列表链表实现.cpp
new file mode 100644
index 0000000..82d0d52
--- /dev/null
+++ b/上课Demo/24.散列表链表实现.cpp
@@ -0,0 +1,135 @@
+#include<iostream>
+#include<cstdlib>
+#include<cmath>
+#define MAXTABLESIZE 100000
+typedef int Index;
+typedef int ElementType;
+typedef struct LNode *PtrToLNode;
+struct LNode{   // ������ 
+	ElementType Data;
+	PtrToLNode Next;
+}; 
+typedef PtrToLNode Position;
+typedef PtrToLNode List;
+
+typedef struct TblNode *HashTable;  // ɢ�б�
+struct TblNode{
+	int TableSize;   // ������󳤶� 
+	List Heads;  // ָ������ͷ�������� 
+}; 
+using namespace std;
+
+int NextPrime(int N){
+	int p = (N%2)?(N+2):(N+1);   // �� tablesize ������� 
+	int i;
+	while(p <= MAXTABLESIZE){
+		for(i = (int)sqrt(p);i>2;i--)
+			if(!(p%i))
+				break;
+		if(i==2)  // �ҵ������� 
+			break;
+		p += 2; // ��һ������
+	}
+	return p;
+}
+
+// ������ϣ�� 
+HashTable CreateTable( int TableSize){
+	HashTable H;
+	H = (HashTable)malloc(sizeof(struct TblNode));
+	H->TableSize = NextPrime(TableSize);
+	H->Heads = (List)malloc(sizeof(struct TblNode) * H->TableSize);
+	for(int i=0;i<H->TableSize;i++) 
+		H->Heads[i].Next = NULL;  // ����ͷ��H->Heads[i] �Dz��涫���� 
+	return H;
+}
+
+// ������������ϣ���� 
+Index Hash(	int TableSize,ElementType Key){
+	return  Key%TableSize;
+}
+
+// ����
+Position Find(HashTable H,ElementType Key){
+	Position p;
+	Index pos;
+	
+	pos = Hash(H->TableSize,Key); 
+	p = H->Heads[pos].Next;  //�������ͷ 
+	while(p && p->Data != Key)
+		p = p->Next;
+	return p;
+} 
+
+// ����
+bool Insert(HashTable H,ElementType Key){
+	Position p,NewCell;
+	Index pos;
+	
+	p = Find(H,Key);
+	if(!p){  // �ؼ���δ�ҵ������Բ��� 
+		NewCell = (Position)malloc(sizeof(struct LNode));
+		NewCell->Data = Key;
+		pos = Hash(H->TableSize,Key);   // ��ʼɢ�б���ַ
+		// ���������嵽��ǰ��
+		NewCell->Next = H->Heads[pos].Next;
+		H->Heads[pos].Next = NewCell;
+		return true;
+	}else{
+		return false;
+	}
+}
+
+void output(HashTable H){
+	for(int i=0;i<H->TableSize;i++){
+		cout<<i;
+		List p = H->Heads[i].Next;  
+		while(p){
+			cout<<" "<<p->Data;
+			p = p->Next;
+		} 
+		cout<<endl;
+	}
+}
+
+void DestroyTable(HashTable H){
+	Position P,tmp;
+	for(int i=0;i<H->TableSize;i++){
+		P = H->Heads[i].Next;
+		while( P ){
+			tmp = P->Next;
+			free(P);
+			P = tmp;
+		}
+	}
+	free(H->Heads);
+	free(H);
+} 
+
+
+int main(){
+	HashTable H = CreateTable(9);
+	int N;
+	cin>>N;
+	for(int i=0;i<N;i++){
+		int tmp;
+		cin>>tmp;
+		Insert(H,tmp);
+	}
+	output(H);
+	DestroyTable(H);
+	return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/上课Demo/24.散列表链表实现.exe b/上课Demo/24.散列表链表实现.exe
new file mode 100644
index 0000000..f59756f
Binary files /dev/null and b/上课Demo/24.散列表链表实现.exe differ
diff --git a/上课Demo/25.KMP算法.cpp b/上课Demo/25.KMP算法.cpp
new file mode 100644
index 0000000..3375d2c
--- /dev/null
+++ b/上课Demo/25.KMP算法.cpp
@@ -0,0 +1,105 @@
+/* ������ʵ�ְ� 
+#include<stdio.h>
+#include<string.h>
+typedef char* Position;
+#define NotFound NULL 
+
+char *Mystr(char* string,char *pattern){
+	int Strlen = strlen(string);
+	int Patlen = strlen(pattern);
+	int i,j;
+	int tmpi;
+	for(i=0;i<Strlen;i++){
+		tmpi=i;
+		j=0;
+		while(string[tmpi++] == pattern[j++] && j < Patlen);
+		if(j==Patlen){
+			return string+i;
+		}
+	}
+	return NULL;
+}
+
+
+int main(){
+	char string[] = "this is a simple example.";
+//	char string[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+	char pattern[] = "simple";
+//	char pattern[] = "ab";
+	Position p = Mystr(string,pattern);
+	if(p==NotFound)
+		printf("NotFound\n");
+	else
+		printf("%s",p);
+	return 0;
+} 
+
+
+*/
+// KMP �㷨 
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+typedef int Position;
+#define NotFound -1
+using namespace std;
+
+void BuildMatch(char *pattern,int *match){
+	int i,j;
+	int m = strlen(pattern);
+	match[0] = -1;
+	for(j=1;j<m;j++){
+		i = match[j-1];   // ǰһ���ַ��� match 
+		while((i>=0) && (pattern[i+1] != pattern[j]))  // ������ȣ����� 
+			i = match[i];
+		if(pattern[i+1] == pattern[j])  // ��ij�����ڵ��� 
+			match[j] = i+1;  // match+1 
+		else  // ����ǰ��û����ȵ� 
+			match[j] = -1; 
+	}
+}
+
+Position KMP(char* string,char *pattern){
+	int n = strlen(string);
+	int m = strlen(pattern);
+	int s,p;
+	if(n < m)
+		return NotFound;
+	int *match = (int *)malloc(sizeof(int) * m);
+	BuildMatch(pattern,match);   // ���� match ���� 
+	s = p = 0;
+	while(s < n && p < m){
+		if(string[s] == pattern[p]){ // �����ʱ���Ƚ���һ�� 
+			s++;
+			p++;
+		}else if(p>0)  // �������ˣ�pattern ���˵� match[p-1] + 1 ��λ��  
+			p = match[p-1]+1;
+		else   // �� p = 0 ʱ�϶�û�˵� 
+			s++;
+	}
+	return (p == m) ? (s-m) : NotFound;
+}
+
+int main(){
+	char string[] = "this is a simple example.";
+//	char string[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+	char pattern[] = "simple";
+//	char pattern[] = "ab";
+	Position p = KMP(string,pattern);
+	if(p==NotFound)
+		printf("NotFound\n");
+	else
+		printf("%s",string+p);
+	return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
diff --git a/上课Demo/25.KMP算法.exe b/上课Demo/25.KMP算法.exe
new file mode 100644
index 0000000..89da998
Binary files /dev/null and b/上课Demo/25.KMP算法.exe differ
diff --git a/上课Demo/3.链表存储的线性表.c b/上课Demo/3.链表存储的线性表.c
new file mode 100644
index 0000000..c15d45e
--- /dev/null
+++ b/上课Demo/3.链表存储的线性表.c
@@ -0,0 +1,155 @@
+#include<stdio.h>
+#include<malloc.h>
+typedef int ElementType; // ElementType �ɶ���Ϊ��������
+typedef struct LNode *List;
+struct LNode{
+	ElementType Data;   //������ 
+	List Next;   // ��һ�������ĵ�ַ 
+}; 
+List L;
+
+List MakeEmpty(); //��ʼ������ 
+int Length(List L);  // �Ա��������ķ������������� 
+List FindKth(int K,List L);  // ����Ų��� 
+List Find(ElementType X,List L);  // ��ֵ���� 
+List Insert(ElementType X,int i,List L);  //�� X ���뵽�� i-1(i>0) �����֮�� 
+List Delete(int i,List L); // ɾ���� i(i>0) ����� 
+void Print(List L); // �������Ԫ�� 
+
+// ��ʼ������ 
+List MakeEmpty(){
+	List L = (List)malloc(sizeof(struct LNode));
+	L = NULL;
+	return L;
+}
+
+//����� 
+int Length(List L){
+	List p = L;
+	int len=0;
+	while(p){  // �� p ���� 
+		p = p->Next;
+		len++;
+	}
+	return len;
+} 
+
+// ������� 
+List FindKth(int K,List L){
+	List p = L;
+	int i = 1;  //�� 1 ��ʼ 
+	while(p && i<K){
+		p = p->Next;
+		i++;
+	}
+	if(i == K)    // �ҵ��� 
+		return p;
+	else    // δ�ҵ� 
+		return NULL;
+} 
+
+// ��ֵ����  
+List Find(ElementType X,List L){
+	List p = L;
+	while(p && p->Data!=X)
+		p = p->Next;
+	// �ҵ��ˣ����� p
+	// δ�ҵ������� NULL����ʱ p ���� NULL 
+	return p;   
+} 
+
+/* ����
+1. �� s ָ��һ���µĽ��
+2. �� p ָ�������ĵ� i-1 ����� 
+3. s->Next = p->Next���� s ����һ�����ָ�� p ����һ����� 
+4. p->Next = s���� p ����һ����Ϊ s   */
+List Insert(ElementType X,int i,List L){
+	List p,s;
+	if(i == 1){     // �½������ڱ�ͷ 
+		s = (List)malloc(sizeof(struct LNode));
+		s->Data = X;
+		s->Next = L;
+		return s;     //����Ľ��Ϊͷ��� 
+	}
+	p = FindKth(i-1,L);   // �ҵ��� i-1 �����
+	if(!p){   // �� i-1 ����㲻���� 
+		printf("������");
+		return NULL;
+	}else{
+		s = (List)malloc(sizeof(struct LNode));
+		s->Data = X;
+		s->Next = p->Next;   //�� s ����һ�����ָ�� p ����һ����� 
+		p->Next = s;   // �� p ����һ����Ϊ s
+		return L;
+	}
+}
+
+/* ɾ��
+1. �� p ָ�������ĵ� i-1 ����� 
+2. �� s ָ��Ҫ��ɾ���ĵĵ� i �����
+3. p->Next = s->Next��p ָ��ָ�� s ����
+4. free(s)���ͷſռ� 
+*/
+List Delete(int i,List L){
+	List p,s;
+	if(i==1){   //���Ҫɾ��ͷ��� 
+		s = L;
+		if(L)   // ������� 
+			L = L->Next;
+		else
+			return NULL;
+		free(s);   // �ͷű�ɾ����� 
+		return L; 
+	}
+	p = FindKth(i-1,L);    // ���ҵ� i-1 �����
+	if(!p || !(p->Next)){     // �� i-1 ����� i ����㲻���� 
+		printf("������");
+		return NULL;
+	}else{
+		s = p->Next;    // s ָ��� i ����� 
+		p->Next = s->Next;  //������ɾ�� 
+		free(s);  // �ͷű�ɾ����� 
+		return L;
+	}
+}
+
+// �������Ԫ�� 
+void Print(List L){
+	List t;
+	int flag = 1;
+	printf("��ǰ����Ϊ��");
+	for(t = L;t;t =t->Next){
+		printf("%d  ",t->Data);
+		flag = 0;
+	}
+	if(flag)
+		printf("NULL");
+	printf("\n"); 
+}
+
+int main(){
+	L = MakeEmpty();
+	Print(L);
+	L = Insert(11,1,L);
+	L = Insert(25,1,L);
+	L = Insert(33,2,L);
+	L = Insert(77,3,L);
+	Print(L);
+	printf("��ǰ��������Ϊ��%d\n",Length(L));
+	printf("��ʱ�����еڶ�������ֵ�ǣ�%d\n",FindKth(2,L)->Data);
+	printf("����22�Ƿ��ڸ������У�");
+	if(Find(22,L))
+		printf("�ǣ�\n");
+	else
+		printf("��\n");
+	printf("����33�Ƿ��ڸ������У�");
+	if(Find(33,L))
+		printf("�ǣ�\n");
+	else
+		printf("��\n");
+	L = Delete(1,L);
+	L = Delete(3,L);
+	printf("----------ɾ����-----\n"); 
+	Print(L);
+	return 0;
+} 
diff --git a/上课Demo/3.链表存储的线性表.exe b/上课Demo/3.链表存储的线性表.exe
new file mode 100644
index 0000000..ccc23db
Binary files /dev/null and b/上课Demo/3.链表存储的线性表.exe differ
diff --git a/上课Demo/4.栈的顺序存储实现.c b/上课Demo/4.栈的顺序存储实现.c
new file mode 100644
index 0000000..64952e1
--- /dev/null
+++ b/上课Demo/4.栈的顺序存储实现.c
@@ -0,0 +1,79 @@
+#include<stdio.h>
+#include<malloc.h> 
+#define MaxSize 100   // ��ջԪ�ص������� 
+typedef int ElementType; // ElementType ��ʱ����Ϊ int ���� 
+typedef struct SNode *Stack;
+struct SNode{
+	ElementType Data[MaxSize];   // �洢��ջԪ��
+	int Top;  // ��¼ջ��Ԫ���±� 
+}; 
+
+Stack CreateStack();  // ��ʼ����ջ 
+int IsFull(Stack S); // �ж϶�ջ�Ƿ����� 
+int IsEmpty(Stack S);   // �ж϶�ջ�Ƿ�Ϊ�� 
+void Push(Stack S,ElementType item);   // ��ջ 
+ElementType Pop(Stack S);   // ��ջ 
+
+// ��ʼ����ջ 
+Stack CreateStack(){
+	Stack S;
+	S = (Stack)malloc(sizeof(struct SNode));
+	S->Top = -1;
+	return S;
+} 
+
+// �Ƿ����� 
+int IsFull(Stack S){
+	return (S->Top == MaxSize-1);
+}
+
+// �Ƿ�Ϊ�� 
+int IsEmpty(Stack S){
+	return (S->Top == -1); 
+} 
+
+// ��ջ 
+void Push(Stack S,ElementType item){
+	if(IsFull(S)){   // Top �� 0 ��ʼ 
+		printf("��ջ��");
+		return;
+	}else{
+		S->Top++;   // ջ��Ԫ�ؼ�һ 
+		S->Data[S->Top] = item;   // �Ž����� 
+		return;
+	}
+}
+
+// ��ջ
+ElementType Pop(Stack S){
+	if(IsEmpty(S)){
+		printf("��ջ��");
+		return;
+	}else{
+		ElementType val = S->Data[S->Top];  //ȡ������ 
+		S->Top--;  // ջ��Ԫ�ؼ�һ 
+		return val;
+	}
+}
+int main(){
+	Stack S;
+	S = CreateStack();
+	printf("5��ջ\n");
+	Push(S,5);
+	printf("7��ջ\n");
+	Push(S,7);
+	printf("66��ջ\n");
+	Push(S,66);
+	printf("%d��ջ\n",Pop(S));
+	printf("%d��ջ\n",Pop(S));
+	return 0;
+}
+
+
+
+
+
+
+
+
+
diff --git a/上课Demo/4.栈的顺序存储实现.exe b/上课Demo/4.栈的顺序存储实现.exe
new file mode 100644
index 0000000..49714de
Binary files /dev/null and b/上课Demo/4.栈的顺序存储实现.exe differ
diff --git a/上课Demo/5.栈的链表存储实现.c b/上课Demo/5.栈的链表存储实现.c
new file mode 100644
index 0000000..514b0dd
--- /dev/null
+++ b/上课Demo/5.栈的链表存储实现.c
@@ -0,0 +1,68 @@
+#include<stdio.h>
+#include<malloc.h>
+typedef int ElementType;
+typedef struct SNode *Stack;
+struct SNode{
+	ElementType Data;
+	Stack Next;
+};
+
+
+Stack CreateStack();  // ��ʼ����ջ 
+int IsEmpty(Stack S);  // �ж���ջ�Ƿ�Ϊ�� 
+void Push(Stack S,ElementType item);  // ��ջ 
+ElementType Pop(Stack S);  // ��ջ
+ 
+
+// ��ʼ�� 
+Stack CreateStack(){
+	Stack S;
+	S = (Stack)malloc(sizeof(struct SNode));
+	S->Next = NULL;
+	return S;
+}
+
+// �ж��Ƿ�Ϊ�� 
+int IsEmpty(Stack S){
+	return (S->Next == NULL);
+}
+
+// ��ջ
+void Push(Stack S,ElementType item){
+	Stack tmp;
+	tmp = (Stack)malloc(sizeof(struct SNode));
+	tmp->Data = item;
+	// ��ջջ��Ԫ��������ͷ��㣬����ջ��������ջ��Ԫ�غ��� 
+	tmp->Next = S->Next;   
+	S->Next = tmp;
+} 
+
+// ��ջ
+ElementType Pop(Stack S){
+	Stack First;
+	ElementType TopVal;
+	if(IsEmpty(S)){
+		printf("��ջ��");
+		return;
+	}else{
+		First = S->Next;   // ��ջ��һ��Ԫ����ջ��Ԫ�غ��� 
+		S->Next = First->Next;  //�ѵ�һ��Ԫ�ش���ջɾ�� 
+		TopVal = First->Data;   // ȡ����ɾ������ֵ 
+		free(First);  // �ͷſռ� 
+		return TopVal;
+	}
+} 
+
+int main(){
+	Stack S;
+	S = CreateStack();
+	printf("5��ջ\n");
+	Push(S,5);
+	printf("7��ջ\n");
+	Push(S,7);
+	printf("66��ջ\n");
+	Push(S,66);
+	printf("%d��ջ\n",Pop(S));
+	printf("%d��ջ\n",Pop(S));
+	return 0;
+} 
diff --git a/上课Demo/5.栈的链表存储实现.exe b/上课Demo/5.栈的链表存储实现.exe
new file mode 100644
index 0000000..f8db437
Binary files /dev/null and b/上课Demo/5.栈的链表存储实现.exe differ
diff --git a/上课Demo/6.循环队列的顺序存储实现.c b/上课Demo/6.循环队列的顺序存储实现.c
new file mode 100644
index 0000000..ecee182
--- /dev/null
+++ b/上课Demo/6.循环队列的顺序存储实现.c
@@ -0,0 +1,75 @@
+#include<stdio.h>
+#include<malloc.h>
+#define MaxSize 100
+typedef int ElementType;
+typedef struct QNode *Queue;
+struct QNode{
+	ElementType Data[MaxSize];
+	int front;   // ��¼��ͷ 
+	int rear;    // ��¼��β 
+};
+
+Queue CreateQueue();  // ��ʼ������ 
+void AddQ(Queue Q,ElementType item);  //  ���
+int IsFull(Queue Q); // �ж϶����Ƿ����� 
+ElementType DeleteQ(Queue Q);  // ���� 
+int IsEmpty(Queue Q); // �ж϶����Ƿ�Ϊ�� 
+
+// ��ʼ�� 
+Queue CreateQueue(){
+	Queue Q;
+	Q = (Queue)malloc(sizeof(struct QNode));
+	Q->front = -1;
+	Q->rear = -1;
+	return Q;
+} 
+
+// �ж϶����Ƿ�����
+int IsFull(Queue Q){
+ 	return ((Q->rear+1) % MaxSize == Q->front);
+}
+
+// ��� 
+void AddQ(Queue Q,ElementType item){
+	if(IsFull(Q)){
+		printf("������");
+		return;
+	}else{ 
+		Q->rear = (Q->rear+1) % MaxSize;
+		Q->Data[Q->rear] = item; 
+	}
+}
+
+//�ж϶����Ƿ�Ϊ��
+int IsEmpty(Queue Q){
+	return (Q->front == Q->rear);
+}
+ 
+// ����
+ElementType DeleteQ(Queue Q){
+	if(IsEmpty(Q)){
+		printf("���п�");
+		return 0;
+	}else{
+		Q->front = (Q->front+1) % MaxSize;
+		return Q->Data[Q->front];
+	}
+} 
+
+int main(){
+	Queue Q;
+	Q = CreateQueue();
+	AddQ(Q,3);
+	printf("3���\n");
+	AddQ(Q,5);
+	printf("5���\n");
+	AddQ(Q,11);
+	printf("11���\n");
+	printf("%d����\n",DeleteQ(Q));
+	printf("%d����\n",DeleteQ(Q));
+	return 0;
+} 
+
+
+
+
diff --git a/上课Demo/6.循环队列的顺序存储实现.exe b/上课Demo/6.循环队列的顺序存储实现.exe
new file mode 100644
index 0000000..17fe022
Binary files /dev/null and b/上课Demo/6.循环队列的顺序存储实现.exe differ
diff --git a/上课Demo/7.队列的链式存储实现.c b/上课Demo/7.队列的链式存储实现.c
new file mode 100644
index 0000000..ab51396
--- /dev/null
+++ b/上课Demo/7.队列的链式存储实现.c
@@ -0,0 +1,97 @@
+#include<stdio.h>
+#include<malloc.h>
+typedef int ElementType;
+typedef struct QNode *Queue;
+struct Node{
+	ElementType Data;
+	struct Node *Next;
+};
+struct QNode{
+	struct Node *rear;    // ָ���β��� 
+	struct Node *front;   // ָ���ͷ��� 
+};
+
+Queue CreateQueue();  // ��ʼ������ 
+void AddQ(Queue Q,ElementType item);  //  ���
+ElementType DeleteQ(Queue Q);  // ���� 
+int IsEmpty(Queue Q); // �ж϶����Ƿ�Ϊ�� 
+
+// ��ʼ�� 
+Queue CreateQueue(){
+	Queue Q;
+	Q = (Queue)malloc(sizeof(struct QNode));
+	Q->front = NULL;
+	Q->rear = NULL;
+	return Q;
+}
+
+// �Ƿ�Ϊ�� 
+int IsEmpty(Queue Q){
+	return (Q->front == NULL);
+}
+
+// ���
+void AddQ(Queue Q,ElementType item){
+	struct Node *node;
+	node = (struct Node *)malloc(sizeof(struct Node));
+	node->Data = item;
+	node->Next = NULL;
+	if(Q->rear==NULL){  //��ʱ���п� 
+		Q->rear = node;
+		Q->front = node;
+	}else{ //���� 
+		Q->rear->Next = node;  // �������� 
+		Q->rear = node;   // rear ��Ȼ������� 
+	}
+} 
+
+// ����
+ElementType DeleteQ(Queue Q){
+	struct Node *FrontCell;
+	ElementType FrontElem;
+	if(IsEmpty(Q)){
+		printf("���п�");
+		return 0;
+	}
+	FrontCell = Q->front;
+	if(Q->front == Q->rear){ // ������ֻ��һ��Ԫ�� 
+		Q->front = Q->rear = NULL; 
+	}else{
+		Q->front = Q->front->Next;
+	}
+	FrontElem = FrontCell->Data;
+	free(FrontCell);
+	return FrontElem;
+}
+
+int main(){
+	Queue Q;
+	Q = CreateQueue();
+	printf("���5\n"); 
+	AddQ(Q,5);
+	printf("���4\n"); 
+	AddQ(Q,4);
+	printf("���4\n"); 
+	AddQ(Q,3);
+	printf("����%d\n",DeleteQ(Q));
+	printf("����%d\n",DeleteQ(Q));
+	printf("����%d\n",DeleteQ(Q));
+	printf("%d\n",DeleteQ(Q));
+	return 0;
+} 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/上课Demo/7.队列的链式存储实现.exe b/上课Demo/7.队列的链式存储实现.exe
new file mode 100644
index 0000000..2c805d2
Binary files /dev/null and b/上课Demo/7.队列的链式存储实现.exe differ
diff --git a/上课Demo/8.树的链表存储实现.cpp b/上课Demo/8.树的链表存储实现.cpp
new file mode 100644
index 0000000..27484b7
--- /dev/null
+++ b/上课Demo/8.树的链表存储实现.cpp
@@ -0,0 +1,265 @@
+#include<stdio.h>
+#include<malloc.h> 
+#include<vector> 
+#include<queue>
+#include<algorithm>
+typedef struct TreeNode *BinTree;
+struct TreeNode{
+	int Data;  // ��ֵ 
+	BinTree Left;    // ����ӽ�� 
+	BinTree Right;   // �Ҷ��ӽ�� 
+};
+BinTree CreatBinTree();   // ����һ��������
+bool IsEmpty(BinTree BT);  // �ж��� BT �Ƿ�Ϊ�� 
+void PreOrderTraversal(BinTree BT);   // ���������������
+void InOrderTraversal(BinTree BT);    // �������������� 
+void PostOrderTraversal(BinTree BT);  // ������������Ҹ� 
+using namespace std;
+typedef struct SNode *Stack;
+struct SNode{
+	BinTree Data;
+	Stack Next;
+};
+
+
+Stack CreateStack();  // ��ʼ����ջ 
+int IsEmpty(Stack S);  // �ж���ջ�Ƿ�Ϊ�� 
+void Push(Stack S,BinTree item);  // ��ջ 
+BinTree Pop(Stack S);  // ��ջ
+ 
+
+// ��ʼ�� 
+Stack CreateStack(){
+	Stack S;
+	S = (Stack)malloc(sizeof(struct SNode));
+	S->Next = NULL;
+	return S;
+}
+
+// �ж��Ƿ�Ϊ�� 
+int IsEmpty(Stack S){
+	return (S->Next == NULL);
+}
+
+// ��ջ
+void Push(Stack S,BinTree item){
+	Stack tmp;
+	tmp = (Stack)malloc(sizeof(struct SNode));
+	tmp->Data = item;
+	// ��ջջ��Ԫ��������ͷ��㣬����ջ��������ջ��Ԫ�غ��� 
+	tmp->Next = S->Next;   
+	S->Next = tmp;
+} 
+
+// ��ջ
+BinTree Pop(Stack S){
+	Stack First;
+	BinTree TopVal;
+	if(IsEmpty(S)){
+		printf("��ջ��");
+		return 0;
+	}else{
+		First = S->Next;   // ��ջ��һ��Ԫ����ջ��Ԫ�غ��� 
+		S->Next = First->Next;  //�ѵ�һ��Ԫ�ش���ջɾ�� 
+		TopVal = First->Data;   // ȡ����ɾ������ֵ 
+		free(First);  // �ͷſռ� 
+		return TopVal;
+	}
+} 
+
+BinTree Insert(int Data){
+	BinTree BT;
+	BT =  (BinTree)malloc(sizeof(struct TreeNode));
+	BT->Data = Data;
+	BT->Left = NULL;
+	BT->Right = NULL;
+	return BT;
+}
+
+// ��ʼ�������� 
+BinTree CreatBinTree(){
+	BinTree BT;
+	BT =  (BinTree)malloc(sizeof(struct TreeNode));
+	BT->Data = 1;
+	BT->Left = Insert(2);
+	BT->Right = Insert(3);
+	BT->Left->Left = Insert(4);
+	BT->Left->Right = Insert(6);
+	BT->Left->Right->Left = Insert(5);
+	BT->Right->Left = Insert(7);
+	BT->Right->Right = Insert(9);
+	BT->Right->Left->Right = Insert(8);
+	return BT;
+}
+
+
+// �ж����Ƿ�Ϊ��
+/*bool  IsEmpty(BinTree BT){
+}*/
+
+// ����
+/*void  PreOrderTraversal(BinTree BT){
+	if(BT){
+		printf("%d",BT->Data);  // ��ӡ�� 
+		PreOrderTraversal(BT->Left);  // ���������� 
+		PreOrderTraversal(BT->Right);  // ���������� 
+	}
+} */
+
+// ����ǵݹ� 
+void PreOrderTraversal(BinTree BT){
+	BinTree T = BT;
+	Stack S = CreateStack();  // ��������ʼ����ջ S
+	while(T || !IsEmpty(S)){  // ������Ϊ�ջ��ջ���� 
+		while(T){     
+			Push(S,T);    // ѹջ����һ�������ý�� 
+			printf("%d",T->Data);  // ���ʽ��
+			T = T->Left;   // ���������� 
+		}
+		if(!IsEmpty(S)){  // ����ջ���� 
+			T = Pop(S);    // ��ջ���ڶ��������ý�� 
+			T = T->Right;  // �����ҽ�� 
+		}
+	} 
+} 
+
+// ����ݹ� 
+/*void InOrderTraversal(BinTree BT){
+	if(BT){
+		InOrderTraversal(BT->Left);  // ���������� 
+		printf("%d",BT->Data);  // ��ӡ�� 
+		InOrderTraversal(BT->Right);  // ���������� 
+	} 
+} */
+
+// ����ǵݹ�
+void InOrderTraversal(BinTree BT){
+	BinTree T = BT;
+	Stack S = CreateStack();  // ��������ʼ����ջ S
+	while(T || !IsEmpty(S)){  // ������Ϊ�ջ��ջ���� 
+		while(T){     
+			Push(S,T);    // ѹջ
+			T = T->Left;   // ���������� 
+		}
+		if(!IsEmpty(S)){  // ����ջ���� 
+			T = Pop(S);    // ��ջ
+			printf("%d",T->Data);  // ���ʽ��
+			T = T->Right;  // �����ҽ�� 
+		}
+	} 
+} 
+
+// ����
+/*void PostOrderTraversal(BinTree BT){
+	if(BT){
+		PostOrderTraversal(BT->Left);  // ���������� 
+		PostOrderTraversal(BT->Right);  // ���������� 
+		printf("%d",BT->Data);  // ��ӡ�� 
+	} 
+} */ 
+
+// ������� 
+void PostOrderTraversal(BinTree BT){
+	BinTree T = BT;
+	Stack S = CreateStack();  // ��������ʼ����ջ S
+	vector<BinTree> v;
+	Push(S,T);
+	while(!IsEmpty(S)){  // ������Ϊ�ջ��ջ���� 
+		T = Pop(S);
+		v.push_back(T);
+		if(T->Left)
+			Push(S,T->Left);
+		if(T->Right)
+			Push(S,T->Right);
+	}
+	reverse(v.begin(),v.end());  // ��ת 
+	for(int i=0;i<v.size();i++)
+		printf("%d",v[i]->Data);
+} 
+
+// ����
+void LevelOrderTraversal(BinTree BT){
+	queue<BinTree> q;
+	BinTree T;
+	if(!BT)
+		return;
+	q.push(BT);  // BT ��� 
+	while(!q.empty()){
+		T = q.front();  // ���ʶ���Ԫ�� 
+		q.pop();  // ����
+		printf("%d",T->Data);
+		if(T->Left)
+			q.push(T->Left);
+	 	if(T->Right)
+	 		q.push(T->Right);
+	}
+}
+// ���Ҷ�ӽ��
+void  FindLeaves(BinTree BT){
+	if(BT){
+		if( !BT->Left && !BT->Right)
+			printf("%d",BT->Data);  // ��ӡҶ�ӽ��
+		FindLeaves(BT->Left);  // ���������� 
+		FindLeaves(BT->Right);  // ���������� 
+	}
+} 
+
+// �����߶�
+int  GetHeight(BinTree BT){
+	int hl,hr,maxh;
+	if(BT){
+		hl = GetHeight(BT->Left);  // ���������߶� 
+		hr = GetHeight(BT->Right);  // ���������߶� 
+		maxh = (hl>hr)?hl:hr;
+		return maxh+1;  // ��ǰ���߶�Ϊ�����������ĸ߶�+1 
+	}else
+		return 0;
+} 
+int main(){
+	BinTree BT,ST;
+	BT = CreatBinTree();
+	printf("���������");
+	PreOrderTraversal(BT);
+	printf("\n���������");
+	InOrderTraversal(BT);
+	printf("\n���������");
+	PostOrderTraversal(BT);
+	printf("\n������");
+	LevelOrderTraversal(BT);
+	printf("\n���Ҷ�ӽ��:"); 
+	FindLeaves(BT);
+	printf("\n������ĸ߶ȣ�%d",GetHeight(BT));
+	return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/上课Demo/8.树的链表存储实现.exe b/上课Demo/8.树的链表存储实现.exe
new file mode 100644
index 0000000..4b78974
Binary files /dev/null and b/上课Demo/8.树的链表存储实现.exe differ
diff --git a/上课Demo/9.二叉搜索树的操作.cpp b/上课Demo/9.二叉搜索树的操作.cpp
new file mode 100644
index 0000000..35e0f85
--- /dev/null
+++ b/上课Demo/9.二叉搜索树的操作.cpp
@@ -0,0 +1,150 @@
+#include<iostream>
+#include<malloc.h>
+using namespace std;
+typedef int ElementType;
+typedef struct TreeNode *BinTree;
+struct TreeNode{
+	ElementType Data;
+	BinTree Left;
+	BinTree Right;
+};
+
+// ���ҵݹ�ʵ�� 
+BinTree Find(ElementType X,BinTree BST){
+	if(!BST)  // ��������Ϊ�գ����� NULL 
+		return NULL; 
+	if(X < BST->Data) // �ȸ����С��ȥ���������� 
+		return Find(X,BST->Left); 
+	else if(BST->Data < X)  // �ȸ�����ȥ���������� 
+		return Find(X,BST->Right);
+	else if(BST->Data == X) // �ҵ��� 
+		return BST;
+}
+
+// ���ҷǵݹ�ʵ��
+BinTree IterFind(ElementType X,BinTree BST){
+	while(BST){
+		if(X < BST->Data)
+			BST = BST->Left;
+		else if(BST->Data < X)  // �ȸ�����ȥ���������� 
+			BST = BST->Right;
+		else if(BST->Data == X) // �ҵ��� 
+			return BST;
+	}
+	return NULL;
+} 
+
+// ������Сֵ�ĵݹ�ʵ��
+BinTree FindMin(BinTree BST){
+	if(!BST)    // ���Ϊ���ˣ����� NULL 
+		return NULL;  
+	else if(BST->Left)   // �������������������֧�������� 
+		return FindMin(BST->Left);
+	else  // �ҵ��� 
+		return BST;
+} 
+
+// �������ֵ�ķǵݹ�ʵ��
+BinTree FindMax(BinTree BST){
+	if(BST)  // ������� 
+		while(BST->Right)   // ֻҪ������������ 
+			BST = BST->Right;
+	return BST;
+} 
+
+// ����
+BinTree Insert(ElementType X,BinTree BST){
+	if(!BST){  // ���Ϊ�գ���ʼ���ý�� 
+		BST = (BinTree)malloc(sizeof(struct TreeNode));
+		BST->Data = X;
+		BST->Left = NULL;
+		BST->Right = NULL;
+	}else{ // ���� 
+		if(X < BST->Data)  // ������������ 
+			BST->Left = Insert(X,BST->Left);
+		else if(BST->Data < X)  // ����󣬹����ұ� 
+			BST->Right = Insert(X,BST->Right);
+		// �����ȣ�ʲô�������� 
+	}
+	return BST;
+} 
+
+// ɾ��
+BinTree Delete(ElementType X,BinTree BST){
+	BinTree tmp;
+	if(!BST)
+		cout<<"Ҫɾ����Ԫ��δ�ҵ�";
+	else if(X < BST->Data)   // X �ȵ�ǰ���ֵС������������������ɾ�� 
+		BST->Left = Delete(X,BST->Left);
+	else if(BST->Data < X)   // x �ȵ�ǰ���ֵ������������������ɾ�� 
+		BST->Right = Delete(X,BST->Right);
+	else{  //  �ҵ���ɾ����� 
+		if(BST->Left && BST->Right){  // ��ɾ������������ӽ�� 
+			tmp = FindMin(BST->Right);   // �ҵ���������ֵ��С��
+			BST->Data = tmp->Data;     // ���ҵ���ֵ���ǵ�ǰ��� 
+			BST->Right = Delete(tmp->Data,BST->Right);    // ��ǰ���ҵ�����������Сֵ���ɾ�� 
+		}else{  // ��ɾ�����ֻ��һ�����ӽ���û�к��ӽ�� 
+			tmp = BST;
+			if(!BST->Left && !BST->Right)  // û�к��ӽ�� 
+				BST = NULL;
+			else if(BST->Left && !BST->Right)  // ֻ�����ӽ�� 
+				BST = BST->Left;
+			else if(!BST->Left && BST->Right)  // ֻ���Һ��ӽ�� 
+				BST = BST->Right;
+		}
+		free(tmp);
+	}
+	return BST;
+} 
+
+// ������� 
+void  InOrderTraversal(BinTree BT){
+	if(BT){
+		InOrderTraversal(BT->Left);  // ���������� 
+		cout<<BT->Data;  // ��ӡ�� 
+		InOrderTraversal(BT->Right);  // ���������� 
+	}
+}
+int main(){
+	BinTree BST = NULL;
+	BST = Insert(5,BST); 
+	BST = Insert(7,BST); 
+	BST = Insert(3,BST); 
+	BST = Insert(1,BST); 
+	BST = Insert(2,BST); 
+	BST = Insert(4,BST); 
+	BST = Insert(6,BST); 
+	BST = Insert(8,BST); 
+	BST = Insert(9,BST); 
+	/*
+			    5
+			   /\
+			  3  7
+             /\	 /\
+            1 4 6  8
+			\      \
+			 2      9
+	*/
+	cout<<"��������Ľ���ǣ�"; 
+	InOrderTraversal(BST);
+	cout<<endl;
+	cout<<"������Сֵ�ǣ�"<<FindMin(BST)->Data<<endl;
+	cout<<"�������ֵ�ǣ�"<<FindMax(BST)->Data<<endl; 
+	cout<<"����ֵΪ3�Ľ�����������ֵΪ��"<<Find(3,BST)->Left->Data<<endl;
+	cout<<"����ֵΪ7�Ľ�����������ֵΪ��"<<IterFind(7,BST)->Right->Data<<endl;
+	cout<<"ɾ��ֵΪ5�Ľ��"<<endl;
+	Delete(5,BST);
+	/*
+			    6
+			   /\
+			  3  7
+             /\	  \
+            1 4    8
+			\      \
+			 2      9
+	*/
+	cout<<"��������Ľ���ǣ�"; 
+	InOrderTraversal(BST);
+	cout<<endl;
+	return 0;
+}
diff --git a/上课Demo/9.二叉搜索树的操作.exe b/上课Demo/9.二叉搜索树的操作.exe
new file mode 100644
index 0000000..f8929dc
Binary files /dev/null and b/上课Demo/9.二叉搜索树的操作.exe differ
diff --git a/编程作业/1.最大子列和问题.cpp b/编程作业/1.最大子列和问题.cpp
new file mode 100644
index 0000000..892839a
--- /dev/null
+++ b/编程作业/1.最大子列和问题.cpp
@@ -0,0 +1,118 @@
+#include<iostream>
+using namespace std;
+/* ����һ��ȷ�����еĿ�ͷ�ͽ�β���ٱ����ۼӣ�ʱ�临�Ӷ� O(n^3)*/
+int MaxSubseqSum1(int n,int a[]){
+	int max = 0;
+	for(int i=0;i<n;i++){
+		for(int k=0;k<i;k++){		
+			int tmpSum = 0;
+			for(int j=k;j<=i;j++){
+				tmpSum+=a[j]; 
+			}
+			if(max < tmpSum)
+				max = tmpSum;
+		}
+	}
+	return max;
+}
+/* ��������ȷ�����еĽ�β�������ȥ����ǰ������ʱ�临�Ӷ� O(n^2)*/ 
+int MaxSubseqSum2(int n,int a[]){
+	int sum[100000+5];
+	int max = 0;
+	sum[0]=a[0];
+	for(int i=1;i<n;i++)
+		sum[i]=sum[i-1]+a[i];
+	for(int i=0;i<n;i++){
+		int tmpSum = sum[i];
+		for(int j=0;j<=i;j++){
+			if(max < tmpSum)
+				max = tmpSum;
+			tmpSum-=a[j]; 
+		}
+	}
+	return max;
+}
+/* ��������ȷ�����е��ײ�������ۼӣ�ʱ�临�Ӷ� O(n^2)*/ 
+int MaxSubseqSum3(int n,int a[]){
+	int max = 0;
+	for(int i=0;i<n;i++){
+		int tmpSum = 0;
+		for(int j=i;j<n;j++){
+			tmpSum+=a[j];
+			if(max < tmpSum)
+				max = tmpSum;
+		}
+	}
+	return max;
+}
+/* ��������ֱ���ۼӣ�����ۼӵ���ǰ�ĺ�Ϊ�������õ�ǰֵ��0��ʱ�临�Ӷ�Ϊ O(n)*/ 
+int MaxSubseqSum5(int n,int a[]){
+	int max = 0;
+	int tmpSum=0;
+	for(int i=0;i<n;i++){
+		tmpSum+=a[i];
+		if(tmpSum<0){
+			tmpSum=0;
+		}else if(max < tmpSum){
+			max = tmpSum;
+		}
+	}
+	return max;
+}
+
+/* �����ģ��ݹ�ֳ����ݣ��ֱ���ÿ���ָ�����е����ͣ�ʱ�临�Ӷ�Ϊ O(n*logn)*/
+/* �������������ֵ*/
+int Max3(int A,int B,int C){
+	return (A>B)?((A>C)?A:C):((B>C)?B:C);
+}
+/* �ֽ�ɸ�С��ģ���*/
+int DivideAndConquer(int a[],int left,int right){
+	
+	/*�ݹ��������������ֻ��һ������*/
+	if(left == right){
+		if(0 < a[left])
+			return a[left];
+		return 0;
+	}
+	
+	/* �ֱ��ҵ�����������к�*/ 
+	int center = (left+right)/2; 
+	int MaxLeftSum = DivideAndConquer(a,left,center);
+	int MaxRightSum = DivideAndConquer(a,center+1,right);
+	
+	/* �ٷֱ������ҿ��������к�*/
+	int MaxLeftBorderSum = 0;
+	int LeftBorderSum = 0;
+	for(int i=center;i>=left;i--){
+		LeftBorderSum += a[i];
+		if(MaxLeftBorderSum < LeftBorderSum)
+			MaxLeftBorderSum = LeftBorderSum;	
+	}
+	int MaXRightBorderSum = 0;
+	int RightBorderSum = 0;
+	for(int i=center+1;i<=right;i++){
+		RightBorderSum += a[i];
+		if(MaXRightBorderSum < RightBorderSum)
+			MaXRightBorderSum = RightBorderSum;
+	}
+	
+	/*��󷵻طֽ�����������кͣ��ұ�������кͣ��Ϳ��������к�������������*/
+	return Max3(MaxLeftSum,MaxRightSum,MaXRightBorderSum+MaxLeftBorderSum);
+}
+int MaxSubseqSum4(int n,int a[]){
+	return DivideAndConquer(a,0,n-1);
+}
+int main(){
+	int n;
+	int a[100000+5];
+	cin>>n;
+	for(int i=0;i<n;i++)
+		cin>>a[i];
+	cout<<MaxSubseqSum1(n,a);
+	cout<<MaxSubseqSum2(n,a);
+	cout<<MaxSubseqSum3(n,a);
+	cout<<MaxSubseqSum4(n,a);
+	cout<<MaxSubseqSum5(n,a);
+	return 0;
+} 
+
diff --git a/编程作业/1.最大子列和问题.exe b/编程作业/1.最大子列和问题.exe
new file mode 100644
index 0000000..11c75a2
Binary files /dev/null and b/编程作业/1.最大子列和问题.exe differ
diff --git a/编程作业/10.是否为同一棵搜索树.cpp b/编程作业/10.是否为同一棵搜索树.cpp
new file mode 100644
index 0000000..44d1d21
--- /dev/null
+++ b/编程作业/10.是否为同一棵搜索树.cpp
@@ -0,0 +1,75 @@
+#include<iostream>
+#include<string>
+#include<malloc.h>
+using namespace std;
+typedef struct TreeNode *BinTree;
+struct TreeNode{
+	int data;  // ��ֵ
+	BinTree left;  // ������
+	BinTree right; // ������ 
+};
+
+// ����һ����� 
+BinTree Insert(int x,BinTree BST){
+	if(!BST){   // ������Ϊ�գ����������� 
+		BST = (BinTree)malloc(sizeof(struct TreeNode));
+		BST->data = x;
+		BST->left = NULL;
+		BST->right = NULL;
+	}else{  //  �����㲻Ϊ�� 
+		if(x < BST->data)  // ��� x �ȵ�ǰ����ֵС 
+			BST->left = Insert(x,BST->left);  // �ݹ鵽���������� 
+		else if(BST->data < x)  // ��� x �ȵ�ǰ����ֵ�� 
+			BST->right = Insert(x,BST->right);   // �ݹ鵽����������
+		// �����ȣ�ʲôҲ���� 
+	}
+	return BST;
+}
+
+// ǰ����� 
+void  PreOrderTraversal(BinTree BST,string &s){
+	if(BST){
+		 
+		PreOrderTraversal(BST->left,s);  // ���������� 
+		s += BST->data+'0';  // �����ֵ������ַ���
+		PreOrderTraversal(BST->right,s);  // ���������� 
+	}
+}
+
+int main(){
+	int n,l;
+	int tmp;
+	cin>>n>>l;
+	while(n){  // �� n ��Ϊ����ѭ�� 
+		BinTree InitBST = NULL;
+		string Initstr;
+		// ÿ�������� n l �ij�ʼ�������� 
+		for(int i=0;i<n;i++){
+			cin>>tmp;
+			InitBST = Insert(tmp,InitBST);
+		}
+		// Initstr ��¼��ʼ���������γɵ��������������� 
+		// ˼��Ϊʲô���������¼�� 
+		PreOrderTraversal(InitBST,Initstr);
+		
+		// �� l �� 
+		for(int i=0;i<l;i++){
+			BinTree BST = NULL;
+			string str;
+			for(int j=0;j<n;j++){
+				cin>>tmp;
+				BST = Insert(tmp,BST);
+			}
+			// ÿ�еIJ������в���һ�������� str ��¼���������� 
+			PreOrderTraversal(BST,str);
+			
+			// �ٽ���ʼ���к�ÿ�β������в�����ֵ���жԱ� 
+			if(str == Initstr)
+				cout<<"Yes"<<endl;
+			else
+				cout<<"No"<<endl;
+		}
+		cin>>n>>l;
+	}
+	return 0;
+}
diff --git a/编程作业/10.是否为同一棵搜索树.exe b/编程作业/10.是否为同一棵搜索树.exe
new file mode 100644
index 0000000..cd3a65d
Binary files /dev/null and b/编程作业/10.是否为同一棵搜索树.exe differ
diff --git a/编程作业/11.Tree Traversals Again.cpp b/编程作业/11.Tree Traversals Again.cpp
new file mode 100644
index 0000000..99aeeaa
--- /dev/null
+++ b/编程作业/11.Tree Traversals Again.cpp	
@@ -0,0 +1,79 @@
+#include<iostream>
+#include<stack>
+#include<string>
+#include<stdio.h>
+#include<malloc.h>
+using namespace std;
+typedef struct TreeNode *Tree;
+struct TreeNode{
+	string data;
+	Tree left;   // ������ 
+	Tree right;  // ������ 
+};
+// ��ʼ��һ������� 
+Tree create(){
+	Tree T;
+	T = (Tree)malloc(sizeof(struct TreeNode));
+	T->left = NULL;
+	T->right = NULL;
+	return T; 
+}
+
+// ���������������������� 
+Tree restore(Tree T){
+	int n;
+	string str;
+	stack<Tree> s;
+	Tree node = T;
+	bool flag = false;
+	string value;
+	scanf("%d\n",&n);
+	// ���ڵ㸳ֵ 
+	getline(cin,str);
+	value = str.substr(5);  // �ӵ������ʼ��ȡ
+	node->data = value;
+	// �������ջ 
+	s.push(node); 
+	for(int i=1;i<2*n;i++){
+		getline(cin,str);
+		if(str=="Pop"){// ����� pop ����
+			node = s.top();
+			s.pop(); 
+		}else{   // push
+			value = str.substr(5);  // �ӵ������ʼ��ȡ
+			Tree tmp = create();
+			tmp->data = value;
+			if(!node->left){// �������ӿգ��½���������� 
+				node->left = tmp;
+				node = node->left; 
+			}else if(!node->right){  // ����Ҷ��ӿգ��½������Ҷ��� 
+				node->right = tmp;
+				node = node->right;
+			}
+			s.push(tmp);
+		}
+	}
+	return T;
+}
+
+// ����ݹ����
+void bl(Tree T,bool &flag){
+	if(T){
+		bl(T->left,flag);
+		bl(T->right,flag);
+		if(!flag)
+			flag = true;
+		else
+			cout<<" ";
+		cout<<T->data;
+	}
+} 
+int main(){
+	Tree T;
+	bool flag = false;
+	string str;
+	T = create();
+	T = restore(T);
+	bl(T,flag);
+	return 0;
+} 
diff --git a/编程作业/11.Tree Traversals Again.exe b/编程作业/11.Tree Traversals Again.exe
new file mode 100644
index 0000000..e7a8f99
Binary files /dev/null and b/编程作业/11.Tree Traversals Again.exe differ
diff --git a/编程作业/12.Root of AVL Tree.cpp b/编程作业/12.Root of AVL Tree.cpp
new file mode 100644
index 0000000..1686420
--- /dev/null
+++ b/编程作业/12.Root of AVL Tree.cpp	
@@ -0,0 +1,137 @@
+#include<iostream>
+#include<malloc.h>
+typedef struct AVLNode *AVLTree;
+struct AVLNode{
+	int data;     // ��ֵ 
+	AVLTree left;  // ������ 
+	AVLTree right;  // ������ 
+	int height;  // ���� 
+};
+using namespace std;
+
+// �������ֵ 
+int Max(int a,int b){
+	return a>b?a:b;
+}
+
+// �������ߣ��������� -1 
+int getHeight(AVLTree A){
+	return A==NULL?-1:A->height;
+}
+
+// LL����
+// �� B ���������ڳ����Ҹ� A �����������ٽ� A �ҵ� B ����������ȥ 
+AVLTree LLRotation(AVLTree A){
+	/*
+			A	
+		   /
+		  B
+	     /
+	    C
+	*/
+	// ��ʱ���ڵ��� A 
+	AVLTree B = A->left;  // B Ϊ A ��������  
+	A->left = B->right;   // B ������������ A ���������� 
+	B->right = A;     //  A ���� B ���������� 
+	A->height = Max(getHeight(A->left),getHeight(A->right)) + 1;
+	B->height = Max(getHeight(B->left),A->height) + 1;
+	return B;  // ��ʱ B Ϊ������� 
+	/*
+		B
+	   / \
+	  C   A 
+	*/
+}
+
+// RR����
+AVLTree RRRotation(AVLTree A){
+	/*
+			A	
+		     \
+		      B
+	          \ 
+	           C
+	*/
+	// ��ʱ���ڵ��� A 
+	AVLTree B = A->right;
+	A->right = B->left;
+	B->left = A;
+	A->height = Max(getHeight(A->left),getHeight(A->right)) + 1;
+	B->height = Max(getHeight(B->left),A->height) + 1;
+	return B;  // ��ʱ B Ϊ������� 
+	/*
+		B
+	   / \
+	  A   C 
+	*/
+}
+
+// LR˫�� 
+AVLTree LRRotation(AVLTree A){
+	/*
+		A
+	   /
+	  B
+	   \
+	   C
+	*/
+	// �� RR ����
+	A->left = RRRotation(A->left);
+	/*
+	*/
+	// �� LL ���� 
+	return LLRotation(A);
+}
+
+// RL˫��
+AVLTree RLRotation(AVLTree A){
+	// �� LL ����
+	A->right = LLRotation(A->right);
+	// �� RR ���� 
+	return RRRotation(A); 
+}
+
+AVLTree Insert(AVLTree T,int x){
+	if(!T){  // ����ý��Ϊ�գ���ʼ����� 
+		T = (AVLTree)malloc(sizeof(struct AVLNode));
+		T->data = x;
+		T->left = NULL;
+		T->right = NULL;
+		T->height = 0;
+	}else{  // ����Ϊ�գ� 
+		if(x < T->data){  // ������ 
+			T->left = Insert(T->left,x);
+			if(getHeight(T->left)-getHeight(T->right)==2){  // ������������������߶Ȳ�Ϊ 2 
+				if(x < T->left->data)  // LL ���� 
+					T = LLRotation(T); 
+				else if(T->left->data < x)  // LR˫��
+					T = LRRotation(T); 
+			}
+		}else if(T->data < x){
+			T->right = Insert(T->right,x);
+			if(getHeight(T->right)-getHeight(T->left)==2){
+				if(x < T->right->data)  // RL ˫�� 
+					T = RLRotation(T); 
+				else if(T->right->data < x)  // RR����
+					T = RRRotation(T); 
+			}
+		}
+	}
+	//�������� 
+	T->height = Max(getHeight(T->left),getHeight(T->right)) + 1;
+	return T;
+} 
+
+
+int main(){
+	AVLTree T=NULL;
+	int n;
+	cin>>n;
+	for(int i=0;i<n;i++){
+		int tmp;
+		cin>>tmp;
+		T = Insert(T,tmp);
+	}
+	cout<<T->data;
+	return 0;
+}
diff --git a/编程作业/12.Root of AVL Tree.exe b/编程作业/12.Root of AVL Tree.exe
new file mode 100644
index 0000000..013252d
Binary files /dev/null and b/编程作业/12.Root of AVL Tree.exe differ
diff --git a/编程作业/13.Complete Binary Search Tree.cpp b/编程作业/13.Complete Binary Search Tree.cpp
new file mode 100644
index 0000000..b7b97a6
--- /dev/null
+++ b/编程作业/13.Complete Binary Search Tree.cpp	
@@ -0,0 +1,52 @@
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+#include<vector>
+#define MaxSize 2005
+using namespace std;
+int value[MaxSize];
+int BST[MaxSize];
+
+// ���� n �������������������� 
+int getLeftTreeSize(int n){
+	int h =0;   // ����ý�������������IJ��� 
+	int tmp = n+1;
+	while(tmp!=1){
+		tmp /=2;
+		h++;
+	}
+	int x = n-pow(2,h)+1;   // ������һ����Ҷ������ 
+	x = x<pow(2,h-1)?x:pow(2,h-1);   // ��Ҷ����������� 2^(h-1) 
+	int L = pow(2,h-1)-1+x;   // �ý�����������������ĸ��� 
+	return L;
+}
+
+// ��亯��
+void fill(int left,int right,int root){
+	int n = right - left + 1;  // ȷ����Χ����ֵ���� 
+ 	if(!n)
+ 		return;
+ 	int L = getLeftTreeSize(n);   // �ҵ�"ƫ����" 
+ 	BST[root] = value[left + L];    // ������ֵӦ���� ��߽�ֵ + ƫ���� 
+ 	int leftRoot = 2 * root + 1;   // ����ӽ��λ�ã����ڴ� 0 ��ʼ 
+ 	int rightRoot = leftRoot + 1;  // �Ҷ��ӽ��λ�� 
+ 	fill(left,left+L-1,leftRoot);  // �������ݹ� 
+ 	fill(left+L+1,right,rightRoot);   // �������ݹ� 
+}
+
+int main(){
+	int n;
+	cin>>n;
+	for(int i=0;i<n;i++){
+		cin>>value[i];
+	}
+	// ���������� 
+	sort(value,value+n);
+	fill(0,n-1,0);
+	for(int i=0;i<n;i++){
+		if(i)
+			cout<<" ";
+		cout<<BST[i];
+	}
+	return 0;
+} 
diff --git a/编程作业/13.Complete Binary Search Tree.exe b/编程作业/13.Complete Binary Search Tree.exe
new file mode 100644
index 0000000..8461aac
Binary files /dev/null and b/编程作业/13.Complete Binary Search Tree.exe differ
diff --git a/编程作业/14.二叉搜索树的操作集.cpp b/编程作业/14.二叉搜索树的操作集.cpp
new file mode 100644
index 0000000..925d29a
--- /dev/null
+++ b/编程作业/14.二叉搜索树的操作集.cpp
@@ -0,0 +1,150 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef int ElementType;
+typedef struct TNode *Position;
+typedef Position BinTree;
+struct TNode{
+    ElementType Data;
+    BinTree Left;
+    BinTree Right;
+};
+
+void PreorderTraversal( BinTree BT ); /* ����������ɲ���ʵ�֣�ϸ�ڲ��� */
+void InorderTraversal( BinTree BT );  /* ����������ɲ���ʵ�֣�ϸ�ڲ��� */
+
+BinTree Insert( BinTree BST, ElementType X );
+BinTree Delete( BinTree BST, ElementType X );
+Position Find( BinTree BST, ElementType X );
+Position FindMin( BinTree BST );
+Position FindMax( BinTree BST );
+
+
+int main()
+{
+    BinTree BST, MinP, MaxP, Tmp;
+    ElementType X;
+    int N, i;
+
+    BST = NULL;
+    scanf("%d", &N);
+    for ( i=0; i<N; i++ ) {
+        scanf("%d", &X);
+        BST = Insert(BST, X);
+    }
+    printf("Preorder:"); PreorderTraversal(BST); printf("\n");
+    MinP = FindMin(BST);
+    MaxP = FindMax(BST);
+    scanf("%d", &N);
+    for( i=0; i<N; i++ ) {
+        scanf("%d", &X);
+        Tmp = Find(BST, X);
+        if (Tmp == NULL) printf("%d is not found\n", X);
+        else {
+            printf("%d is found\n", Tmp->Data);
+            if (Tmp==MinP) printf("%d is the smallest key\n", Tmp->Data);
+            if (Tmp==MaxP) printf("%d is the largest key\n", Tmp->Data);
+        }
+    }
+    scanf("%d", &N);
+    for( i=0; i<N; i++ ) {
+        scanf("%d", &X);
+        BST = Delete(BST, X);
+    }
+    printf("Inorder:"); InorderTraversal(BST); printf("\n");
+
+    return 0; 
+}
+
+// ���� 
+BinTree Insert( BinTree BST, ElementType X ){
+	if(!BST){  // ���Ϊ�գ������½�� 
+		BST = (BinTree)malloc(sizeof(struct TNode));
+		BST->Data = X;
+		BST->Left = NULL;
+		BST->Right = NULL;
+	}else{
+		if(X < BST->Data)
+			BST->Left = Insert(BST->Left,X);
+		else if(BST->Data < X)
+			BST->Right = Insert(BST->Right,X);
+	}
+	return BST; 
+}
+
+// ɾ��
+BinTree Delete( BinTree BST, ElementType X ){
+	BinTree tmp;
+	if(!BST){
+		printf("Not Found\n");
+		return BST;
+	}else{
+		if(X < BST->Data)
+			BST->Left = Delete(BST->Left,X);
+		else if(BST->Data < X)
+			BST->Right = Delete(BST->Right,X);
+		else{  // �ҵ�Ҫɾ����� 
+			if(BST->Left && BST->Right){  // ����ý�������Ҷ��� 
+				tmp = FindMin(BST->Right);
+				BST->Data = tmp->Data;
+				BST->Right = Delete(BST->Right,tmp->Data);
+			}else{
+				tmp = BST;
+				if(BST->Left && !BST->Right)
+					BST = BST->Left;
+				else if(!BST->Left && BST->Right)
+					BST = BST->Right;
+				else
+					BST = NULL;
+				free(tmp);
+			}
+		}
+	}
+	return BST;
+} 
+
+// Ѱ��ֵ��С��� 
+Position FindMin( BinTree BST ){
+	if(BST)
+		while(BST->Left)
+			BST = BST->Left;
+	return BST;
+}
+
+// Ѱ��ֵ�����
+Position FindMax( BinTree BST ){
+	if(BST)
+		while(BST->Right)
+			BST = BST->Right;
+	return BST;
+} 
+
+// ����
+Position Find( BinTree BST, ElementType X ){
+	if(!BST){
+		return NULL;
+	}else if(X < BST->Data)
+		return Find(BST->Left,X);
+	else if(BST->Data < X)
+		return Find(BST->Right,X);
+	else
+		return BST;
+} 
+
+// �������
+void PreorderTraversal( BinTree BT ){
+	if(BT){
+		printf(" %d",BT->Data);
+		PreorderTraversal(BT->Left);
+		PreorderTraversal(BT->Right);
+	}
+} 
+// �������
+void InorderTraversal( BinTree BT ){
+	if(BT){
+		
+		InorderTraversal(BT->Left);
+		printf(" %d",BT->Data);
+		InorderTraversal(BT->Right);
+	}
+} 
diff --git a/编程作业/14.二叉搜索树的操作集.exe b/编程作业/14.二叉搜索树的操作集.exe
new file mode 100644
index 0000000..3593c4b
Binary files /dev/null and b/编程作业/14.二叉搜索树的操作集.exe differ
diff --git a/编程作业/15.堆中的路径.cpp b/编程作业/15.堆中的路径.cpp
new file mode 100644
index 0000000..7f7979c
--- /dev/null
+++ b/编程作业/15.堆中的路径.cpp
@@ -0,0 +1,50 @@
+#include<iostream>
+#include<malloc.h>
+const int MinData = -100000;  // �ڱ�ֵ
+const int MaxSize = 1005;   // ������ 
+using namespace std;
+typedef struct HeapStruct *Heap;
+struct HeapStruct{
+	int *data;   // ��ֵ������ 
+	int size;   // ��ǰԪ�ظ��� 
+	int capacity;  // ������� 
+};
+
+// ��ʼ����
+Heap Create(){
+	Heap H;
+	H = (Heap)malloc(sizeof(struct HeapStruct));
+	H->data = (int *)malloc(sizeof(int) * (MaxSize+1));
+	H->size = 0;
+	H->capacity = MaxSize;
+	H->data[0] = MinData;
+	return H;
+} 
+
+// ����
+void Insert(Heap H,int x){
+	int i = ++H->size;  // ָ���������һ�� 
+	for(;H->data[i/2]>x;i/=2)
+		H->data[i] = H->data[i/2];
+	H->data[i] = x;
+} 
+
+// ���� 
+void bl(Heap H){
+	for(int i=1;i<=H->size;i++)
+		cout<<H->data[i];
+}
+
+int main(){
+	Heap H;
+	H = Create();
+	int n;
+	cin>>n;
+	for(int i=0;i<n;i++){
+		int t;
+		cin>>t;
+		Insert(H,t);
+	}
+	bl(H);
+	return 0;
+} 
diff --git a/编程作业/15.堆中的路径.exe b/编程作业/15.堆中的路径.exe
new file mode 100644
index 0000000..a9eafb5
Binary files /dev/null and b/编程作业/15.堆中的路径.exe differ
diff --git a/编程作业/16.File Transfer.cpp b/编程作业/16.File Transfer.cpp
new file mode 100644
index 0000000..c281f09
--- /dev/null
+++ b/编程作业/16.File Transfer.cpp	
@@ -0,0 +1,83 @@
+#include<cstdio>
+#define MaxSize 10005
+typedef int SetType; 
+using namespace std;
+// ��ʼ�� 
+void Init(SetType s[],int n){
+	for(int i=0;i<n;i++)
+		s[i] = -1;
+}
+
+// ���� 
+int Find(SetType s[],int x){
+	if(s[x] < 0)  // �����Ѿ��Ǹ� 
+		return x;
+	else  // 1. �ҵ���  2. �Ѹ���� x �ĸ����  3.�ٷ��ظ� 
+		return s[x] = Find(s,s[x]);
+} 
+
+// ��
+void Union(SetType s[],int x1,int x2){
+	// x1 ��ģ���󣬸������� 
+	if(s[x1] < s[x2]){
+		s[x1] += s[x2];    //  �����ϲ�����ģ��� 
+		s[x2] = x1;   // x2 �ҵ� x1 �� 
+	}else{
+		s[x2] += s[x1];   //  �����ϲ�����ģ��� 
+		s[x1] = x2;
+	}
+} 
+
+//����
+void Input_connection(SetType s[]){
+	int x1,x2;
+	scanf("%d %d",&x1,&x2);
+	int root1 = Find(s,x1-1);  // �������±��ֵ���±����ֵ�� 1 
+	int root2 = Find(s,x2-1);
+	if(root1 != root2)
+		Union(s,root1,root2);
+}
+
+//�������
+void check_connection(SetType s[]){
+	int x1,x2;
+	scanf("%d %d",&x1,&x2);
+	int root1 = Find(s,x1-1);
+	int root2 = Find(s,x2-1);
+	if(root1 == root2)
+		printf("yes\n");
+	else
+		printf("no\n");
+} 
+
+// �������
+void check_network(SetType s[],int n){
+	int counter = 0;
+	for(int i=0;i<n;i++)
+		if(s[i] < 0)
+			counter++;
+	if(counter == 1)
+		printf("The network is connected.");
+	else
+		printf("There are %d components.",counter);
+}
+
+
+int main(){
+	int n;
+	char in;
+	scanf("%d",&n); 
+	SetType s[MaxSize];
+	Init(s,n);
+	do{
+		getchar();  // ����ÿ�ζ�����Ļس� 
+		scanf("%c",&in);
+		switch(in){
+			case 'I':Input_connection(s);break;
+			case 'C':check_connection(s);break;
+			case 'S':check_network(s,n);break;
+		}		
+	}while(in != 'S');
+
+	return 0;
+} 
diff --git a/编程作业/16.File Transfer.exe b/编程作业/16.File Transfer.exe
new file mode 100644
index 0000000..c65909e
Binary files /dev/null and b/编程作业/16.File Transfer.exe differ
diff --git a/编程作业/17.Huffman Codes.cpp b/编程作业/17.Huffman Codes.cpp
new file mode 100644
index 0000000..13986ac
--- /dev/null
+++ b/编程作业/17.Huffman Codes.cpp	
@@ -0,0 +1,304 @@
+/*#include<queue>
+#include<map> 
+#include<iostream>
+#include<algorithm>
+#define MaxSize 64
+using namespace std;
+priority_queue<int,vector<int>,greater<int> >q; // �������ȶ��У���ǰ���ֵ��С
+map<char,int> mapp;  
+struct character{
+	char ch;   // �ַ� 
+	int fre;  // Ƶ�� 
+};
+struct huffmanTree{
+	char ch;  // �ַ� 
+	string str;  // ���� 
+};
+
+
+// ����
+int bulidTree(int n,character c[]){
+	int weight = 0;
+	// ��� 
+	for(int i=0;i<n;i++)
+		q.push((c[i].fre));
+	while(q.size()>1){ 
+		// ȡ���Ѷ�Ԫ�� 
+		int x = q.top();
+		// �����Ѷ�Ԫ�� 
+		q.pop();
+		int y = q.top();
+		q.pop();
+		// ��� 
+		q.push(x+y);
+		weight += x+y;  // �õ����볤�� 
+		// СȨֵ�᲻�ϱ��� 
+	}
+	q.pop();
+	return weight;
+}
+bool cmp(huffmanTree a,huffmanTree b){
+	return a.str.size() < b.str.size();
+}
+
+// �ж��Ƿ�Ϊǰ׺
+bool isPrefix(huffmanTree code[],int n){
+	// ���ַ������ȴ�С�������� 
+	sort(code,code+n,cmp); 
+	for(int i=0;i<n;i++){
+		string str = code[i].str;
+		for(int j=i+1;j<n;j++){ // ����֮��ȫ���ַ�
+			// ������ַ����볤�ַ�����ȡ��ͬ������ȣ���Ϊǰ׺ 
+			if(code[j].str.substr(0,str.size()) == str)
+				return true;
+		}
+	}
+	return false; 
+}
+
+void judge(int n,character c[],int weight){
+	// ���� WPL 
+	huffmanTree code[MaxSize];
+	int codelen = 0;
+	for(int i=0;i<n;i++){
+		cin>>code[i].ch>>code[i].str;
+		// ���볤�ȵ��ڱ��볤��*Ƶ���ܺ� 
+		codelen += mapp[code[i].ch]*code[i].str.size();  
+	}
+	if(codelen != weight || isPrefix(code,n))
+		cout<<"no"<<endl;
+	else
+		cout<<"yes"<<endl;
+} 
+
+int main(){
+	int n;
+	int m;
+	cin>>n;
+	character c[MaxSize];
+	for(int i=0;i<n;i++){
+		cin>>c[i].ch>>c[i].fre;
+		mapp[c[i].ch] = c[i].fre;
+	}
+	int weight = bulidTree(n,c);
+	cin>>m;
+	for(int i=0;i<m;i++)
+		judge(n,c,weight);
+	return 0;
+}*/ 
+#include<cstdio>
+#include<cstdlib>
+#include<string>
+#include<iostream>
+#include<map>
+#define HeapCapacity 64
+#define MinData 0
+typedef struct TreeNode *HuffmanTree;
+typedef struct Heap *MinHeap;
+struct Heap{   // �� 
+	HuffmanTree *data;  // ��������� 
+	int size; // �ѵĵ�ǰ��С 
+};
+struct TreeNode{   // �������� 
+	int weight;  // Ƶ��
+	HuffmanTree left; 
+	HuffmanTree right; 
+};
+using namespace std;
+
+MinHeap createHeap();   // ���� 
+HuffmanTree createHuffman();  // ���������� 
+void sortHeap(MinHeap H,int i); // ���������� 
+void adjust(MinHeap H);  // ������ 
+MinHeap InitHeap(int n); // ��ʼ���� 
+HuffmanTree Delete(MinHeap H); // �ѵ�ɾ�� 
+void Insert(MinHeap H,HuffmanTree Huff); // �ѵIJ��� 
+HuffmanTree Huffman(MinHeap H);  // ������������ 
+int WPL(HuffmanTree Huff,int depth); // ���� HuffmanTree �ı��볤�� 
+void PreOrderTraversal(HuffmanTree Huff); // ǰ�����  
+
+
+map<char,int> mappp;  // �����ַ���Ƶ�ʵ�ӳ���ϵ 
+
+// ���� 
+MinHeap createHeap(){
+	MinHeap H;
+	H = (MinHeap)malloc(sizeof(struct Heap));
+	H->data = (HuffmanTree *)malloc(sizeof(struct TreeNode) * HeapCapacity);
+	H->size = 0; 
+	// �����ڱ�
+	HuffmanTree Huff = createHuffman();
+	H->data[0] = Huff; 
+	return H;
+}
+
+// ���������� 
+HuffmanTree createHuffman(){
+	HuffmanTree Huff;
+	Huff = (HuffmanTree)malloc(sizeof(struct TreeNode));
+	Huff->weight = MinData;   // ��ʼ����Ƶ����С 
+	Huff->left = NULL;
+	Huff->right = NULL;
+	return Huff;
+}
+
+// ���������� 
+void sortHeap(MinHeap H,int i){
+	int parent,child;
+	HuffmanTree Huff = H->data[i]; // �õ���ǰ�����Ĺ�������
+	for(parent = i;parent*2<=H->size;parent = child){
+		// ���Ҷ�������С�� 
+		child = parent * 2; 
+		if((child!=H->size) && (H->data[child+1]->weight < H->data[child]->weight))
+			child++;
+		// û�и�С���ˣ�����ѭ�� 
+		if(Huff->weight <= H->data[child]->weight)
+			break;
+		// ����Ѷ��ӽ��������
+		H->data[parent] = H->data[child]; 
+	}
+	H->data[parent] = Huff;
+} 
+
+
+// ������ 
+void adjust(MinHeap H){
+	// �ӵ�һ���к��ӽ��Ľ�㿪ʼ���� 
+	for(int i=H->size/2;i>0;i--)
+		sortHeap(H,i); 
+}
+
+// ��ʼ���� 
+MinHeap InitHeap(int n){
+	MinHeap H =createHeap();
+	HuffmanTree Huff;
+	char c;  // ��ʱ�����ַ� 
+	int f;  //  ��ʱ����Ƶ�� 
+	for(int i=0;i<n;i++){
+		getchar();
+		scanf("%c %d",&c,&f);
+		mappp.insert(pair<char,int>(c,f));  // ���ַ���Ƶ�ʵ�ӳ���ϵ���map 
+		Huff = createHuffman();
+		Huff->weight = f;
+		H->data[++H->size] = Huff;
+	}
+	// �������� 
+	adjust(H);
+	return H;
+}
+
+// �ѵ�ɾ�� 
+HuffmanTree Delete(MinHeap H){
+	int parent,child;
+	HuffmanTree T = H->data[1]; // �õ������Ĺ������� 
+	HuffmanTree Huff = H->data[H->size--];  // �õ����һ��λ�õĹ������� 
+	for(parent = 1;parent*2<=H->size;parent = child){
+		// ���Ҷ�������С�� 
+		child = parent * 2; 
+		if((child!=H->size) && (H->data[child+1]->weight < H->data[child]->weight))
+			child++;
+		// û�и�С���ˣ�����ѭ�� 
+		if(Huff->weight <= H->data[child]->weight)
+			break;
+		// ����Ѷ��ӽ��������
+		H->data[parent] = H->data[child]; 
+	}
+	H->data[parent] = Huff;
+	return T;
+} 
+
+// �ѵIJ���
+void Insert(MinHeap H,HuffmanTree Huff){
+	int i = ++H->size; 
+	for(;Huff->weight < H->data[i/2]->weight;i/=2)
+		H->data[i] = H->data[i/2];
+	H->data[i] = Huff;
+} 
+
+// ������������ 
+HuffmanTree Huffman(MinHeap H){
+	HuffmanTree Huff;
+	int times = H->size;
+	for(int i=1;i<times;i++){
+		Huff = createHuffman();
+		Huff->left = Delete(H);  // �Ӷ���ɾ��һ����㣬��Ϊ�� T �����ӽ�� 
+		Huff->right = Delete(H);  // �Ӷ���ɾ��һ����㣬��Ϊ�� T �����ӽ�� 
+		Huff->weight = Huff->left->weight + Huff->right->weight; // ���¼���Ȩֵ 
+		Insert(H,Huff);   // �ټӽ����� 
+	}
+	Huff = Delete(H);
+	return Huff;
+} 
+
+// ���� HuffmanTree �ı��볤�� 
+int WPL(HuffmanTree Huff,int depth){
+	// �����Ҷ��㣬���ر��볤�� 
+	if(Huff->left==NULL && Huff->right==NULL)
+		return depth*Huff->weight;
+	else  // ���򷵻��������ӽ��ı��볤�� 
+		return (WPL(Huff->left,depth+1) + WPL(Huff->right,depth+1));
+}
+
+// �ύ 
+void submit(int n,int codeLen){
+	HuffmanTree Huff = createHuffman();
+	HuffmanTree pre;
+	int counter = 1;
+	bool flag = true;
+	char ch;
+	string code; 
+	for(int i=0;i<n;i++){
+		getchar();
+		pre = Huff; 
+		// ����ÿ�� 
+		scanf("%c",&ch);
+		cin>>code;
+		// �������� 
+		for(int j=0;j<code.size();j++){
+			if(code[j]=='0'){  // �����ǰ����Ϊ 0�����֧ 
+				if(pre->left==NULL){   // ��������������ڣ����� 
+					pre->left =createHuffman();
+					counter++;
+				}
+				if(pre->weight != 0)
+					flag =false;
+				pre = pre->left;
+			}else if(code[j]=='1'){ // �����ǰ����Ϊ 0�����֧ 
+				if(pre->right==NULL){   // ��������������ڣ����� 
+					pre->right = createHuffman();
+					counter++;
+				}
+				if(pre->weight != 0)
+					flag =false;
+				pre = pre->right;
+			}
+		}
+		if(pre->left || pre->right)
+			flag = false;
+		pre->weight = mappp[ch];   // �� mapp ȡ�����Ƶ��
+	}
+	if(counter!=2*n-1 || !flag || WPL(Huff,0) != codeLen){ // �����㲻�� 2n-1 ��  ���߱��볤�Ȳ���� 
+		printf("No\n");
+		return;
+	}else{
+		printf("Yes\n");
+		return;
+	}
+} 
+
+
+int main(){
+	int n,m;
+	scanf("%d",&n);
+	// ��ʼ����С�� 
+	MinHeap H = InitHeap(n);
+	// ��ʼ���������� 
+	HuffmanTree Huff = Huffman(H);
+	// ����ù��������ı��볤�� 
+	int codeLen = WPL(Huff,0); 
+	scanf("%d",&m);
+	for(int i=0;i<m;i++){
+		submit(n,codeLen);
+	} 
+	return 0;
+}
diff --git a/编程作业/17.Huffman Codes.exe b/编程作业/17.Huffman Codes.exe
new file mode 100644
index 0000000..70f3e53
Binary files /dev/null and b/编程作业/17.Huffman Codes.exe differ
diff --git a/编程作业/18.列出连通集.cpp b/编程作业/18.列出连通集.cpp
new file mode 100644
index 0000000..9cb87c8
--- /dev/null
+++ b/编程作业/18.列出连通集.cpp
@@ -0,0 +1,84 @@
+#include<iostream>
+#include<stdlib.h>
+#include<queue>
+#define MaxVertex 100
+typedef int Vertex;
+int G[MaxVertex][MaxVertex];
+bool visit[MaxVertex];
+int Ne,Nv;
+using namespace std;
+
+// ��ͼ 
+void Build(){
+	cin>>Nv;
+	for(int i=0;i<Nv;i++){
+		visit[i] = false;   // ��Ϊδ���� 
+		for(int j=0;j<Nv;j++)
+			G[i][j] = 0;		
+	}
+	cin>>Ne;
+	for(int i=0;i<Ne;i++){
+		int v1,v2;
+		cin>>v1>>v2;
+		G[v1][v2] = 1;
+		G[v2][v1] = 1;
+	}
+}
+
+void DFS(Vertex v){
+	// ����ѷ��� 
+	visit[v] = true;
+	cout<<" "<<v;
+	for(int i=0;i<Nv;i++)
+		if(!visit[i] && G[v][i])
+			DFS(i);
+} 
+
+
+void BFS(Vertex v){
+	queue<Vertex> q;
+	// �ı�״̬ 
+	visit[v] = true;
+	cout<<" "<<v;
+	// ��� 
+	q.push(v);
+	while(!q.empty()){
+		// ���Ӷ���Ԫ�� 
+		Vertex tmp = q.front();
+		q.pop();
+		for(Vertex i=0;i<Nv;i++){
+			// ���δ�����ʹ����Һ͸ճ���Ԫ������ 
+			if(!visit[i] && G[i][tmp]){
+				visit[i] = true; 
+				cout<<" "<<i;
+				q.push(i);
+			}
+		}
+	}
+}
+
+// ������ͨ�� 
+void ListComp(){
+	for(Vertex i=0;i<Nv;i++)
+		if(!visit[i]){
+			cout<<"{";
+			DFS(i);
+			cout<<" }"<<endl;
+		}
+	// ��ʼ����״̬ 
+	for(Vertex i=0;i<Nv;i++)
+		visit[i] = false;
+	
+	for(Vertex i=0;i<Nv;i++)
+		if(!visit[i]){
+			cout<<"{";
+			BFS(i);
+			cout<<" }"<<endl;
+		}
+}
+
+int main(){
+	Build();
+	ListComp();
+	return 0;
+} 
diff --git a/编程作业/18.列出连通集.exe b/编程作业/18.列出连通集.exe
new file mode 100644
index 0000000..a4abd52
Binary files /dev/null and b/编程作业/18.列出连通集.exe differ
diff --git a/编程作业/19.Saving James Bond - Easy Version.cpp b/编程作业/19.Saving James Bond - Easy Version.cpp
new file mode 100644
index 0000000..29977ac
--- /dev/null
+++ b/编程作业/19.Saving James Bond - Easy Version.cpp	
@@ -0,0 +1,126 @@
+#include<iostream>
+#include<stdlib.h>
+#include<cmath>
+#include<queue> 
+#define MaxVertex 105
+struct Node{  // �������±� 
+	int hor;   // ������ 
+	int ver;  // ������
+	bool visit;  // �Ƿ񱻷���
+	bool safe;  // �Ƿ����ϰ� 
+	bool jump;  // ��һ���ܷ�����ȥ 
+};
+int N;   // ������ 
+int D;   // ��Ծ����
+bool isSafe;  // �Ƿ��ϰ� 
+Node G[MaxVertex];
+using namespace std;
+const double diameter=15;
+
+// ����������� 
+double getLen(int x1,int y1,int x2,int y2){
+	return sqrt(pow(x1-x2,2.0)+pow(y1-y2,2.0));
+}
+
+// ����������ܷ񵽰��� 
+bool ashore(int x,int y){
+	// �ֱ���㵱ǰ����밶�ߵľ���
+	// ���� (x,50),(x,-50),(50,y),(-50,y) �ľ���  
+	if(abs(x-50)<=D || abs(x+50)<=D || abs(y+50)<=D || abs(y-50)<=D)
+		return true;
+	return false;
+}
+
+// ȷ�������Ƿ�ȫ("���ϰ�") 
+void getSafe(){
+	for(int i=0;i<N;i++){
+		// ���������λ�ú�"����"���� 
+		if(ashore((G[i].hor),(G[i].ver)))
+			G[i].safe = true; // �������Ϊ true
+		else
+			G[i].safe = false; 
+	}
+}
+
+// ȷ����Щ�����ǿ��Ե�һ������ȥ�� 
+void getJump(){
+	for(int i=0;i<N;i++){
+		// ���������λ�ú�"������"���ڣ���Ծ����+�뾶�� 
+		if(getLen(G[i].hor,G[i].ver,0,0)<=D+diameter/2)
+			G[i].jump = true;
+		else
+			G[i].jump = false;
+	}
+}
+
+// ��ʼ�� 
+void Init(){
+	cin>>N>>D;
+	int x,y;
+	for(int i=0;i<N;i++){
+		cin>>x>>y;
+		G[i].hor = x;
+		G[i].ver = y;
+		G[i].visit = false;
+	}
+	getSafe();
+	getJump();
+	isSafe = false;
+}
+/*
+void DFS(int v){
+	if(G[v].safe){ 
+		isSafe = true;
+		return;
+	} 
+	G[v].visit = true;
+	for(int i=0;i<N;i++){
+		// �������С�� D����δ������������
+		if(getLen(G[v].hor,G[v].ver,G[i].hor,G[i].ver)<=D && !G[i].visit)
+			DFS(i);
+	}
+}
+*/
+void BFS(int v){
+	queue<Node> q;
+	Node tmp;
+	G[v].visit = true;
+	// ��һֻ������� 
+	q.push(G[v]);
+	while(!q.empty()){
+		tmp = q.front();
+		q.pop();
+		// ���ϰ� 
+		if(tmp.safe){
+			isSafe = true;
+			return;
+		}
+		for(int i=0;i<N;i++){
+			// �������С�� D����δ������������
+			if(getLen(tmp.hor,tmp.ver,G[i].hor,G[i].ver)<=D && !G[i].visit){
+				G[i].visit = true;
+				q.push(G[i]);
+			}
+		}
+	}
+}
+
+// �������е�һ�������������� 
+void listCompoent(){
+	for(int i=0;i<N;i++)
+		if(G[i].jump){
+		//	DFS(i); 
+			BFS(i);
+		}
+	if(isSafe)
+		cout<<"Yes"<<endl;
+	else
+		cout<<"No"<<endl;
+}
+
+
+int main(){
+	Init();
+	listCompoent();
+	return 0;
+}
diff --git a/编程作业/19.Saving James Bond - Easy Version.exe b/编程作业/19.Saving James Bond - Easy Version.exe
new file mode 100644
index 0000000..cb2aaa0
Binary files /dev/null and b/编程作业/19.Saving James Bond - Easy Version.exe differ
diff --git a/编程作业/2.Maximum Subsequence Sum.cpp b/编程作业/2.Maximum Subsequence Sum.cpp
new file mode 100644
index 0000000..4d652e3
--- /dev/null
+++ b/编程作业/2.Maximum Subsequence Sum.cpp	
@@ -0,0 +1,31 @@
+#include<iostream>
+using namespace std;
+int main(){
+	int n;
+	int a[100000+5];
+	cin>>n;
+	for(int i=0;i<n;i++)
+		cin>>a[i];
+	int left = 0;
+	int tmpleft = 0;
+	int right = n-1;
+	int max =0;
+	int tmpSum=0;
+	for(int i=0;i<n;i++){
+		tmpSum+=a[i];
+		if(tmpSum<0){
+			tmpSum=0;
+			tmpleft = i+1;   // ��ͷ����������α����������е���һ�� 
+		}else if(max < tmpSum){
+			max = tmpSum;        
+			left = tmpleft;   // ÿ�θ������ֵҲ��ȷ����һ�������У������ʱ�Ŀ�ͷ 
+			right = i;       // ��β��������ÿ�θ������ֵʱ 
+		}
+	}
+	if(max>=0)
+		cout<<max<<" "<<a[left]<<" "<<a[right];
+	else
+		cout<<0<<" "<<a[0]<<" "<<a[n-1];
+	return 0;
+} 
+
diff --git a/编程作业/2.Maximum Subsequence Sum.exe b/编程作业/2.Maximum Subsequence Sum.exe
new file mode 100644
index 0000000..6ee426d
Binary files /dev/null and b/编程作业/2.Maximum Subsequence Sum.exe differ
diff --git a/编程作业/20.六度空间.cpp b/编程作业/20.六度空间.cpp
new file mode 100644
index 0000000..e4fb68d
--- /dev/null
+++ b/编程作业/20.六度空间.cpp
@@ -0,0 +1,107 @@
+#include<iostream>
+#include<stdio.h>
+#include<stdlib.h>
+#include<queue>
+#define MaxVertex 10005
+typedef int vertex;
+typedef struct Node *AdjList;
+struct Node{
+	vertex Adjv;  // ��ǰ�±� 
+	AdjList Next;  // ��һ�� 
+};
+AdjList G[MaxVertex];
+bool visit[MaxVertex];  // �Ƿ���� 
+int N;  // �����
+int M;  // ���� 
+using namespace std;
+
+// ��ʼ������״̬ 
+void InitVisit(){
+	for(int i=1;i<=N;i++)
+		visit[i] = false;
+}
+
+// ��ʼ�� 
+void Init(){
+	vertex v1,v2;
+	AdjList NewNode;
+	cin>>N>>M;
+	// ��ʼ���㣬�� 1��N 
+	for(int i=1;i<=N;i++){
+		G[i] = (AdjList)malloc(sizeof(struct Node));
+		G[i]->Adjv = i;
+		G[i]->Next = NULL;
+	}
+	// ��ʼ���� 
+	for(int i=0;i<M;i++){
+		cin>>v1>>v2;
+		NewNode = (AdjList)malloc(sizeof(struct Node));
+		NewNode->Adjv = v2;
+		NewNode->Next = G[v1]->Next;
+		G[v1]->Next = NewNode;
+		
+		NewNode = (AdjList)malloc(sizeof(struct Node));
+		NewNode->Adjv = v1;
+		NewNode->Next = G[v2]->Next;
+		G[v2]->Next = NewNode;
+	}
+}
+
+int BFS(vertex v){
+	queue<vertex> q;
+	vertex tmp;
+	int level = 0;
+	int last = v;  // �ò����һ�η��ʵĽ�� 
+	int tail = v;  // ÿ���ڱ�Ľ�� 
+	AdjList node;
+	visit[v] = true;
+	int count = 1;  // ͳ�ƹ�ϵ�� 
+	q.push(v);
+	while(!q.empty()){
+		tmp = q.front();
+		q.pop();
+		// G[i]��һ�������Լ����±� 
+		node = G[tmp]->Next;
+		while(node){
+			if(!visit[node->Adjv]){
+				visit[node->Adjv] = true;
+				q.push(node->Adjv);
+				count++;
+				tail = node->Adjv; // ÿ�θ��¸ý�� 
+			}
+			node = node->Next;
+		} 
+		// ����õ�ǰ�����������һ����� 
+		if(tmp == last){  
+			level++;    // ���� +1  
+			last = tail;   // ���� last 
+		}
+		// �������˽��� 
+		if(level==6)
+		   break;
+	}
+	return count; 
+} 
+
+
+void output(double result,int i){
+	printf("%d: %.2f%%\n",i,result);
+}
+
+void SDS(){
+	int count;
+	for(int i=1;i<=N;i++){
+		// ÿ�γ�ʼ���������� 
+		InitVisit(); 
+		count = BFS(i);
+		output((100.0*count)/N,i);
+	}
+}
+
+
+int main(){
+	Init();
+	SDS();
+	
+	return 0;
+} 
diff --git a/编程作业/20.六度空间.exe b/编程作业/20.六度空间.exe
new file mode 100644
index 0000000..ca60f3c
Binary files /dev/null and b/编程作业/20.六度空间.exe differ
diff --git a/编程作业/21.哈利·波特的考试.cpp b/编程作业/21.哈利·波特的考试.cpp
new file mode 100644
index 0000000..b554ea5
--- /dev/null
+++ b/编程作业/21.哈利·波特的考试.cpp
@@ -0,0 +1,167 @@
+/*#include<iostream>
+#define MaxVertex 105
+#define INF 100000
+typedef int Vertex;
+int G[MaxVertex][MaxVertex];  // ͼ 
+int N;  // �����������㣩 
+int M;  // �����������ߣ� 
+int dist[MaxVertex][MaxVertex];  // ����
+bool collected[MaxVertex][MaxVertex];  // ѡ��״̬ 
+using namespace std;
+
+// ��ʼ�� 
+void build(){
+	Vertex v1,v2;
+	int w;
+	cin>>N>>M;
+	for(Vertex i=1;i<=N;i++){
+		for(Vertex j=1;j<=N;j++){ 
+			G[i][j] = 0;   // ��ʼ��ͼ
+			dist[i][j] = INF;  // ��ʼ������
+			collected[i][j] = false;  // ��ʼѡ��״̬ 
+		}
+		dist[i][0] = INF;  // ���⽫ÿ��Դ���һ�������ʼ�� INF 
+	}
+	for(int i=0;i<M;i++){
+		cin>>v1>>v2>>w;
+		G[v1][v2] = w; 
+		G[v2][v1] = w;
+	}
+} 
+
+// ����δ��ѡ�еĶ����о�����С��һ�� 
+Vertex FindMin(Vertex s){
+	Vertex min = 0;
+	for(Vertex i = 1;i<=N;i++)
+		if(i!=s && dist[s][i] < dist[s][min] && !collected[s][i])
+			min = i;
+	return min; 
+}
+
+int FindMax(Vertex s){
+	int max = 0;
+	for(Vertex i = 1;i<=N;i++)
+		if(max < dist[s][i])
+			max = dist[s][i];
+	return max;
+}
+
+// ����Դ����룬�Ҹõ���Χ�����״̬ 
+void prepare(Vertex s){
+	dist[s][s] = 0;
+	collected[s][s] = true;
+	for(Vertex i=1;i<=N;i++)
+		if(G[s][i])
+			dist[s][i] = G[s][i];
+} 
+
+int Dijkstra(Vertex s){
+	prepare(s);  // ׼�� 
+	while(1){
+		Vertex v = FindMin(s);
+		if(!v)
+			break;
+		collected[s][v] = true;
+		for(Vertex w=1;w<=N;w++)
+			if(G[v][w] && !collected[s][w])
+				if(dist[s][v] + G[v][w] < dist[s][w])
+					dist[s][w] = dist[s][v] + G[v][w];
+	} 
+	// �ҵ��Լ����ѱ�����ﳤ�� 
+	return FindMax(s);
+}
+
+int main(){
+	build();
+	int min = INF;
+	int xb = 0;
+	int max;
+	for(Vertex s=1;s<=N;s++){
+		max = Dijkstra(s);
+		if(max < min){ 
+			min = max;
+			xb = s; 
+		} 
+		if(min==INF){
+			cout<<0<<endl;
+			return 0;
+		}
+	}
+	cout<<xb<<" "<<min<<endl;
+	return 0;
+}*/
+
+
+
+#include<iostream>
+#define MaxVertex 105
+#define INF 100000
+typedef int Vertex;
+int G[MaxVertex][MaxVertex];  // ͼ 
+int N;  // �����������㣩 
+int M;  // �����������ߣ� 
+int dist[MaxVertex][MaxVertex];  // ����
+using namespace std;
+
+// ��ʼ�� 
+void build(){
+	Vertex v1,v2;
+	int w;
+	cin>>N>>M;
+	for(Vertex i=1;i<=N;i++)
+		for(Vertex j=1;j<=N;j++)
+			G[i][j] = INF;   // ��ʼ��ͼ
+	for(int i=0;i<M;i++){
+		cin>>v1>>v2>>w;
+		G[v1][v2] = w; 
+		G[v2][v1] = w;
+	}
+}
+
+void Floyd(){
+	// ��ʼ�� dist ���� 
+	for(Vertex i=1;i<=N;i++)
+		for(Vertex j=1;j<=N;j++) 
+			dist[i][j] = G[i][j];
+	for(Vertex k=1;k<=N;k++)
+		for(Vertex i=1;i<=N;i++)
+			for(Vertex j=1;j<=N;j++)
+				if(dist[i][k] + dist[k][j] < dist[i][j])
+					dist[i][j] = dist[i][k] + dist[k][j];
+}
+
+// ����ÿ��Դ�㵽����������ֵ 
+int FindMax(Vertex s){
+	int max = 0;
+	for(Vertex i=1;i<=N;i++)
+		if(s!=i && max < dist[s][i])
+			max = dist[s][i];
+	return max;
+}
+
+// ����ÿ��Դ�㵽����������ֵ����С�ľ��� 
+void FindMin(){
+	int ItemMax;
+	int min = INF;
+	int animal; 
+	for(Vertex i=1;i<=N;i++){
+		ItemMax = FindMax(i);
+		if(ItemMax == INF){
+			cout<<0<<endl;
+			return;
+		}
+		if(ItemMax < min){ 
+			min = ItemMax;
+			animal = i;
+		}
+	}
+	cout<<animal<<" "<<min<<endl;
+}
+
+int main(){
+	build();
+	Floyd();
+	FindMin();
+	return 0;
+}
+
diff --git a/编程作业/21.哈利·波特的考试.exe b/编程作业/21.哈利·波特的考试.exe
new file mode 100644
index 0000000..382ee7e
Binary files /dev/null and b/编程作业/21.哈利·波特的考试.exe differ
diff --git a/编程作业/22.Saving James Bond - Hard Version.cpp b/编程作业/22.Saving James Bond - Hard Version.cpp
new file mode 100644
index 0000000..e2fc5f8
--- /dev/null
+++ b/编程作业/22.Saving James Bond - Hard Version.cpp	
@@ -0,0 +1,165 @@
+#include<iostream>
+#include<cmath>
+#define INF 100000 
+#define MaxVertex 105
+typedef int Vertex;
+int G[MaxVertex][MaxVertex]; // ͼ
+int dist[MaxVertex];  // ����
+int path[MaxVertex];  // ·�� 
+bool collected[MaxVertex];  // ��¼��� 
+int N;  // ����
+int D;  // һ������ 
+struct Node{  // ���
+	int hor;  // ������
+	int ver;  // ������ 
+};
+Node pos[MaxVertex];  // �������� 
+const double diameter=15;  // ֱ�� 
+using namespace std;
+
+// ������Ȩͼ 
+// 0.�ж����ϰ�����ļ��� 
+// 1.�жϸ������Ƿ�����
+// 2.ת��Ϊͼ 
+
+// ����������� 
+double getLen(int x1,int y1,int x2,int y2){
+	return sqrt(pow(x1-x2,2.0)+pow(y1-y2,2.0));
+}
+// �ж������ܷ��ϰ� 
+bool ashore(int x,int y){
+	// �ֱ���㵱ǰ����밶�ߵľ���
+	// ���� (x,50),(x,-50),(50,y),(-50,y) �ľ���  
+	if(abs(x-50)<=D || abs(x+50)<=D || abs(y+50)<=D || abs(y-50)<=D)
+		return true;
+	return false;
+}
+
+// ȷ�������Ƿ�ȫ("���ϰ�") 
+void getSafe(){
+	for(int i=0;i<N;i++){
+		// ���������λ�ú�"����"���� 
+		// ��ͨ 
+		if(ashore((pos[i].hor),(pos[i].ver))){
+			G[N+1][i] = 1;
+			G[i][N+1] = 1;
+		}
+	}
+}
+
+// ȷ����Щ�����ǿ��Ե�һ������ȥ�� 
+void getJump(){
+	for(int i=0;i<N;i++)
+		// ���������λ�ú�"������"���ڣ���Ծ����+�뾶�� 
+		if(getLen(pos[i].hor,pos[i].ver,0,0)<=D+diameter/2){
+			G[N][i] = 1;
+			G[i][N] = 1;
+		}
+}
+
+// ��������� 
+void getConn(){
+	for(int i=0;i<N;i++)
+		for(int j=0;j<N;j++)
+			// �����������С��һ�����룬��˴���ͨ 
+			if(i!=j && getLen(pos[i].hor,pos[i].ver,pos[j].hor,pos[j].ver)<=D){
+				G[i][j] = 1;
+				G[j][i] = 1;
+			}
+}
+
+// ��ʼ�� 
+void Init(){
+	cin>>N>>D;
+	int x,y;
+	// ¼��λ�� 
+	for(int i=0;i<N;i++){
+		cin>>x>>y;
+		pos[i].hor = x;
+		pos[i].ver = y;
+	}
+	// 007 �㶥�㣬��Ҳ�㶥��
+	// ��ʼ��ͼ��007��ͨ����� G[N]������ͨ����� G[N+1] 
+	for(Vertex i=0;i<=N+1;i++){
+		for(Vertex j=0;j<=N+1;j++)
+			G[i][j] = INF;  // ��ʼ�����
+		dist[i] = INF;  // ��ʼ������
+		path[i] = -1;  // ��ʼ��·��
+		collected[i] = false; // ��ʼ����¼״̬ 
+	} 
+	// ��ʼ����
+	// ����ͨ��� 
+	getSafe();
+	// 007��ͨ��� 
+	getJump();
+	// ����˴���ͨ��� 
+	getConn(); 
+}
+
+
+// ����δ��¼dist��С�ĵ�
+Vertex FindMin(Vertex s){
+	int min = INF;
+	Vertex xb=-1;
+	for(Vertex i=0;i<=N+1;i++)
+		if(s!=i && !collected[i] && dist[i] < min){
+			min = dist[i];
+			xb = i;
+		}
+	return xb;
+} 
+
+// ��ʼ��Դ����Ϣ 
+void InitSource(Vertex s){
+	dist[s] = 0;
+	collected[s] = true;
+	for(Vertex i=0;i<=N+1;i++)
+		if(G[s][i]!=INF){
+			dist[i] = G[s][i];
+			path[i] = s;
+		}
+}
+
+void Dijkstra(Vertex s){
+	InitSource(s);
+	while(1){
+		Vertex v = FindMin(s);
+		if(v==-1)
+			break;
+		collected[v] = true;
+		for(Vertex w=0;w<=N+1;w++)
+			if(!collected[w] && G[v][w]!=INF)
+				if(dist[v] + G[v][w] < dist[w]){
+					dist[w] = dist[v] + G[v][w];
+					path[w] = v;
+				}
+	}
+} 
+
+// ���·�� 
+void outputPath(){
+	// �����ͨ 
+	
+	
+	if(dist[N+1] == INF){
+		cout<<0<<endl;
+		return;
+	}
+	Vertex v = path[N+1];
+	cout<<dist[N+1]<<endl;
+	while(v!=-1){
+		cout<<pos[v].hor<<" "<<pos[v].ver<<endl;
+		v = path[v];
+	}
+	
+}
+
+int main(){
+	Init();
+	Dijkstra(N);
+	outputPath(); 
+	return 0;
+} 
+
+
+
diff --git a/编程作业/22.Saving James Bond - Hard Version.exe b/编程作业/22.Saving James Bond - Hard Version.exe
new file mode 100644
index 0000000..7587d40
Binary files /dev/null and b/编程作业/22.Saving James Bond - Hard Version.exe differ
diff --git a/编程作业/23.旅游规划.cpp b/编程作业/23.旅游规划.cpp
new file mode 100644
index 0000000..8c05416
--- /dev/null
+++ b/编程作业/23.旅游规划.cpp
@@ -0,0 +1,86 @@
+#include<iostream>
+#define MaxVertex 505
+#define INF 100000
+typedef int Vertex;
+int N; // ������
+int M; // ��
+int S; // Source
+int D;  // Destination 
+int dist[MaxVertex];  // ����
+int cost[MaxVertex]; // ����
+bool collected[MaxVertex];  // ѡ����� 
+int value[MaxVertex][MaxVertex];  // �շ�
+int G[MaxVertex][MaxVertex];
+using namespace std; 
+
+
+void build(){
+	Vertex v1,v2,w1,w2;
+	cin>>N>>M>>S>>D;
+	for(Vertex i=0;i<N;i++){
+		for(Vertex j=0;j<N;j++){
+			G[i][j] = INF;
+			value[i][j] = INF; 
+		}
+		cost[i] = 0;
+		collected[i] = false;
+		dist[i] = INF;
+	}
+	for(int i=0;i<M;i++){
+		cin>>v1>>v2>>w1>>w2;
+		G[v1][v2] = w1;
+		G[v2][v1] = w1; 
+		value[v1][v2] = w2;
+		value[v2][v1] = w2;
+	}
+}
+
+// ��ʼ��Դ����Ϣ 
+void InitSource(){
+	dist[S] = 0;
+	collected[S] = true;
+	for(Vertex i=0;i<N;i++)
+		if(G[S][i]){
+			dist[i] = G[S][i];
+			cost[i] = value[S][i];
+		}
+}
+
+// ����δ����¼��dist��С�ĵ� 
+Vertex FindMin(){
+	int min = INF;
+	Vertex xb = -1;
+	for(Vertex i=0;i<N;i++)
+		if(S!=i && !collected[i] && dist[i] < min){
+			min = dist[i];
+			xb = i;
+		}
+	return xb;
+}
+
+void Dijkstra(){
+	InitSource();
+	while(1){
+		Vertex v = FindMin();
+		if(v==-1)
+			break;
+		collected[v] = true;
+		for(Vertex w=0;w<N;w++)
+			if(!collected[w] && G[v][w])
+				if(dist[v] + G[v][w] < dist[w]){  // �����·������ 
+					dist[w] = dist[v] + G[v][w];
+					cost[w] = cost[v] + value[v][w];
+				}else if(dist[v] + G[v][w] == dist[w] && cost[v] + value[v][w] < cost[w]){  // ���·��һ������ѡ����ø��� 
+					cost[w] = cost[v] + value[v][w];
+				}
+	}
+}
+
+
+int main(){
+	build();
+	Dijkstra();
+	cout<<dist[D]<<" "<<cost[D];
+	return 0;
+}
+
diff --git a/编程作业/23.旅游规划.exe b/编程作业/23.旅游规划.exe
new file mode 100644
index 0000000..e392fd0
Binary files /dev/null and b/编程作业/23.旅游规划.exe differ
diff --git a/编程作业/24.公路村村通.cpp b/编程作业/24.公路村村通.cpp
new file mode 100644
index 0000000..3cf4023
--- /dev/null
+++ b/编程作业/24.公路村村通.cpp
@@ -0,0 +1,90 @@
+#include<iostream>
+#include<queue>
+#include<vector> 
+#define MaxVertex 1005
+typedef int Vertex;
+using namespace std;
+int N;  // ���� 
+int M;  // �� 
+int parent[MaxVertex];   // ���鼯
+struct Node{
+	Vertex v1;
+	Vertex v2;
+	int weight;
+	// ��������� 
+	bool operator < (const Node &a) const
+	{
+		return weight>a.weight;
+	}
+}; 
+priority_queue<Node> q;  // ���� 
+vector<Node> MST; // �������� 
+int sum;
+
+// ��ʼ��ͼ��Ϣ 
+void build(){
+	Vertex v1,v2;
+	int w;
+	cin>>N>>M;
+	for(int i=1;i<=N;i++){ 
+		parent[i] = -1;
+	} 
+	// ��ʼ����
+	for(int i=0;i<M;i++){
+		cin>>v1>>v2>>w;
+		struct Node tmpE;
+		tmpE.v1 = v1;
+		tmpE.v2 = v2;
+		tmpE.weight = w;
+		q.push(tmpE); 
+	}
+	sum = 0;
+}
+
+
+//  ·��ѹ������ 
+int Find(int x){
+	if(parent[x] < 0)
+		return x;
+	else
+		return parent[x] = Find(parent[x]);
+} 
+
+//  ���ȹ鲢 
+void Union(int x1,int x2){
+	x1 = Find(x1);
+	x2 = Find(x2);
+	if(parent[x1] < parent[x2]){
+		parent[x1] += parent[x2];
+		parent[x2] = x1;
+	}else{
+		parent[x2] += parent[x1];
+		parent[x1] = x2;
+	}
+} 
+
+void Kruskal(){
+	while(MST.size()!=M-1 && !q.empty()){
+		Node E = q.top();    // ��С�ѣ�����Ȩ����С�� 
+		q.pop();   
+		if(Find(E.v1) != Find(E.v2)){ // �ж��Ƿ�����ͬһ���� 
+			sum += E.weight;
+			Union(E.v1,E.v2);    // �� 
+			MST.push_back(E);
+		}
+	}
+}
+
+
+int main(){
+	build();
+	Kruskal();
+	// ͼ��ͨ 
+	if(MST.size()==N-1)
+		cout<<sum;
+	else 
+		cout<<-1;
+	return 0;
+} 
+
+
diff --git a/编程作业/24.公路村村通.exe b/编程作业/24.公路村村通.exe
new file mode 100644
index 0000000..757e417
Binary files /dev/null and b/编程作业/24.公路村村通.exe differ
diff --git a/编程作业/25.How Long Does It Take.cpp b/编程作业/25.How Long Does It Take.cpp
new file mode 100644
index 0000000..c1c3331
--- /dev/null
+++ b/编程作业/25.How Long Does It Take.cpp	
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<queue>
+#include <algorithm>
+#define MaxVertex 105
+#define INF -100000
+typedef int Vertex;
+using namespace std;
+int N; // ��
+int M;  // ��
+int G[MaxVertex][MaxVertex];  
+int Earliest[MaxVertex];  // ʱ�� 
+int Indegree[MaxVertex]; // ��� 
+
+// ��ʼ��ͼ 
+void build(){
+	Vertex v1,v2,w;
+	cin>>N>>M;
+	for(Vertex i=0;i<N;i++){
+		for(Vertex j=0;j<N;j++)
+			G[i][j] = INF;
+	}
+	for(int i=0;i<M;i++){
+		cin>>v1>>v2>>w;
+		G[v1][v2] = w;  // ����ͼ 
+		Indegree[v2]++;  // ���+1 
+	}
+}
+
+void TopSort(){
+	int cnt = 0;
+	queue<Vertex> q;
+	// ���Ϊ0������� 
+	for(Vertex i=0;i<N;i++)
+		if(!Indegree[i]){ 
+			q.push(i);
+			Earliest[i] = 0;
+		} 
+	while(!q.empty()){
+		Vertex v = q.front();
+		q.pop();
+		cnt++;
+		for(Vertex w=0;w<N;w++)
+			if(G[v][w]!=INF){ 
+				if(Earliest[w] < Earliest[v]+G[v][w])  //�����Χ��ʱ�����������ʱ�� 
+					Earliest[w] = max(Earliest[w],Earliest[v]+G[v][w]);
+				if(--Indegree[w]==0)
+					q.push(w);
+			} 
+	}
+	if(cnt!=N)
+		cout<<"Impossible";
+	else{ 
+		// Ҳ����ֹһ���յ� 
+		int max = 0;
+		for(Vertex i=0;i<N;i++)  
+			if(max < Earliest[i]) 
+				max = Earliest[i];
+		cout<<max;
+	}
+		
+}
+
+int main(){
+	build();
+	TopSort();
+	return 0;
+}
+
diff --git a/编程作业/25.How Long Does It Take.exe b/编程作业/25.How Long Does It Take.exe
new file mode 100644
index 0000000..1b8b5e5
Binary files /dev/null and b/编程作业/25.How Long Does It Take.exe differ
diff --git a/编程作业/26.关键活动.cpp b/编程作业/26.关键活动.cpp
new file mode 100644
index 0000000..6443811
--- /dev/null
+++ b/编程作业/26.关键活动.cpp
@@ -0,0 +1,83 @@
+#include<iostream>
+#include<queue>
+#include <algorithm>
+#define MaxVertex 105
+#define INF 100000
+typedef int Vertex;
+using namespace std;
+int N; // ��
+int M;  // ��
+int G[MaxVertex][MaxVertex];  
+int Earliest[MaxVertex];  // �������ʱ�� 
+int latest[MaxVertex];  // �������ʱ�� 
+int Indegree[MaxVertex]; // ��� 
+int Outdegree[MaxVertex];  // ���� 
+int Max;   // �ʱ�� 
+
+// ��ʼ��ͼ 
+void build(){
+	Vertex v1,v2,w;
+	cin>>N>>M;
+	for(Vertex i=1;i<=N;i++)
+		for(Vertex j=1;j<=N;j++)
+			G[i][j] = INF;
+	for(int i=0;i<M;i++){
+		cin>>v1>>v2>>w;
+		G[v1][v2] = w;  // ����ͼ 
+		Indegree[v2]++;  // ���+1
+		Outdegree[v1]++;  // ����+1 
+	}
+}
+
+// ���Ƶõ���������ʱ�� 
+void GetLastest(){
+	
+}
+
+// ���������ҵ������Ŀ���ʱ�� 
+bool TopSort(){
+	int cnt = 0;
+	queue<Vertex> q;
+	// ���Ϊ0������� 
+	for(Vertex i=1;i<=N;i++)
+		if(!Indegree[i]){ 
+			q.push(i);
+			Earliest[i] = 0;
+		} 
+	while(!q.empty()){
+		Vertex v = q.front();
+		q.pop();
+		cnt++;
+		for(Vertex w=1;w<=N;w++)
+			if(G[v][w]!=INF){ 
+				if(Earliest[w] < Earliest[v]+G[v][w])  //�����Χ��ʱ�����������ʱ�� 
+					Earliest[w] = max(Earliest[w],Earliest[v]+G[v][w]);
+				if(--Indegree[w]==0)
+					q.push(w);
+			} 
+	}
+	if(cnt!=N)
+		return false;
+	else{ 
+		// Ҳ����ֹһ���յ� 
+		Max = 0;
+		for(Vertex i=1;i<=N;i++)
+			if(Max < Earliest[i])
+				Max = Earliest[i];
+		return true;
+	}
+		
+}
+
+int main(){
+	build();
+	if(!TopSort())
+		cout<<0;
+	else{
+		cout<<Max<<endl;
+		
+	}
+	return 0;
+}
+
+
diff --git a/编程作业/26.关键活动.exe b/编程作业/26.关键活动.exe
new file mode 100644
index 0000000..bf92062
Binary files /dev/null and b/编程作业/26.关键活动.exe differ
diff --git a/编程作业/27.排序.cpp b/编程作业/27.排序.cpp
new file mode 100644
index 0000000..3b0607d
--- /dev/null
+++ b/编程作业/27.排序.cpp
@@ -0,0 +1,270 @@
+#include<iostream>
+#include<algorithm>
+#include<queue>
+using namespace std; 
+
+// ���� 
+void Bubble_sort(long A[],int N){
+	for(int i=0;i<N-1;i++){  // N-1��ð��
+		bool flag = false;  // ��֤�Ƿ񽻻��� 
+		for(int j=0;j<N-i-1;j++){
+			if(A[j+1] < A[j]){
+				flag = true; 
+				swap(A[j],A[j+1]);
+			}
+		} 
+		// �Ѿ����� 
+		if(!flag)  
+			break; 
+	} 
+} 
+
+// ��������
+void Insertion_sort(long A[],int N){
+	for(int i=1;i<N;i++){  // ��һ���Ѿ����� 
+		long tmp = A[i];
+		int j=i;
+		for(;tmp<A[j-1] && j>0;j--)
+			A[j] = A[j-1];
+		A[j] = tmp;
+	}
+}
+
+// ԭʼϣ������ 
+void shell_sort(long A[],int N){
+	for(int D=N/2;D>0;D/=2){
+		for(int p=D;p<N;p++){
+			long tmp = A[p];
+			int k=p;
+			for(;k>=D && tmp<A[k-D] ;k-=D) // j>=D ��ǰ����ΪҲ�� A[j-D]�Ѿ�Խ�� 
+				A[k] = A[k-D];
+			A[k] = tmp;
+		}
+	}
+} 
+
+// Hibbard��������ϣ������ 
+void Hibbard_shell_sort(long A[],int N){
+	int add[]={32767,16383,8191,4095,2047,1023,511,255,127,63,31,15,7,3,1,0};
+	int i=0;
+	for(int D=add[i];D>0;D=add[++i]){
+		for(int p=D;p<N;p++){
+			long tmp = A[p];
+			int k=p;
+			for(;k>=D && tmp<A[k-D] ;k-=D) // j>=D ��ǰ����ΪҲ�� A[j-D]�Ѿ�Խ�� 
+				A[k] = A[k-D];
+			A[k] = tmp;
+		}
+	}
+} 
+// Sedgewick�������й�ϣ���� 
+void Sedgewick_shell_sort(long A[],int N){
+	int add[]= {587521,260609,146305,64769,36289,16001,8929,3905,2161,929,505,209,109,41,19,5,1,0};
+	int i=0;
+	for(int D=add[i];D>0;D=add[++i]){
+		for(int p=D;p<N;p++){
+			long tmp = A[p];
+			int k = p;
+			for(;k>=D && tmp<A[k-D];k-=D)
+				A[k] = A[k-D];
+			A[k] = tmp;
+		}
+	} 
+}
+
+/***************������ʼ***************/
+
+// ���������� 
+void PrecDown(long A[],int i,int N){
+	int parent,child;
+	long tmp = A[i];
+	// �� 0 ��ʼ�棬���Թ�ϵ�б仯 
+	for(parent = i;parent*2+1<N;parent = child){
+		child = parent*2+1;
+		if((child!=N-1) && (A[child] < A[child+1]))
+			child++;
+		if(A[child] <= tmp)
+			break;
+		else
+			A[parent] = A[child];
+	}
+	A[parent] = tmp;
+}
+
+// ������ 
+void Heap_sort(long A[],int N){
+	// �ȵ��������� 
+	for(int i=N/2;i>=0;i--)
+		PrecDown(A,i,N);
+	for(int i=N-1;i>0;i--){
+		swap(A[0],A[i]); // ÿ�ΰѵ�ǰ���Ѹ�Ԫ��ѡ����� 
+		PrecDown(A,0,i);  // �ٴε������� 
+	}
+} 
+
+/***************���������***************/
+
+/***************stl������ʼ***************/
+priority_queue<long,vector<long>,less<long> > q; // ����һ������ 
+
+void STL_Heap_sort(long A[],int N){
+	// ���ݶ������� 
+	for(int i=0;i<N;i++)
+		q.push(A[i]);
+	// ����� 
+	for(int i=N-1;i>=0;i--){
+		A[i] = q.top();
+		q.pop();
+	}
+} 
+/***************stl���������***************/
+
+/***************�ݹ�鲢����ʼ***************/
+/*
+// �鲢ʵ�� 
+void Merge(long A[],long tmpA[],int L,int R,int RightEnd){
+	// L = ���Ԫ�ؿ�ʼλ�� ��R = �ұ�Ԫ�ؿ�ʼλ�� ��RightEnd = �ұ߽����յ�λ��
+	int NumSize = RightEnd-L+1; // Ԫ�ظ���
+	int LeftEnd = R-1;  // ���Ԫ���յ�λ��
+	int tmp = L;  // tmp ���鿪ʼλ�� 
+	while( L <= LeftEnd && R <= RightEnd ){
+		if(A[L] <= A[R]) // ��С��������ѡС�� 
+			tmpA[tmp++] = A[L++];
+		else
+			tmpA[tmp++] = A[R++];
+	} 
+	// Ҳ����û���� 
+	while( L <= LeftEnd )
+		tmpA[tmp++] = A[L++];
+	// Ҳ���ұ�û���� 
+	while( R <= RightEnd)
+		tmpA[tmp++] = A[R++];
+	// �ٵ��� A ,tmp��ʱ�Ѿ�Խ�磬����Ҫ�ȼ����� 
+	for(int i=0;i<NumSize;i++)
+		A[RightEnd--] = tmpA[--tmp];
+}
+
+// ���� 
+void Msort(long A[],long tmpA[],int L,int RightEnd){
+	if(L < RightEnd){
+		int center = ( L + RightEnd )/2;
+		Msort(A,tmpA,L,center);
+		Msort(A,tmpA,center+1,RightEnd);
+		Merge(A,tmpA,L,center+1,RightEnd);
+	}
+}
+
+void Merge_sort(long A[],int N){
+	long tmpA[N];
+	Msort(A,tmpA,0,N-1);
+}
+*/
+/***************�ݹ�鲢�������***************/
+
+/***************�ǵݹ�鲢����ʼ***************/
+// �鲢ʵ�� ����󲻰�Ԫ�ص���A 
+void Merge1(long A[],long tmpA[],int L,int R,int RightEnd){
+	// L = ���Ԫ�ؿ�ʼλ�� ��R = �ұ�Ԫ�ؿ�ʼλ�� ��RightEnd = �ұ߽����յ�λ��
+	int NumSize = RightEnd-L+1; // Ԫ�ظ���
+	int LeftEnd = R-1;  // ���Ԫ���յ�λ��
+	int tmp = L;  // tmp ���鿪ʼλ�� 
+	while( L <= LeftEnd && R <= RightEnd ){
+		if(A[L] <= A[R]) // ��С��������ѡС�� 
+			tmpA[tmp++] = A[L++];
+		else
+			tmpA[tmp++] = A[R++];
+	} 
+	// Ҳ����û���� 
+	while( L <= LeftEnd )
+		tmpA[tmp++] = A[L++];
+	// Ҳ���ұ�û���� 
+	while( R <= RightEnd)
+		tmpA[tmp++] = A[R++];
+}
+
+// һ�˹鲢 
+void Merge_pass(long A[],long tmpA[],int N,int length){
+	int i;
+	// ÿ 2*length һ����Ԫ�鲢 
+	for(i=0;i<N-2*length;i+=2*length)
+		Merge1(A,tmpA,i,i+length,i+2*length-1);
+	// ����ʣ�಻��һ����Ԫ��ֵ 
+	if(i+length < N)  // ʣ���������У���߹����ұ߲��� 
+		Merge1(A,tmpA,i,i+length,N-1);
+	else    //  ʣ��һ�����У���߶����� 
+		for(int j=i;j<N;j++)
+			tmpA[j] = A[j];
+}
+
+
+void Merge_sort(long A[],int N){
+	int length = 1;
+	long tmpA[N];
+	// ��֤ÿ�����˹鲢�����ս��һ������ A�� 
+	while(length < N){
+		Merge_pass(A,tmpA,N,length);
+		length *=2;
+		Merge_pass(tmpA,A,N,length);
+		length *=2;
+	}
+}
+
+/***************�ǵݹ�鲢�������***************/
+
+/*********************��������ʼ*******************************************/ 
+// ѡ��Ԫ 
+long getPivot(long A[],int L,int R){
+	int center = (L+R)/2;
+	if(A[R] < A[center])
+		swap(A[R],A[center]);
+	if(A[R] < A[L])
+		swap(A[R],A[L]);
+	if(A[center] < A[L])
+		swap(A[center],A[L]);
+	swap(A[center],A[R-1]);
+	return A[R-1];
+}
+
+void QucikSort(long A[],int Left,int Right){
+	int cutoff = 50;
+	if( cutoff <= Right - Left ){  // �����ģ���ÿ��� 
+		int pivot = getPivot(A,Left,Right);
+		int i = Left;      
+		int j = Right-1; 
+		for(;;){
+			// ��ǰ�����ұ� pivot С�� 
+			while(A[++i] < pivot);
+			// �Ӻ���ǰ�ұ� pivot ��� 
+			while(A[--j] > pivot);
+			if(j <= i)
+				break;
+			swap(A[i],A[j]);
+		}
+		// ����Ԫ���ں���λ�� 
+		swap(A[i],A[Right-1]);
+		QucikSort(A,Left,i-1);
+		QucikSort(A,i+1,Right);
+	}else   // ���������� 
+		Insertion_sort(A+Left,Right-Left+1);
+}
+
+void Quick_sort(long A[],int N){
+	QucikSort(A,0,N-1);
+}
+
+/*********************�����������**********************************/ 
+
+int main(){
+	int N;
+	cin>>N;
+	long A[N];
+	for(int i=0;i<N;i++)
+		cin>>A[i];
+	Quick_sort(A,N);
+	for(int i=0;i<N;i++){
+		if(i)
+			cout<<" ";
+		cout<<A[i];
+	}
+	return 0;
+} 
diff --git a/编程作业/27.排序.exe b/编程作业/27.排序.exe
new file mode 100644
index 0000000..1b5b215
Binary files /dev/null and b/编程作业/27.排序.exe differ
diff --git a/编程作业/28.Insert or Merge.cpp b/编程作业/28.Insert or Merge.cpp
new file mode 100644
index 0000000..d21da2a
--- /dev/null
+++ b/编程作业/28.Insert or Merge.cpp	
@@ -0,0 +1,117 @@
+#include<iostream>
+using namespace std; 
+
+bool judge(int A[],int B[],int N){
+	for(int i=0;i<N;i++)
+		if(A[i]!=B[i])
+			return false;
+	return true;
+}
+
+// �������� 
+bool Insertion_Sort(int A[],int B[],int N){
+	for(int P=1;P<N;P++){
+		int tmp = A[P];
+		int j = P;
+		for(;j>0 && tmp < A[j-1];j--)
+			A[j] = A[j-1];
+		A[j] = tmp;
+		if(judge(A,B,N)){  // �������ˣ�����һ�� 
+			P++;
+			int tmp = A[P];
+			int j = P;
+			for(;j>0 && tmp < A[j-1];j--)
+				A[j] = A[j-1];
+			A[j] = tmp;
+			return false;
+		}
+	}
+	return true; 
+}
+
+
+void Merge(int A[],int tmpA[],int L,int R,int RightEnd){
+	// L = �����ʼλ�ã�R = �ұ���ʼλ�ã�RightEnd = �ұ��յ�λ�� 
+	int NumSize = RightEnd-L+1;   //  �������  
+	int LeftEnd = R-1;   // �����ֹλ�� 
+	int tmp = L; 
+	// ���� 
+	while(L <= LeftEnd && R <= RightEnd){
+		if(A[L] <= A[R])
+			tmpA[tmp++] = A[L++];
+		else
+			tmpA[tmp++] = A[R++];
+	} 
+	// ��������ʣ 
+	while(L <= LeftEnd)
+		tmpA[tmp++] = A[L++];
+	// ����ұ���ʣ 
+	while(R <= RightEnd)
+		tmpA[tmp++] = A[R++];
+	//  ���� A ���� 
+	for(int i=0;i<NumSize;i++)
+		A[RightEnd--] = tmpA[--tmp];
+}
+
+void Merge_pass(int A[],int tmpA[],int N,int length){
+	int i;
+	// ÿ�� 2*length Ϊһ������Ԫ 
+	for(i=0;i<=N-2*length;i+=2*length)
+		Merge(A,tmpA,i,i+length,i+length*2-1);
+	// ����ʣ�µIJ���һ�������Ԫ 
+	if(i+length < N)   // �����߹��ˣ������ұ߲��룬�ٴν������� 
+		Merge(A,tmpA,i,i+length,N-1);
+	else   // �����߶�������ֱ�ӵ��� tmpA 
+		for(int j=i;j<N;j++)
+			tmpA[j] = A[j];			
+}
+
+// �鲢����
+bool Merge_Sort(int A[],int B[],int N){
+	int tmpA[N];
+	int length = 1;
+	while(length < N){
+		Merge_pass(A,tmpA,N,length);  // һ�˹鲢 
+		length *=2;
+		if(judge(A,B,N)){   // �������ˣ�����һ�� 
+			Merge_pass(A,tmpA,N,length);
+			return false;
+		}
+	} 
+	return true;
+}
+
+// ��� 
+void output(int A[],int N){
+	for(int i=0;i<N;i++){
+		if(i)
+			cout<<" ";
+		cout<<A[i]; 
+	} 
+} 
+
+int main(){
+	int N;
+	cin>>N;
+	int A[N],tmpA[N];
+	for(int i=0;i<N;i++){
+		cin>>A[i];
+		tmpA[i] = A[i];
+	}
+	int B[N];
+	for(int i=0;i<N;i++)
+		cin>>B[i];
+	// �� tmpA �������鲢�����ж��Ƿ��ǹ鲢���� 
+	if(!Merge_Sort(tmpA,B,N)){
+		cout<<"Merge Sort"<<endl;
+		output(tmpA,N);
+		return 0;
+	}
+	// �� A ���������������ж��Ƿ��Dz�������
+	if(!Insertion_Sort(A,B,N)){
+		cout<<"Insertion Sort"<<endl;
+		output(A,N);
+		return 0;
+	}
+	return 0;
+}
diff --git a/编程作业/28.Insert or Merge.exe b/编程作业/28.Insert or Merge.exe
new file mode 100644
index 0000000..1e6da90
Binary files /dev/null and b/编程作业/28.Insert or Merge.exe differ
diff --git a/编程作业/29.Insertion or Heap Sort.cpp b/编程作业/29.Insertion or Heap Sort.cpp
new file mode 100644
index 0000000..db722d6
--- /dev/null
+++ b/编程作业/29.Insertion or Heap Sort.cpp	
@@ -0,0 +1,96 @@
+#include<iostream>
+#include<algorithm>
+using namespace std;
+void output(int A[],int N); 
+
+// �ж��Ƿ���� 
+bool judge(int A[],int B[],int N){
+	for(int i=0;i<N;i++)
+		if(A[i]!=B[i])
+			return false;
+	return true;
+} 
+
+// �������� 
+bool Insertion_Sort(int A[],int B[],int N){
+	for(int p=1;p<N;p++){
+		int tmp = A[p];
+		int k = p;
+		for(;k>0 && tmp < A[k-1];k--)
+			A[k] = A[k-1];
+		A[k] = tmp;
+		if(judge(A,B,N)){// �����ȣ�����һ��
+			p++; 
+			int tmp = A[p];
+			int k = p;
+			for(;k>0 && tmp < A[k-1];k--)
+				A[k] = A[k-1];
+			A[k] = tmp;
+			return false;
+		}
+	}
+	return true;
+}
+
+void PrecDown(int A[],int i,int N){
+	int tmp = A[i]; // ȡ�õ�ǰ"��"
+	int parent,child;
+	for(parent=i;parent*2+1<N;parent = child){
+		child = 2*parent +1;
+		if((child!=N-1) && (A[child] < A[child+1]))
+			child++;
+		if(A[child] <= tmp)
+			break;
+		A[parent] = A[child];
+	} 
+	A[parent] = tmp;
+}
+
+// ������ 
+bool Heap_Sort(int A[],int B[],int N){
+	for(int i=N/2;i>=0;i--)
+		PrecDown(A,i,N);
+	for(int i=N-1;i>0;i--){
+		swap(A[0],A[i]);
+		PrecDown(A,0,i);
+		if(judge(A,B,N)){  // �����ȣ�����һ�� 
+			swap(A[0],A[--i]);
+			PrecDown(A,0,i);
+			return false;
+		}
+	}
+	return true;
+}
+
+// ��� 
+void output(int A[],int N){
+	for(int i=0;i<N;i++){
+		if(i)
+			cout<<" ";
+		cout<<A[i];
+	}
+}
+
+int main(){
+	int N;
+	cin>>N;
+	int A[N],tmpA[N];
+	for(int i=0;i<N;i++){
+		cin>>A[i];
+		tmpA[i] = A[i];
+	}
+	int B[N];
+	for(int i=0;i<N;i++) 
+		cin>>B[i];
+	if(!Heap_Sort(tmpA,B,N)){  // ����Ƕ����� 
+		cout<<"Heap Sort"<<endl;
+		output(tmpA,N);
+		return 0;
+	}
+	if(!Insertion_Sort(A,B,N)){  // ����Dz������� 
+		cout<<"Insertion Sort"<<endl;
+		output(A,N);
+		return 0;
+	}
+	return 0;
+} 
diff --git a/编程作业/29.Insertion or Heap Sort.exe b/编程作业/29.Insertion or Heap Sort.exe
new file mode 100644
index 0000000..bc4e0f6
Binary files /dev/null and b/编程作业/29.Insertion or Heap Sort.exe differ
diff --git a/编程作业/3.二分查找.cpp b/编程作业/3.二分查找.cpp
new file mode 100644
index 0000000..da21dbc
--- /dev/null
+++ b/编程作业/3.二分查找.cpp
@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAXSIZE 10
+#define NotFound 0
+typedef int ElementType;
+
+typedef int Position;
+typedef struct LNode *List;
+struct LNode {
+    ElementType Data[MAXSIZE];
+    Position Last; /* �������Ա������һ��Ԫ�ص�λ�� */
+};
+
+Position BinarySearch( List L, ElementType X );
+
+int main()
+{
+    List L;
+    ElementType X;
+    Position P;
+
+    L->Data = int[]{1,3,5};
+    L->Last = 3;
+    scanf("%d", &X);
+    P = BinarySearch( L, X );
+    printf("%d\n", P);
+
+    return 0;
+}
+
+Position BinarySearch( List L, ElementType X ){
+	ElementType left = 1;
+	ElementType right = L->Last;
+	while(left<right){
+		ElementType center = (left+right)/2;  //�����м�ֵ 
+		if(L->Data[center] < X){     //���м�ֵ��X ���Ұ�� 
+			left = center+1;
+		}else if(X < L->Data[center]){   //���м�ֵС��X ������ 
+			right = center-1;
+		}else  //�ҵ��ˣ�ֱ�ӷ��� 
+			return center;
+	}
+	return NotFound;
+} 
diff --git a/编程作业/30.统计工龄.cpp b/编程作业/30.统计工龄.cpp
new file mode 100644
index 0000000..1fbe3b4
--- /dev/null
+++ b/编程作业/30.统计工龄.cpp
@@ -0,0 +1,23 @@
+#include<iostream>
+using namespace std;
+
+void bucket_sort(int A[],int N){
+	int count[55];
+	for(int i=0;i<55;i++)
+		count[i] = 0;
+	for(int i=0;i<N;i++)
+		count[A[i]]++;
+	for(int i=0;i<55;i++)
+		if(count[i])
+			cout<<i<<":"<<count[i]<<endl;
+}
+
+int main(){
+	int N;
+	cin>>N;
+	int A[N];
+	for(int i=0;i<N;i++)
+		cin>>A[i];
+	bucket_sort(A,N);
+	return 0;
+}
diff --git a/编程作业/30.统计工龄.exe b/编程作业/30.统计工龄.exe
new file mode 100644
index 0000000..daa6301
Binary files /dev/null and b/编程作业/30.统计工龄.exe differ
diff --git a/编程作业/31.PAT Judge.cpp b/编程作业/31.PAT Judge.cpp
new file mode 100644
index 0000000..afb6fd6
--- /dev/null
+++ b/编程作业/31.PAT Judge.cpp	
@@ -0,0 +1,95 @@
+#include<cstdio>
+#include<algorithm>
+#include<vector>
+
+const int INIT = -2;  // ��ʼ�� 
+const int NOPASS = -1;  // δͨ������ 
+const int MAXID = 10005;  //���ID 
+using namespace std;
+
+struct info{
+	int id;    // id�� 
+	int ques[6];  // ÿ����÷�
+	int sum;   // �ܷ� 
+	int solved;   // ������� 
+};
+
+// ����sort ��������� 
+bool cmp(info a,info b){
+	if(a.sum != b.sum)
+		return a.sum>b.sum;	
+	if(a.solved != b.solved)
+		return a.solved > b.solved;
+	return a.id < b.id;
+}
+
+
+int main(){
+	int N;  // ʹ��������
+	int K;  // ��������
+	int M;  // �ύ���� 
+	scanf("%d %d %d",&N,&K,&M);
+	vector<info> user(N+1); // ʹ������Ϣ
+	int Full[K+1];  // ��¼�����ܷ� ,a[i] ��ʾ��i����ķ���
+	for(int i=1;i<=K;i++) 
+		scanf("%d",&Full[i]);
+	// ��ʼ����Ϣ 
+	for(int i=1;i<N+1;i++){
+		user[i].id = MAXID;  // ��ʼ������� 
+		user[i].sum = 0; 
+		user[i].solved = 0;
+		for(int j=1;j<K+1;j++) 
+			user[i].ques[j] = INIT;
+	}
+	int use;  // ��ұ�� 
+	int question;  // ������ 
+	int score;  // �÷� 
+	int listSum = 0; // Ӧ�ñ�������� 
+	for(int i=0;i<M;i++){
+		scanf("%d %d %d",&use,&question,&score);
+		// ֻҪͨ�����룬����Ҿ��ܱ���ʾ
+		if(score >= 0 && user[use].id == MAXID){
+			listSum++;
+			user[use].id = use;
+		} 
+		// �����и�����³ɸ��� 
+		if(user[use].ques[question] < score){
+			user[use].ques[question] = score;
+		}
+	}
+	for(int i=1;i<N+1;i++)
+		for(int j=1;j<K+1;j++){
+			// ������ȫ��ȷ������ 
+			if(user[i].ques[j] == Full[j])
+				user[i].solved++;
+			// �����ܷ� 
+			if(user[i].ques[j] != NOPASS && user[i].ques[j] != INIT)
+				user[i].sum += user[i].ques[j];
+		} 
+	
+	sort(user.begin()+1,user.end(),cmp);
+	
+	int preSum = user[1].sum;
+	int preNum = 1;
+	
+	for(int i=1;i<=listSum;i++){ 
+	    // ������ϴη�����ͬ���������� 
+		if(preSum != user[i].sum){ 
+			preNum = i;
+			preSum = user[i].sum;
+		} 
+		printf("%d ",preNum);
+		printf("%05d %d",user[i].id,user[i].sum);
+		for(int j=1;j<K+1;j++){
+			// ���ɳ�ʼ��״̬ 
+			if(user[i].ques[j] == INIT)
+				printf(" -");
+			else if(user[i].ques[j] == NOPASS)
+				printf(" 0");
+			else
+				printf(" %d",user[i].ques[j]);
+		}
+		printf("\n");
+	}
+	return 0;
+}
diff --git a/编程作业/31.PAT Judge.exe b/编程作业/31.PAT Judge.exe
new file mode 100644
index 0000000..dd64f32
Binary files /dev/null and b/编程作业/31.PAT Judge.exe differ
diff --git a/编程作业/32.Sort with Swap(0, i).cpp b/编程作业/32.Sort with Swap(0, i).cpp
new file mode 100644
index 0000000..a28e212
--- /dev/null
+++ b/编程作业/32.Sort with Swap(0, i).cpp	
@@ -0,0 +1,33 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+int main(){
+  int N;
+  cin>>N;
+  int tmp;
+  int sum = 0;
+  vector<int> A; // �� N 
+  vector<bool> flag;
+  for(int i=0;i<N;i++){
+  	cin>>tmp;
+  	A.push_back(tmp);
+  	flag.push_back(false);
+  }
+  for(int i=0;i<N;i++){
+  	if(A[i]!=i && !flag[i]){   // û�����ʹ��ĵ�Ԫ�� 
+  		int tmpSum = 0;  // �ƽ�������
+  		int j = i;
+  		do{
+  			tmpSum++;  // ÿ����һ��������+1 
+  			flag[j] = true; // ��ǻ� 
+  			if(!A[j])   // ��������� 0����ȥ�뻷���������� 
+  				tmpSum-=2;
+  			j = A[j];
+  		}while(j!=i);
+  		tmpSum++;    // ǰ���ȥ�� 0�����Խ��������ǵ�ǰ������+1 
+  		sum += tmpSum;
+  	}
+  }
+  cout<<sum<<endl;
+  return 0;
+}
diff --git a/编程作业/32.Sort with Swap(0, i).exe b/编程作业/32.Sort with Swap(0, i).exe
new file mode 100644
index 0000000..df4433b
Binary files /dev/null and b/编程作业/32.Sort with Swap(0, i).exe differ
diff --git a/编程作业/33.电话聊天狂人.cpp b/编程作业/33.电话聊天狂人.cpp
new file mode 100644
index 0000000..5db216f
--- /dev/null
+++ b/编程作业/33.电话聊天狂人.cpp
@@ -0,0 +1,129 @@
+#include<iostream>
+#include<stdlib.h>
+#include<string>
+#include<cmath>
+#define MAXTABLESIZE 1000000
+using namespace std;
+typedef string ElementType;
+typedef struct LNode *List;
+struct LNode{  // ������ 
+	ElementType number;  // �绰���� 
+	int Count;  // ���� 
+	List Next;   
+};
+
+typedef struct HashTbl *HashTable;
+struct HashTbl{   // ��ϣ�� 
+	int TableSize;  // ��ϣ����С
+	List Heads;   // ͷ��� 
+}; 
+
+// ������������ϣ���� 
+int Hash(int key,int p){
+	return key%p;
+}
+ 
+int NextPrime(int N){
+	int p = (N%2)?N+2:N+1;
+	int i;
+	while(p <= MAXTABLESIZE){
+		for(i = (int)sqrt(1.0*p);i>2;i--)
+			if(!(p%i))   // �������� 
+				break;  
+		if(i==2)  // �ҵ��� 
+			break; 
+		p += 2;  // ȥ���¸����� 
+	}
+	return p; 
+}
+
+// ��ʼ����ϣ�� 
+HashTable CreateTable(int TableSize){
+	HashTable H;
+	H = (HashTable)malloc(sizeof(struct HashTbl));
+	H->TableSize = NextPrime(TableSize);
+	
+	// �ṹ���к��ַ������붯̬�����ַ�ռ� 
+	H->Heads = new LNode[H->TableSize];
+	for(int i=0;i<H->TableSize;i++){
+		H->Heads[i].Next = NULL;
+		H->Heads[i].Count = 0; 
+	}
+	return H;
+} 
+
+// ���� 
+List Find(HashTable H,ElementType key){
+	List p;
+	int pos;
+	// �Ե绰���������λɢ��
+	pos = Hash(atoi(key.substr(6,5).c_str()),H->TableSize);
+
+	p = H->Heads[pos].Next;
+	while(p && key != p->number)
+		p = p->Next;
+	return p;
+}
+
+// ���� 
+bool Insert(HashTable H,ElementType key){
+	List p,NewCell;
+	int pos;
+	p = Find(H,key);
+	if(!p){   // p�� 
+		
+		NewCell = new LNode();
+		NewCell->number = key;
+		NewCell->Count = 1;   
+		pos = Hash(atoi(key.substr(6,5).c_str()),H->TableSize);  // �ҵ�ɢ�е�ַ 
+	
+		// ���½����뵽����ͷ 
+		NewCell->Next = H->Heads[pos].Next; 
+		H->Heads[pos].Next = NewCell;
+		return true;
+	}else{
+		p->Count++;   // �Ѿ����ڣ�����+1 
+		return false;
+	}
+}
+
+void ScanAndOutput(HashTable H){
+	List p; 
+	int MaxCnt=0;  // ���ͨ������ 
+	string Minphone; // ������ 
+	int PCnt=0;   // �������� 
+	// ɨ������ 
+	for(int i=0;i<H->TableSize;i++){
+		p = H->Heads[i].Next;
+		while(p){
+			if(MaxCnt < p->Count){
+				MaxCnt = p->Count;
+				Minphone = p->number;
+				PCnt = 1;
+			}else if( p->Count == MaxCnt ){
+				if(p->number < Minphone )
+					Minphone = p->number;
+				PCnt++;
+			} 
+			p = p->Next; 
+			
+		}
+	}
+	cout<<Minphone<<" "<<MaxCnt;
+	if(1 < PCnt)
+		cout<<" "<<PCnt;
+}
+
+int main(){
+	HashTable H;
+	int N;
+	ElementType key;
+	cin>>N;
+	H = CreateTable(2*N);
+	for(int i=0;i<N;i++){
+		cin>>key;		Insert(H,key);
+		cin>>key;		Insert(H,key);
+	}
+	ScanAndOutput(H);
+	return 0;
+} 
diff --git a/编程作业/33.电话聊天狂人.exe b/编程作业/33.电话聊天狂人.exe
new file mode 100644
index 0000000..14f8239
Binary files /dev/null and b/编程作业/33.电话聊天狂人.exe differ
diff --git a/编程作业/34.Hashing.cpp b/编程作业/34.Hashing.cpp
new file mode 100644
index 0000000..d8651ee
--- /dev/null
+++ b/编程作业/34.Hashing.cpp
@@ -0,0 +1,102 @@
+#include<iostream>
+#include<cmath>
+#include<stdlib.h>
+#define MAXTABLESIZE 100000
+#define NOTFIND -1
+typedef int ElementType;
+typedef enum{     // ��Ԫ��״̬ 
+	Legitimate,Empty
+} EntryType;   // �ֱ��Ӧ���кϷ�Ԫ�غ��п�λ 
+typedef struct HashEntry Cell;
+struct HashEntry{   // ��Ԫ�� 
+	ElementType data;  // ��ֵ
+	EntryType info;   // ��״̬ 
+};
+typedef struct HashTbl *HashTable;
+struct HashTbl{  // ��ϣ��
+	int TableSize;  // ��С 
+	Cell *Cells;   // ���� 
+};
+using namespace std;
+
+// ������������ϣ���� 
+int Hash(int key,int p){
+	return key%p;
+}
+
+// ������һ������ 
+int NextPrime(int N){
+	int p = N%2?N:N+1;
+	int i;
+	if(N<=2)
+		return 2;
+	else if(N<=3)
+		return 3; 
+	while(p <= MAXTABLESIZE){
+		for(i=(int)sqrt(p);i>2;i--)
+			if(!(p%i))   // �������� 
+				break;
+		if(i==2)  // �ҵ���
+			break;
+		p += 2; 
+	}
+	return p;
+}
+
+// ������ϣ�� 
+HashTable CreateTable(int TableSize){
+	HashTable H;
+	H = (HashTable)malloc(sizeof(struct HashTbl));
+	H->TableSize = NextPrime(TableSize);
+	H->Cells = (Cell *)malloc(sizeof(struct HashEntry)*H->TableSize);
+	for(int i=0;i<H->TableSize;i++)
+		H->Cells[i].info = Empty;
+	return H;	
+}
+
+//����
+int Find(HashTable H,ElementType key){
+	int NewPos,CurrentPos;
+	int CNum = 0;  // ��¼��ͻ���� 
+	CurrentPos = NewPos = Hash(key,H->TableSize);
+	// �����ǰ״̬��Ϊ�գ���һֱ���ȣ�һֱ�� 
+	while(H->Cells[NewPos].info != Empty && H->Cells[NewPos].data != key){
+		CNum++;
+		NewPos = (CurrentPos + CNum*CNum)%H->TableSize;
+		if(CNum == H->TableSize/2) // û�ҵ�
+			return NOTFIND;
+	}
+	return NewPos;
+}
+
+int Insert(HashTable H,ElementType key){
+	int pos;
+	pos = Find(H,key);
+	if(pos==NOTFIND) // ���û�ҵ� 
+		return NOTFIND;
+	else if(H->Cells[pos].info != Legitimate){
+		H->Cells[pos].info = Legitimate;
+		H->Cells[pos].data = key;
+	}
+	return pos;
+} 
+
+int main(){
+	HashTable H;
+	int M,N;
+	int key;
+	cin>>M>>N;
+	H = CreateTable(M);
+	for(int i=0;i<N;i++){
+		cin>>key;
+		int pos = Insert(H,key);
+		if(i)
+			cout<<" ";
+		if(pos==NOTFIND)
+			cout<<"-";
+		else
+			cout<<pos;
+	}
+	return 0;
+}
+
diff --git a/编程作业/34.Hashing.exe b/编程作业/34.Hashing.exe
new file mode 100644
index 0000000..71e2a8e
Binary files /dev/null and b/编程作业/34.Hashing.exe differ
diff --git a/编程作业/35.QQ帐户的申请与登陆.cpp b/编程作业/35.QQ帐户的申请与登陆.cpp
new file mode 100644
index 0000000..777904f
--- /dev/null
+++ b/编程作业/35.QQ帐户的申请与登陆.cpp
@@ -0,0 +1,140 @@
+/*
+#include<iostream>
+#include<stdlib.h>
+#include<string>
+#include<cmath>
+#define MAXTABLESIZE 1000000
+using namespace std;
+typedef struct Node Cell;
+struct Node{
+	bool exist;
+	string acc;   // �˺�
+	string pas;  // ���� 
+};
+
+typedef struct HashTBL *HashTable; 
+struct HashTBL{
+	int TableSize;
+	Cell *users;
+};
+
+int Hash(int key,int p){
+	return key%p;
+}
+
+int NextPrime(int N){
+	int p = N%2?N+2:N+1;
+	int i;
+	while(p <= MAXTABLESIZE) {  
+		for(i=(int)sqrt(p);i>2;i--)
+			if(!(p%i))
+				break;
+		if(i==2 && p%4==3) // ��֤ƽ��̽�ⶼ���ҵ� 
+			break;
+		p +=2;
+	}
+	return p;
+}
+
+// ��ʼ�� 
+HashTable Create(int TableSize){
+	HashTable H;
+	H = (HashTable)malloc(sizeof(struct HashTBL));
+	H->TableSize = NextPrime(TableSize);
+	H->users = new Node[H->TableSize];
+	for(int i=0;i<H->TableSize;i++)
+		H->users[i].exist = false;
+	return H;
+}
+
+int Find(HashTable H,string key){
+	int NewPos,CurrentPos;
+	int CNum = 0;
+	NewPos = CurrentPos = Hash(atoi(key.c_str()),H->TableSize);
+	while(H->users[NewPos].exist && H->users[NewPos].acc != key){
+		if(++CNum %2){
+			NewPos =( CurrentPos + (CNum+1)/2*(CNum+1)/2 )%H->TableSize;
+		}else{
+			NewPos = CurrentPos - CNum/2*CNum/2;
+			while(NewPos < 0)
+				NewPos += H->TableSize;
+		}
+	}
+	return NewPos;
+}
+
+void Insert(HashTable H,string key,string pas,char flag){
+	int pos;
+	pos = Find(H,key);
+	if(H->users[pos].exist){  // �Ѿ����� 
+		if(flag == 'L'){   // ��½ 
+			if(pas == H->users[pos].pas)   // ������ȷ����½�ɹ� 
+				cout<<"Login: OK"<<endl;
+			else   // ������󣬵�½ʧ�� 
+				cout<<"ERROR: Wrong PW"<<endl;
+		}else if(flag == 'N'){  // ע��ʧ�� 
+			cout<<"ERROR: Exist"<<endl;
+		} 
+	}else{  // ������ 
+		if(flag == 'L')   // ��½ʧ�� 
+			cout<<"ERROR: Not Exist"<<endl;
+		else if(flag == 'N'){ // ע��ɹ� 
+			cout<<"New: OK"<<endl; 
+			H->users[pos].exist = true;
+			H->users[pos].pas = pas;
+			H->users[pos].acc = key;
+		}
+	}
+}
+
+int main(){
+	HashTable H;
+	int N;
+	char command;
+	string account;
+	string password;
+	cin>>N;
+	H = Create(N);
+	for(int i=0;i<N;i++){
+		cin>>command>>account>>password;
+		Insert(H,account,password,command);
+	} 
+	return 0;
+}*/
+
+
+#include<cstdio>
+#include<iostream>
+#include<map>
+#include<string>
+using namespace std;
+int main(){
+	int N;
+	char command;
+	string qq;
+	string ps;
+	map<string,string> m;
+	scanf("%d",&N);
+	for(int i=0;i<N;i++){
+		getchar();
+		scanf("%c",&command);
+		cin>>qq>>ps;
+		if(command == 'N'){     // ���û� 
+			if(m.find(qq)!=m.end())    // qq���Ѿ����� 
+				printf("ERROR: Exist");
+			else{    // ע��ɹ� 
+				printf("New: OK");
+				m[qq] = ps;
+			}
+		}else if(command == 'L'){  // ���û� 
+			if(m.find(qq)==m.end())  // û�ҵ� 
+				printf("ERROR: Not Exist"); 
+			else if(m[qq] == ps)   // ������ȷ 
+				printf("Login: OK");
+			else   
+				printf("ERROR: Wrong PW");
+		}
+		printf("\n");
+	} 
+	return 0;
+}
diff --git a/编程作业/35.QQ帐户的申请与登陆.exe b/编程作业/35.QQ帐户的申请与登陆.exe
new file mode 100644
index 0000000..e0f9394
Binary files /dev/null and b/编程作业/35.QQ帐户的申请与登陆.exe differ
diff --git a/编程作业/36.Hashing - Hard Version.cpp b/编程作业/36.Hashing - Hard Version.cpp
new file mode 100644
index 0000000..ef8c05a
--- /dev/null
+++ b/编程作业/36.Hashing - Hard Version.cpp	
@@ -0,0 +1,73 @@
+#include<queue>
+#include<iostream>
+#include<vector>
+#include<map>
+#define INF -100000
+#define MaxVertex 1005
+int G[MaxVertex][MaxVertex];
+int Indegree[MaxVertex];  // ��� 
+int value[MaxVertex];  // ��ֵ 
+int N;  // ��ֵ
+using namespace std;
+priority_queue<int,vector<int>,greater<int> > q;   // �������� 
+map<int,int> m;
+
+// ����� 
+void Insert(){
+	for(int i=0;i<N;i++){ 
+		if(0 <= value[i]){
+			m.insert(pair<int,int>(value[i],i));   // ���±���ֵ��ӳ���ϵ 
+			int remainder = value[i]%N;  // ���� 
+			if(remainder==i)
+				Indegree[i] = 0;
+			else if(remainder != i){
+				Indegree[i] = (i - remainder < 0)?(i - remainder + N):(i - remainder);
+				for(int j=remainder;j!=i;j=(j+1)%N)
+					G[j][i] = 1;
+			}
+		}
+	}
+}
+
+// ��ʼ��ͼ 
+void build(){
+	for(int i=0;i<N;i++)
+		for(int j=0;j<N;j++)
+			G[i][j] = INF;
+	Insert();
+}
+
+// �������� 
+void TopSort(){
+	for(int i=0;i<N;i++)
+		if(!Indegree[i] && 0 < value[i])
+			q.push(value[i]);
+	bool flag = true;
+	while(!q.empty()){
+		int tmpValue = q.top(); 
+		int v = m[tmpValue];  // �һ��±� 
+		q.pop();
+		if(flag)
+			flag = false;
+		else
+			cout<<" ";
+		cout<<tmpValue;
+		for(int w=0;w<N;w++)
+			if(G[v][w]!=INF){  // �����ͨ 
+				if(--Indegree[w]==0)
+					q.push(value[w]);
+			}
+	}
+}
+
+
+int main(){
+	cin>>N;
+	int i=0;
+	for(int i=0;i<N;i++)
+		cin>>value[i];
+	build();
+
+	TopSort();
+	return 0;
+}
diff --git a/编程作业/36.Hashing - Hard Version.exe b/编程作业/36.Hashing - Hard Version.exe
new file mode 100644
index 0000000..bae62fd
Binary files /dev/null and b/编程作业/36.Hashing - Hard Version.exe differ
diff --git a/编程作业/37.KMP 串的模式匹配.cpp b/编程作业/37.KMP 串的模式匹配.cpp
new file mode 100644
index 0000000..875a4f9
--- /dev/null
+++ b/编程作业/37.KMP 串的模式匹配.cpp	
@@ -0,0 +1,86 @@
+/*#include<iostream>
+#include<stdio.h>
+#include<string.h>
+#include<stdlib.h>
+typedef int Position;
+#define NotFound -1 
+using namespace std;
+
+void BuildMatch(char *pattern,int *match){
+	int i,j;
+	int m = strlen(pattern);
+	match[0] = -1;
+	for(j=1;j<m;j++){
+		i = match[j-1];
+		while((i>=0) && (pattern[i+1] != pattern[j]))
+			i = match[i];
+		if(pattern[i+1] == pattern[j])
+			match[j] = i+1;
+		else
+			match[j] = -1; 
+	}
+}
+
+Position KMP(char* string,char *pattern){
+	int n = strlen(string);
+	int m = strlen(pattern);
+	int s,p;
+	if(n < m)
+		return NotFound;
+	int *match = (int *)malloc(sizeof(int) * m);
+	BuildMatch(pattern,match);
+	s = p = 0;
+	while(s < n && p < m){
+		if(string[s] == pattern[p]){
+			s++;
+			p++;
+		}else if(p>0)
+			p = match[p-1]+1;
+		else
+			s++;
+	}
+	return (p == m) ? (s-m) : NotFound;
+}
+
+int main(){
+	char *string;
+	char *pattern;
+	Position p;
+	int N;
+	int i;
+	string = (char *)malloc(sizeof(char) * 100005);
+	pattern = (char *)malloc(sizeof(char) * 10005);
+	scanf("%s %d",string,&N);
+	for(i=0;i<N;i++){
+		scanf("%s",pattern);
+		p = KMP(string,pattern);
+		if(p == NotFound)
+			printf("Not Found\n");
+		else
+			printf("%s\n",p+string);
+	}
+	return 0;
+}*/
+#include<iostream>
+#include<string.h>
+#include<string>
+typedef char *Position;
+#define NotFound NULL 
+using namespace std;
+
+int main(){
+	string str;
+	string pat;
+	Position p;
+	int N;
+	cin>>str>>N;
+	for(int i=0;i<N;i++){
+		cin>>pat;
+		p = strstr(str.c_str(),pat.c_str());
+		if(p == NotFound)
+			cout<<"Not Found"<<endl;
+		else
+			cout<<p<<endl;
+	}
+	return 0;
+}
diff --git a/编程作业/37.KMP 串的模式匹配.exe b/编程作业/37.KMP 串的模式匹配.exe
new file mode 100644
index 0000000..0ae5ac1
Binary files /dev/null and b/编程作业/37.KMP 串的模式匹配.exe differ
diff --git a/编程作业/4.两个有序链表序列的合并.cpp b/编程作业/4.两个有序链表序列的合并.cpp
new file mode 100644
index 0000000..aacaf47
--- /dev/null
+++ b/编程作业/4.两个有序链表序列的合并.cpp
@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef int ElementType;
+typedef struct Node *PtrToNode;
+struct Node {
+    ElementType Data;
+    PtrToNode   Next;
+};
+typedef PtrToNode List;
+
+List Read(); /* ϸ���ڴ˲��� */
+void Print( List L ); /* ϸ���ڴ˲����������������NULL */
+
+List Merge( List L1, List L2 );
+
+int main()
+{
+    List L1, L2, L;
+    L1 = Read();
+    L2 = Read();
+    L = Merge(L1, L2);
+    Print(L);
+    Print(L1);
+    Print(L2);
+    return 0;
+}
+
+List Merge( List L1, List L2 ){
+	List L=(List)malloc(sizeof(struct Node));
+	List head = L;
+	List tmpL1 = L1->Next;
+	List tmpL2 = L2->Next;
+	while(tmpL1 && tmpL2){
+		if(tmpL1->Data < tmpL2->Data){
+			L->Next=tmpL1;
+			tmpL1=tmpL1->Next;
+		}else{
+			L->Next=tmpL2;
+			tmpL2=tmpL2->Next;
+		}
+		L=L->Next;
+	}
+	if(tmpL1)
+		L->Next=tmpL1;
+	if(tmpL2)
+		L->Next=tmpL2;
+	L1->Next = NULL;
+	L2->Next = NULL;
+	return head;
+} 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/编程作业/4.两个有序链表序列的合并.exe b/编程作业/4.两个有序链表序列的合并.exe
new file mode 100644
index 0000000..7774d70
Binary files /dev/null and b/编程作业/4.两个有序链表序列的合并.exe differ
diff --git a/编程作业/5.一元多项式的乘法与加法运算.cpp b/编程作业/5.一元多项式的乘法与加法运算.cpp
new file mode 100644
index 0000000..0256c74
--- /dev/null
+++ b/编程作业/5.一元多项式的乘法与加法运算.cpp
@@ -0,0 +1,108 @@
+#include<stdio.h>
+#include<stdlib.h>
+typedef struct Node *List;
+struct Node{
+	List Next;
+	int z;   // ָ�� 
+	int x;  // ϵ�� 
+};
+
+// �������� 
+List Read(){
+	List L = (List)malloc(sizeof(struct Node));
+	List head = L;
+	int n;
+	int i=0;
+	scanf("%d",&n);
+	for(i=0;i<n;i++){
+		int x;
+		int z;
+		List t = (List)malloc(sizeof(struct Node));
+		scanf("%d %d",&x,&z);
+		t->x = x;
+		t->z = z;
+		L->Next = t;
+		L = L->Next;
+	}
+	L->Next = NULL;
+	return head->Next;
+}
+
+// ʵ�ּӷ����� 
+List addition(List L1,List L2){
+	List tmpL1 = L1;
+	List tmpL2 = L2;
+	List add=(List)malloc(sizeof(struct Node));
+	add->Next = NULL;
+	List head = add;
+	List t;
+	while(tmpL1 && tmpL2){
+		t = (List)malloc(sizeof(struct Node));
+		if(tmpL1->z == tmpL2->z){  //ָ����ȣ�ϵ�����  
+			t->x = tmpL1->x + tmpL2->x;
+			t->z = tmpL1->z;
+			tmpL1 = tmpL1->Next;
+			tmpL2 = tmpL2->Next;
+		}else if(tmpL1->z < tmpL2->z){   // L2 ���ָ�����󣬰� L2 ���������� 
+			t->x = tmpL2->x;
+			t->z = tmpL2->z;
+			tmpL2 = tmpL2->Next;
+		}else if(tmpL2->z < tmpL1->z){   // L1 ���ָ�����󣬰� L1 ���������� 
+			t->x = tmpL1->x;
+			t->z = tmpL1->z;
+			tmpL1 = tmpL1->Next;
+		}
+		add->Next = t;
+		add = add->Next; 
+	}
+	if(tmpL1)   // �� L1 ������ NULL����ʣ�½�������� 
+		add->Next = tmpL1;
+	else if(tmpL2)  // ͬ�� 
+		add->Next = tmpL2;
+	return head->Next; // head ���ֻ��ָ�����ֵ 
+}
+
+// ʵ�ֳ˷����� 
+List multiplication(List L1,List L2){
+	List tmpL1 = L1;
+	List tmpL2 = L2;
+	List mul=(List)malloc(sizeof(struct Node));
+	mul->Next = NULL;
+	List head = mul;
+	List t;
+	for(;tmpL1;tmpL1=tmpL1->Next)
+		for(tmpL2 = L2;tmpL2;tmpL2=tmpL2->Next){
+			t = (List)malloc(sizeof(struct Node));
+			t->x = tmpL1->x * tmpL2->x;  // ϵ�����
+			t->z = tmpL1->z + tmpL2->z;  // ָ�����
+			t->Next = NULL;
+			head = addition(t,mul);  // ����������֮ǰ�Ѿ��ź���Ľ������ 
+			mul = head; // ����ȷ����ͷ 
+		}
+	return head;
+}
+void Print(List L){
+	List t = L;
+	int flag = 1;
+	for(;t;t = t->Next){
+		if(!flag && t->x)   //���ƿո����
+			printf(" ");
+		if(t->x){   // ���ϵ��Ϊ 0������� 
+			printf("%d %d",t->x,t->z);
+			flag =0;		
+		}
+	}
+	if(flag)
+		printf("0 0");
+	printf("\n");
+}
+int main(){
+	List L1,L2,add,mul;
+	L1 = Read();
+	L2 = Read();
+	add = addition(L1,L2);
+	mul = multiplication(L1,L2);
+	Print(mul);
+	Print(add);
+	return 0;
+} 
diff --git a/编程作业/5.一元多项式的乘法与加法运算.exe b/编程作业/5.一元多项式的乘法与加法运算.exe
new file mode 100644
index 0000000..744544d
Binary files /dev/null and b/编程作业/5.一元多项式的乘法与加法运算.exe differ
diff --git a/编程作业/6.Reversing Linked List.cpp b/编程作业/6.Reversing Linked List.cpp
new file mode 100644
index 0000000..1cc3229
--- /dev/null
+++ b/编程作业/6.Reversing Linked List.cpp	
@@ -0,0 +1,33 @@
+#include<stdio.h>
+#include<iostream>
+#define MaxSize 100005
+using namespace std;
+int main(){
+	int Data[MaxSize];
+	int Next[MaxSize];
+	int list[MaxSize];
+	int FirstAdd,N,K;
+	scanf("%d %d %d",&FirstAdd,&N,&K);
+	for(int i=0;i<N;i++){
+		int tmpAdd,tmpData,tmpNext;
+		scanf("%d %d %d",&tmpAdd,&tmpData,&tmpNext);
+		Data[tmpAdd] = tmpData;
+		Next[tmpAdd] = tmpNext;
+	}
+	int sum=0;   // �ۼ���Ч����� 
+	while(FirstAdd!=-1){   // ��β���Ϊ -1 ʱ���� 
+		list[sum++] = FirstAdd;   // ��¼����Address
+		FirstAdd = Next[FirstAdd];  // ����һ����� 
+	}
+	for(int i=0;i<sum-sum%K;i+=K){  // ÿ K �����һ������ 
+		for(int j=0;j<K/2;j++){  // ��ת����
+			int t = list[i+j];
+			list[i+j] = list[i+K-j-1];
+			list[i+K-j-1] = t; 
+		}
+	}
+	for(int i=0;i<sum-1;i++)
+		printf("%05d %d %05d\n",list[i],Data[list[i]],list[i+1]);
+	printf("%05d %d -1\n",list[sum-1],Data[list[sum-1]]);
+	return 0;
+}
diff --git a/编程作业/6.Reversing Linked List.exe b/编程作业/6.Reversing Linked List.exe
new file mode 100644
index 0000000..eb7828a
Binary files /dev/null and b/编程作业/6.Reversing Linked List.exe differ
diff --git a/编程作业/7.Pop Sequence.cpp b/编程作业/7.Pop Sequence.cpp
new file mode 100644
index 0000000..58e6e2e
--- /dev/null
+++ b/编程作业/7.Pop Sequence.cpp	
@@ -0,0 +1,29 @@
+#include<iostream>
+#include<vector>
+#include<stack>
+using namespace std;
+int main(){
+	int m,n,k;
+	cin>>m>>n>>k;
+	for(int i=0;i<k;i++){
+		stack<int> s;
+		vector<int> v(n + 1);
+		for(int j=1;j<=n;j++)
+			cin>>v[j];
+		int cur=1;
+		for(int j=1;j<=n;j++){
+			s.push(j);
+			if(s.size() > m)
+				break;
+			while(!s.empty() && s.top()==v[cur]){
+				s.pop();
+				cur++;
+			}
+		}
+		if(cur == n+1)
+			cout<<"YES"<<endl;
+		else
+			cout<<"NO"<<endl;
+	}
+	return 0;
+}
diff --git a/编程作业/7.Pop Sequence.exe b/编程作业/7.Pop Sequence.exe
new file mode 100644
index 0000000..cbbdc8f
Binary files /dev/null and b/编程作业/7.Pop Sequence.exe differ
diff --git a/编程作业/8.树的同构.cpp b/编程作业/8.树的同构.cpp
new file mode 100644
index 0000000..168930b
--- /dev/null
+++ b/编程作业/8.树的同构.cpp
@@ -0,0 +1,59 @@
+#include<iostream>
+#include<malloc.h>
+#define null -1
+using namespace std;
+struct TreeNode{
+	char data;    // ��ֵ 
+	int left;   // ���������±� 
+	int right;  // ���������±� 
+}T1[10],T2[10];
+// ���ظ���� 
+int create(struct TreeNode T[]){
+	int n;
+	int root = 0;
+	char left,right;
+	cin>>n;
+	if(!n)
+		return null;
+	for(int i=0;i<n;i++){
+		cin>>T[i].data>>left>>right;
+		if(left=='-')
+			T[i].left = null;
+		else{
+			T[i].left = left-'0';
+			root -= T[i].left;
+		}
+		if(right=='-')
+			T[i].right = null;
+		else{
+			T[i].right = right-'0';
+			root -= T[i].right;
+		}
+		// 0 �ۼӵ� n-1 
+		root +=i;	
+	}
+	return root;
+}
+// �ж��Ƿ�ͬ��
+bool judge(int R1,int R2){
+	if(R1 == null && R2 == null)   // ���� 
+		return true;
+	if(R1 == null && R2 != null || R1 != null && R2 == null)    // һ��Ϊ�գ�һ����Ϊ��
+		return false;
+	if(T1[R1].data != T2[R2].data)   // ֵ��ͬ
+		return false;
+	if((T1[R1].left != null && T2[R2].left != null )&&(T1[T1[R1].left].data == T2[T2[R2].left].data))  // ����Ӳ�Ϊ����ֵ���
+		return judge(T1[R1].left,T2[R2].left) && judge(T1[R1].right,T2[R2].right);
+	else   // ����Ӳ�Ϊ����ֵ����  ���� ijһ�������Ϊ�� 
+		return judge(T1[R1].right,T2[R2].left) && judge(T1[R1].left,T2[R2].right);
+} 
+int main(){
+	int R1,R2;
+	R1 = create(T1);
+	R2 = create(T2);
+	if(judge(R1,R2))
+		cout<<"Yes";
+	else
+		cout<<"No";
+	return 0;
+} 
diff --git a/编程作业/8.树的同构.exe b/编程作业/8.树的同构.exe
new file mode 100644
index 0000000..8013c7f
Binary files /dev/null and b/编程作业/8.树的同构.exe differ
diff --git a/编程作业/9.List Leaves.cpp b/编程作业/9.List Leaves.cpp
new file mode 100644
index 0000000..fedcdcf
--- /dev/null
+++ b/编程作业/9.List Leaves.cpp	
@@ -0,0 +1,71 @@
+#include<queue>
+#include<iostream> 
+#define null -1
+using namespace std;
+struct TreeNode{
+	int data;  // ��ֵ
+	int left;  // ������ӽ�� 
+	int right;   // ���Ҷ��ӽ�� 
+}T[10];
+//  ������������ 
+int create(){
+	int n;
+	int root = 0;
+	char left,right;
+	cin>>n;
+	if(!n)
+		return null;
+	for(int i=0;i<n;i++){
+		T[i].data = i;
+		cin>>left>>right;
+		if(left=='-')
+			T[i].left = null;
+		else{
+			T[i].left = left-'0';
+			root -= T[i].left;
+		}
+		if(right=='-')
+			T[i].right = null;
+		else{
+			T[i].right = right-'0';
+			root -= T[i].right;
+		}
+		root +=i;
+	}
+	return root;
+}
+// ������� 
+void LevelorderTraversal(int root){
+	// �������� 
+	queue<struct TreeNode> q;
+	struct TreeNode t;
+	bool flag = false;
+	
+	// �����Ϊ�գ�ֱ�Ӵ�ӡ 
+	if(root == null){
+		cout<<"-";
+		return;	
+	}
+	q.push(T[root]);
+	while(!q.empty()){
+		t = q.front();  // �õ���ǰ����Ԫ�� 
+		q.pop();  // ���� 
+		if(t.left == null && t.right == null){  // ���ΪҶ�ӽ������ 
+			if(flag)
+				cout<<" ";
+			else
+				flag = true;
+			cout<<t.data;	
+		}
+		if(t.left != null)  // ���������ӽ�㣬�������ӽ�� 
+			q.push(T[t.left]);
+		if(t.right != null)  // ������Ҷ��ӽ�㣬����Ҷ��ӽ�� 
+			q.push(T[t.right]);
+	}
+} 
+int main(){
+	int root;
+	root = create();
+	LevelorderTraversal(root);
+	return 0;
+} 
diff --git a/编程作业/9.List Leaves.exe b/编程作业/9.List Leaves.exe
new file mode 100644
index 0000000..e05173f
Binary files /dev/null and b/编程作业/9.List Leaves.exe differ