diff --git "a/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/LinkList.c" "b/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/LinkList.c"
new file mode 100644
index 00000000..6369443f
--- /dev/null
+++ "b/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/LinkList.c"
@@ -0,0 +1,69 @@
+#include "LinkList.h"
+
+/* 链表的遍历 */
+void TraverseList(LinkList p) {
+	LinkList l = p;
+	l = l->next;
+	while ( l != p) {
+		printf("%d ",l->data);
+		l = l->next;
+	}
+	printf("\n");
+}
+
+/* 创建链表 */
+LinkList CreatList( int n) {
+	LNode *L,* p;
+	int i;
+	L = (LinkList)malloc(sizeof(LNode));
+	L->next = L;
+	L->data = n;
+	if (!L)
+		exit(1);
+	for (i = 0; i < n ; i++) {
+		p = (LinkList)malloc(sizeof(LNode));
+		if (!p)
+			exit(1);
+		p->data = i;
+		p->next = L->next;
+		L->next = p;
+	}
+	return L;
+}
+
+/*初始化链表*/
+void InitList(LinkList a) {
+	LinkList p = a;
+	for (; p->next != a; p = p->next) {
+		p->data = 0;
+
+	}
+}
+
+/* 拆分链表 */
+void SeparateList(LinkList A, LinkList b, LinkList c) {
+//算法分析：算法的的时间复杂度为 O（n），空间复杂度为O（1），
+//在保证算法的正确性的前提下，使用了最少的时间复杂度和最少的空间复杂度
+	LinkList p = A,p1 = b,p2 = c;
+	InitList(b);
+	InitList(c);
+	p = p->next;
+	p1 = p1->next;
+	p2 = p2->next;
+	while ( p != A) {
+		p1->data = p->data;
+		b->data++;
+		p1 = p1->next;
+		p = p->next;
+		if (p != A) {
+			p2->data = p->data;
+			c->data++;
+			p2 = p2->next;
+			p = p->next;
+		}
+	}
+	return;
+}
+
+
+
diff --git "a/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/LinkList.h" "b/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/LinkList.h"
new file mode 100644
index 00000000..838452cd
--- /dev/null
+++ "b/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/LinkList.h"
@@ -0,0 +1,30 @@
+#pragma once
+#ifndef LINKLIST_H
+#define LINKLIST_H
+#include<stdio.h>
+#include<stdlib.h>
+#define length 10
+
+typedef  struct LNode {
+	int data;
+	struct LNode *next;
+}LNode, *LinkList;
+
+typedef enum {
+	true,
+	false
+}bool;
+
+/* 链表的遍历 */
+void TraverseList(LNode * p);
+
+/* 创建链表 */
+LinkList CreatList(int n);
+
+/* 拆分链表 */
+void SeparateList(LinkList A, LinkList b, LinkList c);
+
+/*初始化链表*/
+void InitList(LinkList);
+
+#endif
\ No newline at end of file
diff --git "a/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/main_LinkList.c" "b/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/main_LinkList.c"
new file mode 100644
index 00000000..14387f01
--- /dev/null
+++ "b/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/main_LinkList.c"
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include "LinkList.h"
+#define length 20
+int main() {
+	LinkList A = CreatList(length),
+		a1 = CreatList(length/2),
+		a2 = CreatList(length/2);
+	TraverseList(A);
+	SeparateList(A, a1, a2);
+	TraverseList(a1);
+	TraverseList(a2);
+	return 0;
+}
\ No newline at end of file
diff --git "a/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/main_LinkList.txt" "b/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/main_LinkList.txt"
new file mode 100644
index 00000000..aaed159d
--- /dev/null
+++ "b/2017-1/Cloud/1.\347\272\277\346\200\247\350\241\250\347\232\204\345\237\272\346\234\254\346\223\215\344\275\234/main_LinkList.txt"
@@ -0,0 +1,3 @@
+19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 
+19 17 15 13 11 9 7 5 3 1 
+18 16 14 12 10 8 6 4 2 0 
diff --git "a/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/BST.c" "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/BST.c"
new file mode 100644
index 00000000..1580e568
--- /dev/null
+++ "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/BST.c"
@@ -0,0 +1,138 @@
+#include "BST.h"
+
+/* 查找表的初始化建立 */
+Status _CreateBST(BiTree *T, TElemType * c) {
+	int i;
+	for (i = 0; c[i] != -1; i++) {
+		InsertBST(T, c[i]);
+	}
+	return OK;
+}
+
+/* 在T树中查找关键字key */
+Status SearchBST(BiTree T, TElemType key, BiTree f, BiTree * p) {
+	if (!T) {
+		*p = f;
+		return FALSE;
+	}
+	else if (key == T->data) {
+		*p = T;
+		return TRUE;
+	}
+	else if (key < (*T).data) {
+		return SearchBST((*T).lchild, key, T, p);
+	}
+	else {
+		return SearchBST((*T).rchild, key, T, p);
+	}
+}
+
+/* c插入关键字key */
+Status InsertBST(BiTree *T, TElemType key) {
+	BiTree p, s;
+	if (!SearchBST(*T, key, NULL, &p)) {
+		s = (BiTree)malloc(sizeof(BiTNode));
+		s->data = key;
+		s->lchild = NULL;
+		s->rchild = NULL;
+		s->parent = NULL;
+		if (!p) {
+			*T = s;
+		}
+		else if (key < p->data) {
+			p->lchild = s;
+			s->parent = p;
+		}
+		else {
+			p->rchild = s;
+			s->parent = p;
+		}
+		return TRUE;
+	}
+	else {
+		return FALSE;
+	}
+}
+
+/*查找表的初始化建立和查找 */
+Status _Search(BiTree T, TElemType * a) {
+	//如果未找到则将当前关键字添加到当前查找表中，如果找到，则删除该关键字所在结点
+	BiTree p, f = NULL;
+	int i;
+	for (i = 0; a[i] != -1; i++) {
+		if (SearchBST(T, a[i], f, &p)) {
+			Delete(p, f);
+		}
+		else {
+			InsertBST(&T, a[i]);
+		}
+		_print(T);
+	}
+	return OK;
+}
+
+/* 先序遍历二叉树 */
+Status PreOrderTraverse(BiTree T, int i) {
+	if (T == NULL) {
+		return OK;
+	}
+	if (T) {
+		if (i == 0) {	/* 访问结点*/
+			printf("%d", T->data);
+			i++;
+		}
+		else
+			printf(", %d", T->data);
+		PreOrderTraverse(T->lchild, i); /* 遍历左子树*/
+		PreOrderTraverse(T->rchild, i); /* 遍历右子树*/
+	}
+	return 0;
+}
+
+/* 删除一个结点 */
+Status Delete(BiTree  p, BiTree f) {
+	BiTree q, s;
+	q = p;
+	if (!p->rchild) {
+		if (p->parent->rchild == p) {
+			p->parent->rchild = p->lchild;
+		}
+		else {
+			p->parent->lchild = p->lchild;
+		}
+		free(q);
+	}
+	else if (!p->lchild) {
+		if (p->parent->rchild == p) {
+			p->parent->rchild = p->rchild;
+		}
+		else {
+			p->parent->lchild = p->rchild;
+		}
+		free(q);
+	}
+	else {
+		s = p->lchild;
+		while (s->rchild) {
+			q = s;
+			s = s->rchild;
+		}
+		p->data = s->data;
+		if (q != p) {
+			q->rchild = s->lchild;
+		}
+		else {
+			q->lchild = s->lchild;
+		}
+		free(s);
+	}
+	return OK;
+}
+
+/* 打印一遍查找表 */
+Status _print(BiTree T) {
+	static int i = 0;
+	PreOrderTraverse(T, i);
+	printf("\n");
+	return OK;
+}
\ No newline at end of file
diff --git "a/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/BST.h" "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/BST.h"
new file mode 100644
index 00000000..32756c6b
--- /dev/null
+++ "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/BST.h"
@@ -0,0 +1,44 @@
+#ifndef BST_H
+#define BST_H
+#include <stdio.h>
+#include <stdlib.h>
+#define TElemType int 
+#define KeyType int 
+
+typedef struct BiTNode {
+	TElemType data;
+	struct BiTNode *lchild, *rchild, *parent;
+
+}BiTNode, *BiTree;
+typedef enum {
+	FALSE,
+	TRUE
+}bool;
+typedef enum {
+	OK,
+	ERROR,
+	OVERFLOW
+}Status;
+
+/* 查找表的初始化建立 */
+Status _CreateBST(BiTree *T, TElemType * c);
+
+/* 在T树中查找关键字key */
+Status SearchBST(BiTree T, TElemType key, BiTree f, BiTree * p);
+
+/* c插入关键字key */
+Status InsertBST(BiTree *T, TElemType key);
+
+/* 打印一遍查找表 */
+Status _print(BiTree T);
+
+/* 先序遍历二叉树 */
+Status PreOrderTraverse(BiTree T, int i);
+
+/* 删除一个结点 */
+Status Delete(BiTree  p, BiTree f);
+
+/* 在查找表中查找 */
+Status _Search(BiTree T, TElemType * a);
+
+#endif // !1
diff --git "a/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/BSTOutput.txt" "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/BSTOutput.txt"
new file mode 100644
index 00000000..eea55310
--- /dev/null
+++ "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/BSTOutput.txt"
@@ -0,0 +1,6 @@
+8, 3, 1, 6, 4, 5, 7, 10, 14, 19, 22, 30
+8, 3, 1, 6, 4, 5, 7, 10, 14, 13, 19, 22, 30
+7, 3, 1, 6, 4, 5, 10, 14, 13, 19, 22, 30
+7, 3, 1, 6, 4, 10, 14, 13, 19, 22, 30
+7, 3, 1, 6, 4, 10, 14, 13, 19, 22, 20, 30
+7, 3, 1, 4, 10, 14, 13, 19, 22, 20, 30
\ No newline at end of file
diff --git "a/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/Hash.c" "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/Hash.c"
new file mode 100644
index 00000000..1d64c91f
--- /dev/null
+++ "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/Hash.c"
@@ -0,0 +1,158 @@
+#include "Hash.h"
+
+/* 初始化哈希表 */
+void InitHashTable(HashTable *H) {
+	int i;
+	H->count = 0;
+	H->sizeindex = SizeIndex;
+	H->elem = (ElemType*)malloc(H->sizeindex * sizeof(ElemType));
+	for (i = 0; i < H->sizeindex; i++) {
+		H->elem[i].key = NULLKEY;
+		H->elem[i].val = NULLKEY;
+	}
+}
+
+/* 用随机生成的正整数序列填充Hash表 */
+void CreateHashTable(HashTable * H) {
+	int i;
+	ElemType e;
+	for (i = 0; i < H->sizeindex; i++) {
+		e.val = rand() % 1024;
+		e.key = e.val % H->sizeindex;
+		InsertHash(H, e);
+	}
+	return;
+}
+
+/* 查找for本题 */
+void _Search(HashTable T) {
+	int i, p = 0, c = 0;
+	ElemType e;
+	printf("\n");
+	for (i = 0; i < 5; i++)
+	{
+		e.val = (T.elem[i].key + 1 + rand())%1024;
+		e.key = e.val % T.sizeindex;
+		if (SearchHash(T, e, &p, &c)) {
+			printf("关键字%d查找成功! 冲突次数%d\n", e.key, c);
+		}
+		else {
+			printf("关键字%d查找失败!\n", e.key);
+		}
+	}
+
+}
+
+/* 返回哈希地址 */
+int Hash(HashTable H,ValueType k) {
+	int p;
+	p = k%H.sizeindex;
+	return p;
+}
+
+/* 解决哈希冲突 */
+void collision(HashTable H,int *p, int *c) {
+	*c++;
+	*p = (*p + 1) % H.sizeindex;
+}
+
+/* 哈希表的查找 */
+Status SearchHash(HashTable H, ElemType e, int *p, int *c) {
+	// 在开放定址哈希表H中查找关键码为K的记录
+	// c用于记录冲突次数，初值置0
+	*p = e.key; // 求得哈希地址
+	while (H.elem[*p].key != NULLKEY && e.key != H.elem[*p].key) {
+		if(*p == H.sizeindex -1 )
+			return  FAILED;
+		collision(H,p, c);       // 求得下一探查地址 p
+	}
+	if (e.key == H.elem[*p].key) { // 查找成功，p返回待查数据元素位置
+		return SUCCESS;
+	}
+	else {
+		return FAILED;   // 查找不成功
+	}
+}
+
+/* 向哈希表中插入数据 */
+Status InsertHash(HashTable *H, ElemType e) {
+	// 查找不成功时插入数据元素e到开放地址哈希表H中，并返回OK
+	// 若冲突次数过大，则重建哈希表
+	int p, c;
+	c = 0;//记录冲突次数
+	if (SearchHash(*H, e, &p, &c) == SUCCESS) {
+		collision(*H,&p, &c);       // 表中已有与 e 有	相同关键字的元素
+		while ((*H).elem[p].key != NULLKEY /*&& e.key != (*H).elem[p].key*/) {
+			collision(*H,&p, &c);       // 求得下一探查地址 p
+		}
+		H->elem[p].val = e.val;
+		H->elem[p].key = e.key;
+		++H->count;
+		return DUPLICATE;
+	}
+	else if (c < H->sizeindex / 2) {
+		// 冲突次数 c 未达到上限，（阀值可调，此处仅为示例）
+		H->elem[e.key].val = e.val;
+		H->elem[e.key].key = e.key;
+		++H->count;
+		return SUCCESS;
+	}
+	else {
+		// 重建哈希表，极端情况下可能哈希表“已满”。
+		// 所以通常的重建过程都是先增大新哈希表的容量
+		RecreateHashTable(H);
+	}
+	return SUCCESS;
+}
+
+/* 重建哈希表 */
+void RecreateHashTable(HashTable *H) // 重建哈希表代码参考了csdn徐留根的发表 -【数据结构】哈希表
+{
+	printf("\n重建哈希表:\n");
+	int i, count = (*H).count,n = (*H).sizeindex;
+	ElemType *p , *elem = (ElemType*)malloc(count * sizeof(ElemType));
+	p = elem;
+	
+	(*H).count = 0;
+	for (i = 0; i < n; i++) { // 保存原有的数据到elem中   
+		if (((*H).elem + i)->key != NULLKEY) { // 该单元有数据   
+			*p++ = *((*H).elem + i);
+			/*p->val = ((*H).elem + i)->val;
+			p->key = Hash(*H, ((*H).elem + i)->val);
+			p++;*/
+		}
+	}
+
+	(*H).sizeindex += SizeIndex;
+	for (i = 0; i < n; i++) { 
+		if (((*H).elem + i)->key != NULLKEY) {
+			p->val = ((*H).elem + i)->val;
+			p->key = Hash(*H, ((*H).elem + i)->val);
+			p++;
+		}
+	}
+	 // 增大存储容量   
+	p = (ElemType*)malloc((*H).sizeindex * sizeof(ElemType));
+	if (!p)
+		exit(1); // 存储分配失败   
+   (*H).elem = p;
+	for (i = 0; i < (*H).sizeindex; i++) {
+		(*H).elem[i].key = -1; // 初始化   
+	    (*H).elem[i].val = -1;
+	}
+	for (p = elem; p < elem + count ; p++) // 将原有的数据按照新的表长插入到重建的哈希表中   
+		InsertHash(H, *p);
+}
+
+/* 打印哈希表 */
+void PrintHashTable(HashTable H){
+	int i = 0,j = 0;
+	for (; i < H.sizeindex; i++) {
+		// {[元素所在Hash表中的索引位置] : 关键字->值}
+		printf("{[%d] : %d->%d}   ", i, H.elem[i].key, H.elem[i].val);
+		j++;
+		if(j%3 == 0)
+			printf("\n");
+	}
+	printf("\n");
+}
diff --git "a/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/Hash.h" "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/Hash.h"
new file mode 100644
index 00000000..5bbaca22
--- /dev/null
+++ "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/Hash.h"
@@ -0,0 +1,58 @@
+#pragma once
+#ifndef Hash_h
+#define Hash_h
+#include <stdio.h>
+#include <stdlib.h>
+#
+#include <time.h>
+#define  SUCCESS    1
+#define  FAILED     0
+#define  DUPLICATE -1
+#define  NULLKEY -1
+#define  SizeIndex 7   // hash表的表长
+
+typedef int KeyType;
+typedef int ValueType;
+typedef int Status;
+
+typedef struct _ElemType {
+	KeyType key;      // 关键字
+	ValueType val;    // 值
+#ifdef CHAINED_HASH
+	struct _ElemType *next;
+#endif
+} ElemType;
+
+typedef struct {
+	ElemType  *elem;
+	int  count;     // 当前数据元素个数
+	int  sizeindex; // hashsize[sizeindex]为当前容量
+} HashTable;
+
+/* 初始化哈希表 */
+void InitHashTable(HashTable *H);
+
+/* 用随机生成的正整数序列填充Hash表(for本题) */
+void CreateHashTable(HashTable * H);
+
+/* 查找函数(for本题) */
+void _Search(HashTable T);
+
+/* 解决哈希冲突 */
+void collision(HashTable H, int *p, int *c);
+
+/* 返回哈希地址 */
+int Hash(HashTable H, ValueType k);
+
+/* 哈希表的查找 */
+Status SearchHash(HashTable H, ElemType e, int *p, int *c);
+
+/* 向哈希表中插入数据 */
+Status InsertHash(HashTable *H, ElemType e);
+
+/* 重建哈希表 */
+void RecreateHashTable(HashTable *H);
+
+/* 打印哈希表 */
+void PrintHashTable(HashTable H);
+#endif // !1
\ No newline at end of file
diff --git "a/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/main_BST.c" "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/main_BST.c"
new file mode 100644
index 00000000..3c63f45d
--- /dev/null
+++ "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/main_BST.c"
@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include "BST.h"
+int main() {
+	BiTree T = NULL;
+	TElemType c[] = { 8, 10, 14, 3, 1, 6, 4, 7, 5, 19, 22, 30 ,-1 },
+		s[] = { 13, 8, 5, 20, 6 ,-1 };
+	_CreateBST(&T, c);
+	_print(T);
+	_Search(T, s);
+	return 0;
+}
\ No newline at end of file
diff --git "a/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/main_Hash.c" "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/main_Hash.c"
new file mode 100644
index 00000000..1c49555a
--- /dev/null
+++ "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/main_Hash.c"
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include "Hash.h"
+int main() {
+	srand(time(NULL));
+	HashTable H;
+	InitHashTable(&H);
+	CreateHashTable(&H);
+	PrintHashTable(H);
+	_Search(H);
+	RecreateHashTable(&H);
+	PrintHashTable(H);
+	return 0;
+}
\ No newline at end of file
diff --git "a/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/main_Hash.png" "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/main_Hash.png"
new file mode 100644
index 00000000..a627b7e9
Binary files /dev/null and "b/2017-1/Cloud/5.\345\220\204\347\247\215\346\237\245\346\211\276\346\223\215\344\275\234/main_Hash.png" differ
diff --git "a/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/Sort.c" "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/Sort.c"
new file mode 100644
index 00000000..a0d08cc9
--- /dev/null
+++ "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/Sort.c"
@@ -0,0 +1,142 @@
+#include "Sort.h"
+
+/* 打印数组 */
+Status  PrintArray(ElemeyType *a, int l, int move_count, int compare_count) {
+	int i;
+	for (i = 0; i < l; i++) {
+		printf("%d ", a[i + 1]);
+	}
+	if (a[0] == 1)
+		printf("\n该算法执行的 总比较次数为：%d 总移动记录次数为:%d 二者次数之和为:%d\n",
+			compare_count, move_count, compare_count + move_count);
+	else
+		printf("\n");
+	return OK;
+}
+
+/* 直接插入排序 */
+Status InsSort(ElemeyType *r, int length, int *move_count, int *compare_count) {
+	int i, j;
+	for (i = 2; i <= length; i++) {
+		*r = *(r + i);   /* 将待插入记录存放到临时变量中 */
+		j = i - 1;     /* 最近一次排序结束的边界位置 */
+		(*compare_count)++;
+		while (r[0] < r[j]) { 	/* 寻找插入位置 */
+			(*move_count)++;
+			*(r + j + 1) = *(r + j);/* 从小到大排序，大元素右移 */
+			j = j - 1; /* 待插入元素与已排序区下一个（左移一位）元素继续进行比较 */
+		}
+		*(r + j + 1) = r[0]; /* 将待插入记录插入到已排序的序列中 */
+	}
+	*r = 1;
+	return OK;
+}
+
+/* 一趟希尔插入排序 */
+void ShellInsert(ElemeyType *r, int length, int delta, int *move_count, int *compare_count) {
+	//length为数组的长度, delta 为增量
+	int i, j;
+	for (i = 1 + delta; i <= length; i++) { /* 1+delta为第一个子序列的第二个元素的下标 */
+		(*compare_count)++;
+		if (r[i] < r[i - delta]) {
+			*r = r[i];     /* 备份r[i] (不做监视哨) */
+			for (j = i - delta; j > 0 && r[0] < r[j]; j -= delta) {
+				(*compare_count)++;
+				*(r + j + delta) = r[j];
+				(*move_count)++;
+			}
+			*(r + j + delta) = r[0];
+		}
+	}
+}
+
+/* 希尔排序 */
+void ShellSort(ElemeyType *r, int length, int *move_count, int *compare_count) {
+	//length为数组的长度
+	int d = length / 2;
+	while (d >= 1) {
+		ShellInsert(r, length, d, move_count, compare_count);
+		d = d / 2;
+	}
+	*r = 1;
+}
+
+/* 冒泡排序 */
+void BubbleSort(ElemeyType *r, int length, int *move_count, int *compare_count) {
+	//length为数组的长度
+	int n = length, i, j, x;
+	bool change = TRUE;
+	for (i = 1; i <= n - 1 && change; ++i) {
+		change = FALSE;
+		for (j = 1; j <= n - i; ++j) {
+			(*compare_count)++;
+			if (r[j] > r[j + 1]) {
+				(*move_count)++;
+				x = r[j];
+				*(r + j) = r[j + 1];
+				*(r + j + 1) = x;
+				change = TRUE;
+			}
+		}
+	}
+	*r = 1;
+}
+
+/* 快速排序 */
+void QKSort(ElemeyType *r, int low, int high, int *move_count, int *compare_count) {
+	int pivot;
+	if (low < high) {
+		pivot = QKPass(r, low, high, move_count, compare_count);
+		QKSort(r, low, pivot - 1, move_count, compare_count);
+		QKSort(r, pivot + 1, high, move_count, compare_count);
+	}
+	*r = 1;
+}
+
+/* 一趟快速排序 */
+int QKPass(ElemeyType *r, int left, int right, int *move_count, int *compare_count) {
+	//对记录数组r 中的r[left]至r[right]部分进行一趟排序，并得到基准的位置，使得排序后的结果满足其之后（前）
+	//的记录的关键字均不小于（大于）于基准记录
+	int x, low, high;
+	x = r[left];             /* 选择基准记录*/
+	low = left;
+	high = right;
+	while (low < high) {
+		while (low < high && r[high] >= x) { /* high从右到左找小于x的记录 */
+			(*compare_count)++;
+			high--;
+		}
+		*(r + low) = r[high]; /* 找到小于x.key的记录，则进行交换 */
+		(*move_count)++;
+		while (low < high && r[low] < x) { /* low从左到右找不小于x的记录 */
+			*(compare_count)++;
+			low++;
+		}
+		*(r + high) = r[low]; /* 找到不小于x的记录，则交换*/
+		(*move_count)++;
+	}
+
+	*(r + low) = x;  /* 将基准记录保存到low=high的位置 */
+	return low;  /*返回基准记录的位置*/
+}
+
+/* 选择排序 */
+void SelectSort(ElemeyType *r, int length, int *move_count, int *compare_count) {
+	//length为数组的长度
+	int n = length, i, k, j, x;
+	for (i = 1; i <= n - 1; ++i) {
+		k = i;
+		for (j = i + 1; j <= n; ++j) {
+			(*compare_count)++;
+			if (r[j] < r[k]) {
+				k = j;
+			}
+		}
+		if (k != i) {
+			(*move_count)++;
+			x = r[i];
+			*(r + i) = r[k];
+			*(r + k) = x;
+		}
+	}
+}
\ No newline at end of file
diff --git "a/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/Sort.h" "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/Sort.h"
new file mode 100644
index 00000000..4ef01518
--- /dev/null
+++ "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/Sort.h"
@@ -0,0 +1,41 @@
+#pragma once
+#ifndef SORT_H
+#define SORT_H
+#include<stdio.h>
+#define ElemeyType int 
+#define len  5
+typedef enum {
+	OK,
+	ERROR,
+	OVERFLOW
+}Status;
+
+typedef enum {
+	FALSE,
+	TRUE
+}bool;
+/* 打印数组 */
+Status  PrintArray(ElemeyType *a, int l, int move_count, int compare_count);
+
+/* 直接插入排序 */
+Status InsSort(ElemeyType *r, int length, int *move_count, int *compare_count);
+
+/* 一趟希尔插入排序 */
+void ShellInsert(ElemeyType *r, int length, int delta, int *move_count, int *compare_count);
+
+/* 希尔排序 */
+void ShellSort(ElemeyType *r, int length, int *move_count, int *compare_count);
+
+/* 冒泡排序 */
+void BubbleSort(ElemeyType *r, int length, int *move_count, int *compare_count);
+
+/* 快速排序 */
+void QKSort(ElemeyType *r, int low, int high, int *move_count, int *compare_count);
+
+/* 一趟快速排序 */
+int QKPass(ElemeyType *r, int left, int right, int *move_count, int *compare_count);
+
+/* 选择排序 */
+void SelectSort(ElemeyType *r, int length, int *move_count, int *compare_count);
+
+#endif
diff --git "a/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/main_Sort.c" "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/main_Sort.c"
new file mode 100644
index 00000000..49a7d6b9
--- /dev/null
+++ "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/main_Sort.c"
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "Sort.h"
+int main() {
+	int a[20], b[20], i;
+	srand(time(NULL));
+	for (i = 1; i < len + 1; i++) {
+		a[i] = rand() % 128;
+		b[i] = a[i];
+	}
+	int cCount = 0, mCount = 0;//记录比较次数和移动次数
+	PrintArray(a, len, mCount, cCount);
+
+	printf("\n希尔排序: ");
+	ShellSort(a, len, &mCount, &cCount);
+	PrintArray(a, len, mCount, cCount);
+
+	printf("\n直接插入排序: ");
+	for (i = 1; i < len + 1; i++) {
+		a[i] = b[i];
+	}
+	cCount = 0;
+	mCount = 0;
+	InsSort(a, len, &mCount, &cCount);
+	PrintArray(a, len, mCount, cCount);
+
+	printf("\n冒泡排序: ");
+	for (i = 1; i < len + 1; i++) {
+		a[i] = b[i];
+	}
+	cCount = 0, mCount = 0;
+	BubbleSort(a, len, &mCount, &cCount);
+	PrintArray(a, len, mCount, cCount);
+
+	printf("\n快速排序: ");
+	for (i = 1; i < len + 1; i++) {
+		a[i] = b[i];
+	}
+	cCount = 0, mCount = 0;
+	QKSort(a, 1, len, &mCount, &cCount);
+	PrintArray(a, len, mCount, cCount);
+
+	printf("\n选择排序: ");
+	for (i = 1; i < len + 1; i++) {
+		a[i] = b[i];
+	}
+	cCount = 0, mCount = 0;
+	SelectSort(a, len, &mCount, &cCount);
+	PrintArray(a, len, mCount, cCount);
+
+	return 0;
+}
\ No newline at end of file
diff --git "a/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/main_Sort.png" "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/main_Sort.png"
new file mode 100644
index 00000000..0083515f
Binary files /dev/null and "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/main_Sort.png" differ
diff --git "a/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/main_Sort.txt" "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/main_Sort.txt"
new file mode 100644
index 00000000..e4df38b4
--- /dev/null
+++ "b/2017-1/Cloud/6.\345\220\204\347\247\215\346\216\222\345\272\217\346\223\215\344\275\234/main_Sort.txt"
@@ -0,0 +1,16 @@
+106 19 10 63 127 
+
+希尔排序: 10 19 63 106 127 
+该算法执行的 总比较次数为：9 总移动记录次数为:2 二者次数之和为:11
+
+直接插入排序: 10 19 63 106 127 
+该算法执行的 总比较次数为：4 总移动记录次数为:4 二者次数之和为:8
+
+冒泡排序: 10 19 63 106 127 
+该算法执行的 总比较次数为：9 总移动记录次数为:4 二者次数之和为:13
+
+快速排序: 10 19 63 106 127 
+该算法执行的 总比较次数为：2 总移动记录次数为:6 二者次数之和为:8
+
+选择排序: 10 19 63 106 127 
+该算法执行的 总比较次数为：10 总移动记录次数为:2 二者次数之和为:12