diff --git a/9781449364939_files.zip b/9781449364939_files.zip
deleted file mode 100644
index a5d069d..0000000
Binary files a/9781449364939_files.zip and /dev/null differ
diff --git a/Chapter1/test.js b/Chapter1/test.js
new file mode 100644
index 0000000..465f533
--- /dev/null
+++ b/Chapter1/test.js
@@ -0,0 +1,37 @@
+// function factorial(number){
+// 	if(number == 1){
+// 		return number;
+// 	}else{
+// 		return number * factorial(number-1);
+// 	}
+// }
+// print(factorial(5));
+
+// function compare(num1, num2) {
+// return num1 - num2;
+// }
+// var nums = [3,1,2,100,4,200];
+// nums.sort(compare);
+// print(nums); // 1,2,3,4,100,200
+
+
+// Array.matrix = function(numrows,numcols,initial){
+// 	var arr = [];
+// 	for(var i=0;i<numrows;i++){
+// 		var columns = [];
+// 		for(var j=0;j<numcols;++j){
+// 			columns[j]=initial;
+// 		}
+// 		arr[i]=columns;
+// 	}
+// 	return arr;
+// }
+
+// var nums = Array.matrix(5,5,[1,2,3]);
+// print(nums);
+
+
+var grades = [[89, 77, 78],[76, 82, 81],[91, 94, 89]];
+print(grades[0][0]);
+print(grades[0][1]);
+print(grades[0][2]);
\ No newline at end of file
diff --git a/Chapter10/bst.js b/Chapter10/bst.js
index fc2fd34..627a2bd 100644
--- a/Chapter10/bst.js
+++ b/Chapter10/bst.js
@@ -1,195 +1,139 @@
-function Node(data, left, right) {
-   this.data = data;
-   this.left = left;
-   this.right = right;
-   this.show = show;
+//二叉查找树：一种特殊的二叉树，相对较小的值保存在左节点中，较大的值保存在右节点中。
+//实现二叉查找树
+function Node(data,left,right){
+	this.data = data;
+	this.count = 1;
+	this.left = left;
+	this.right = right;
+	this.show = show;
 }
-
-function show() {
-   return this.data;
+function show(){
+	return this.data;
 }
-
-function BST() {
-   this.root = null;
-   this.insert = insert;
-   this.inOrder = inOrder;
-   this.preOrder = preOrder;
-   this.postOrder = postOrder;
-   this.getmin = getmin;
-   this.getmax = getmax;
-   this.find = find;
-   this.remove = remove;
-   this.removeNode = removeNode;
-   this.getSmallest = getSmallest;
+function BST(){ //二叉查找树
+	this.root = null;//根节点 初始化为null，以此创建一个空节点
+	this.insert = insert;
+	this.inOrder = inOrder;
+	this.preOrder = preOrder;
+   	this.postOrder = postOrder;
+	this.getMax = getMax;
+	this.getMin = getMin;
+	this.find = find;
+	this.update = update;
 }
-
-function insert(data) {
-   var n = new Node(data, null, null);
-   if (this.root == null) {
-      this.root = n;
-   }
-   else {
-      var current = this.root;
-      var parent;
-      while (true) {
-         parent = current;
-         if (data < current.data) {
-            current = current.left;
-            if (current == null) {
-               parent.left = n;
-               break;
-            }
-         }
-         else {
-            current = current.right;
-            if (current == null) {
-               parent.right = n;
-               break;
-            }
-         }
-      }
-   }
+function insert(data){
+	var n = new Node(data,null,null);
+	if( this.root == null ){
+		this.root = n;
+	}else{
+		var current = this.root;//设根节点为当前节点
+		var parent;
+		while(true){
+			parent = current;
+			if(data < current.data){//如果带插入节点保存的数据小于当前节点
+				current = current.left;//设新的当前节点为原节点的左节点
+				if(current == null){//如果当前节点的左节点为null
+					parent.left = n;//将新的节点插入这个位置
+					break;//退出循环
+				}
+			}else{
+				current = current.right;
+				if(current == null){
+					parent.right = n;
+					break;
+				}
+			}
+		}
+	}
 }
-
-function inOrder(node) {
-   if (!(node == null)) {
-      inOrder(node.left);
-      putstr(node.show() + " ");
-      inOrder(node.right);
-   }
+//中序遍历使用遍历的方式最容易实现。该方法需要以升序访问树中所有节点。 左 根 右
+function inOrder(node){
+	if(!(node == null)){
+		inOrder(node.left);
+		putstr(node.show() + " ");
+		inOrder(node.right);
+	}
 }
-
-function preOrder(node) {
-   if (!(node == null)) {
-      putstr(node.show() + " ");
-      preOrder(node.left);
-      preOrder(node.right);
-   }
+//先序
+function preOrder(node){
+	if(!(node == null)){
+		putstr(node.show() + " ");
+		preOrder(node.left);
+		preOrder(node.right);
+	}
 }
-
-function postOrder(node) {
-   if (!(node == null)) {
-      postOrder(node.left);
-      postOrder(node.right);
-      putstr(node.show() + " ");
-   }
+//后序
+function postOrder(node){
+	if(!(node == null)){
+		postOrder(node.left);
+		postOrder(node.right);
+		putstr(node.show() + " ");
+	}
 }
-
-function getmin() {
-   var current = this.root;
-   print("debug: " + current.data);
-   while (!(current.left == null)) {
-      current = current.left;
-   }
-   return current.data;
+//查找最大值
+function getMax(){
+	var current = this.root;
+	while(!(current.right == null)){
+		current = current.right;
+	}
+	return current.data;
 }
-
-function getmax() {
-   var current = this.root;
-   while (!(current.right == null)) {
-      current = current.right;
-   }
-   return current.data;
-}
-
-function find(data) {
-   var current = this.root;
-   while (current.data != data) {
-      if (data < current.data) {
-         current = current.left;
-      }
-      else {
-         current = current.right;
-      }
-      if (current == null) {
-         return null;
-      }
-   }
-   return current;
+//查找最小值
+// 在BST上因为较小的值总是在左子节点上，查找最小值，只需要遍历左子树，直到找到最后一个节点
+function getMin(){
+	var current = this.root;
+	while(!(current.left == null)){
+		current = current.left;
+	}
+	return current.data;
 }
 
-function getSmallest(node) {
-   if (node.left == null) {
-      return node;
-   }
-   else {
-      return getSmallest(node.left);
-   }
+//查找给定值
+function find(data){
+	var current = this.root;
+	while( current != null){
+		if(current.data == data){
+			return current;
+		}else if(data < current.data){
+			current = current.left;
+		}else{
+			current = current.right;
+		}
+	}
+	return null;//如果找到给定值，该方法返回保存该值的节点；如果没找到，该方法返回 null。
 }
-
-function remove(data) {
-   root = removeNode(this.root, data);
+//从二叉查找树上删除节点
+function remove(data){ //简单地接受待删除数据
+	root = removeNode(this.root,data);
 }
-
-function removeNode(node, data) {
-   if (node == null) {
-      return null;
-   }
-   if (data == node.data) {
-      // node has no children
-      if (node.left == null && node.right == null) {
-         return null;
-      }
-      // node has no left child
-      if (node.left == null) {
-         return node.right;
-      }
-      // node has no right child
-      if (node.right == null) {
-         return node.left;
-      }
-      // node has two children
-      var tempNode = getSmallest(node.right);
-      node.data = tempNode.data;
-      node.right = removeNode(node.right, tempNode.data);
-      return node;
-   }
-   else if (data < node.data) {
-      node.left = removeNode(node.left, data);
-      return node;
-   }
-   else {
-      node.right = removeNode(node.right, data);
-      return node;
-   }
+function removeNode(node,data){//删除节点
+	if(node == null){ 
+		return null;
+	}
+	if(data == node.data){ //判断当前节点是否包含待删除的数据
+		if(node.left == null && node.right == null){ //没有子节点的节点  叶子节点
+			return null;//只需将从父节点指向它的链接指向null
+		}
+		if(node.left == null){//没有左子节点的节点
+			return node.right;
+		}
+		if(node.right == null){//没有右子节点的节点
+			return node.left;
+		}
+		var tempNode = getSmallest(node.right);//有两个子节点的节点
+		node.data = tempNode.data;
+		node.right = removeNode(node.right, tempNode.data);
+		return node;
+	}else if(data < node.data){//如果不包含 比较当前节点上的数据和待删除的数据
+		node.left = removeNode(node.left,data); //如果待删除数据小于当前节点上的数据，则移至当前节点的左子节点继续比较
+		return node;
+	}else{
+		node.right = removeNode(node.right, data);//如果删除数据大于当前节点上的数据，则移至当前节点的右子节点继续比较。
+		return node;
+	}
 }
-      
-   
-
-var nums = new BST();
-nums.insert(23);
-nums.insert(45);
-nums.insert(16);
-nums.insert(37);
-nums.insert(3);
-nums.insert(99);
-nums.insert(22);
-/*print("Inorder traversal: ");
-inOrder(nums.root);
-print("\n");
-print("Preorder traversal: ");
-preOrder(nums.root);
-print("\n");
-print("Postorder traversal: ");
-postOrder(nums.root);
-print("\n");
-var min = nums.getmin();
-print("The minimum value of the BST is: " + min);
-var max = nums.getmax();
-print("The maximum value of the BST is: " + max);
-inOrder(nums.root);
-print("\n");
-putstr("Enter a value to search for: ");
-var value = parseInt(readline());
-var found = nums.find(value);
-if (found != null) {
-   print("Found " + value + " in the BST.");
+function update(data){
+	var grade = this.find(data);
+	grade.count++;
+	return grade;
 }
-else {
-   print(value + " was not found in the BST.");
-}*/
-inOrder(nums.root);
-print("\n");
-var num = parseInt(readline());
-nums.remove(num);
-inOrder(nums.root);
diff --git a/Chapter10/bst1.js b/Chapter10/bst1.js
new file mode 100644
index 0000000..5e72d24
--- /dev/null
+++ b/Chapter10/bst1.js
@@ -0,0 +1,195 @@
+function Node(data, left, right) {
+   this.data = data;
+   this.left = left;
+   this.right = right;
+   this.show = show;
+}
+
+function show() {
+   return this.data;
+}
+
+function BST() {
+   this.root = null;
+   this.insert = insert;
+   this.inOrder = inOrder;
+   this.preOrder = preOrder;
+   this.postOrder = postOrder;
+   this.getmin = getmin;
+   this.getmax = getmax;
+   this.find = find;
+   this.remove = remove;
+   this.removeNode = removeNode;
+   this.getSmallest = getSmallest;
+}
+
+function insert(data) {
+   var n = new Node(data, null, null);
+   if (this.root == null) {
+      this.root = n;
+   }
+   else {
+      var current = this.root;
+      var parent;
+      while (true) {
+         parent = current;
+         if (data < current.data) {
+            current = current.left;
+            if (current == null) {
+               parent.left = n;
+               break;
+            }
+         }
+         else {
+            current = current.right;
+            if (current == null) {
+               parent.right = n;
+               break;
+            }
+         }
+      }
+   }
+}
+
+function inOrder(node) {
+   if (!(node == null)) {
+      inOrder(node.left);
+      putstr(node.show() + " ");
+      inOrder(node.right);
+   }
+}
+
+function preOrder(node) {
+   if (!(node == null)) {
+      putstr(node.show() + " ");
+      preOrder(node.left);
+      preOrder(node.right);
+   }
+}
+
+function postOrder(node) {
+   if (!(node == null)) {
+      postOrder(node.left);
+      postOrder(node.right);
+      putstr(node.show() + " ");
+   }
+}
+
+function getmin() {
+   var current = this.root;
+   print("debug: " + current.data);
+   while (!(current.left == null)) {
+      current = current.left;
+   }
+   return current.data;
+}
+
+function getmax() {
+   var current = this.root;
+   while (!(current.right == null)) {
+      current = current.right;
+   }
+   return current.data;
+}
+
+function find(data) {
+   var current = this.root;
+   while (current.data != data) {
+      if (data < current.data) {
+         current = current.left;
+      }
+      else {
+         current = current.right;
+      }
+      if (current == null) {
+         return null;
+      }
+   }
+   return current;
+}
+
+function getSmallest(node) {
+   if (node.left == null) {
+      return node;
+   }
+   else {
+      return getSmallest(node.left);
+   }
+}
+
+function remove(data) {
+   root = removeNode(this.root, data);
+}
+
+function removeNode(node, data) {
+   if (node == null) {
+      return null;
+   }
+   if (data == node.data) {
+      // node has no children
+      if (node.left == null && node.right == null) {
+         return null;
+      }
+      // node has no left child
+      if (node.left == null) {
+         return node.right;
+      }
+      // node has no right child
+      if (node.right == null) {
+         return node.left;
+      }
+      // node has two children
+      var tempNode = getSmallest(node.right);
+      node.data = tempNode.data;
+      node.right = removeNode(node.right, tempNode.data);
+      return node;
+   }
+   else if (data < node.data) {
+      node.left = removeNode(node.left, data);
+      return node;
+   }
+   else {
+      node.right = removeNode(node.right, data);
+      return node;
+   }
+}
+      
+   
+
+var nums = new BST();
+nums.insert(23);
+nums.insert(45);
+nums.insert(16);
+nums.insert(37);
+nums.insert(3);
+nums.insert(99);
+nums.insert(22);
+/*print("Inorder traversal: ");
+inOrder(nums.root);
+print("\n");
+print("Preorder traversal: ");
+preOrder(nums.root);
+print("\n");
+print("Postorder traversal: ");
+postOrder(nums.root);
+print("\n");
+var min = nums.getmin();
+print("The minimum value of the BST is: " + min);
+var max = nums.getmax();
+print("The maximum value of the BST is: " + max);
+inOrder(nums.root);
+print("\n");
+putstr("Enter a value to search for: ");
+var value = parseInt(readline());
+var found = nums.find(value);
+if (found != null) {
+   print("Found " + value + " in the BST.");
+}
+else {
+   print(value + " was not found in the BST.");
+}*/
+inOrder(nums.root);
+print("\n");
+var num = parseInt(readline());
+nums.remove(num);
+inOrder(nums.root);
diff --git a/Chapter10/test.js b/Chapter10/test.js
new file mode 100644
index 0000000..c0c57c7
--- /dev/null
+++ b/Chapter10/test.js
@@ -0,0 +1,94 @@
+function prArray(arr) {
+	putstr(arr[0].toString() + ' ');
+	for (var i = 1; i < arr.length; ++i) {
+		putstr(arr[i].toString() + ' ');
+		if (i % 10 == 0) {
+			putstr("\n");
+		}
+	}
+}
+function genArray(length) {
+	var arr = [];
+	for (var i = 0; i < length; ++i) {
+		arr[i] = Math.floor(Math.random() * 101);
+	}
+	return arr;
+}
+
+load("BST.js");
+/*
+var nums = new BST();
+nums.insert(23);
+nums.insert(45);
+nums.insert(16);
+nums.insert(37);
+nums.insert(3);
+nums.insert(99);
+nums.insert(22);
+
+print("Inorder traversal: ");
+inOrder(nums.root);
+
+// Inorder traversal:
+// 3 16 22 23 37 45 99
+
+print();
+print("preOrder traversal: ");
+preOrder(nums.root);
+// preOrder traversal:
+// 23 16 3 22 45 37 99
+
+print();
+print("postOrder traversal: ");
+postOrder(nums.root);
+// postOrder traversal:
+// 3 22 16 37 99 45 23
+
+print();
+var min = nums.getMin();
+print("The minimum value of the BST is: " + min);
+//The minimum value of the BST is: 3
+print("\n");
+var max = nums.getMax();
+print("The maximum value of the BST is: " + max);
+// The maximum value of the BST is: 99
+
+
+print("\n");
+putstr("Enter a value to search for: ");
+var value = parseInt(readline());
+var found = nums.find(value);
+if (found != null) {
+	print("Found " + value + " in the BST.");
+}
+else {
+	print(value + " was not found in the BST.");
+}
+// Enter a value to search for: 22
+// Found 22 in the BST.
+*/
+var grades = genArray(100);
+prArray(grades);
+var gradedistro = new BST();
+for (var i = 0; i < grades.length; ++i) {
+	var g = grades[i];
+	var grade = gradedistro.find(g);
+	if (grade == null) {
+		gradedistro.insert(g);
+	}else {
+		gradedistro.update(g);
+	}
+}
+var cont = "y";
+while (cont == "y") {
+	putstr("\n\nEnter a grade: ");
+	var g = parseInt(readline());
+	var aGrade = gradedistro.find(g);
+	if (aGrade == null) {
+		print("No occurrences of " + g);
+	}else {
+		print("Occurrences of " + g + ": " + aGrade.count);
+	}
+	putstr("Look at another grade (y/n)? ");
+	cont = readline();
+}
diff --git a/Chapter11/Graph.js b/Chapter11/Graph.js
new file mode 100644
index 0000000..f962886
--- /dev/null
+++ b/Chapter11/Graph.js
@@ -0,0 +1,104 @@
+function Vertex(label){//创建一个Vertex类来保存顶点和边
+	this.label = label;
+}
+function Graph(v){
+	this.vertices = v;//顶点数
+	this.edges = 0;//边数
+	this.adj = []; //长度与顶点数相同的数组来记录顶点的数量
+	for(var i=0;i<this.vertices;++i){
+		this.adj[i] = [];//for循环为数组中每个元素添加一个子数组来存储所有的相邻顶点
+		this.adj[i].push("");//并将所有元素初始化为空字符串
+	}
+	this.addEdge = addEdge;
+	this.showGraph = showGraph;
+	this.toString = toString;
+
+	this.dfs = dfs;
+	this.marked = [];//添加一个数组，用来存储已访问过的顶点
+	for(var i=0;i<this.vertices;++i){
+		this.marked[i] = false;//将它所有元素的值全部初始化为false
+	}
+
+	this.bfs = bfs;
+
+	this.edgeTo = [];//保存从一个顶点到下一个顶点的所有边的数组
+	this.pathTo = pathTo;
+	this.hasPathTo = hasPathTo;
+}
+function addEdge(v,w){//传入顶点v,w
+	this.adj[v].push(w);//先找到顶点v的邻接表，将顶点w添加到列表中
+	this.adj[w].push(v);//查找顶点w的邻接表，将顶点v添加到列表。
+	this.edges++;//边数加1
+}
+function showGraph(){//通过打印所有顶点及其相邻顶点列表的方式来显示图
+	for(var i=0;i<this.vertices;++i){
+		putstr(i + "->");
+		for(var j=0;j<this.vertices;++j){
+			if(this.adj[i][j] != undefined)
+				putstr(this.adj[i][j] + ' ');
+		}
+		print();
+	}
+}
+
+// 深度优先搜索
+/*深度优先搜索包括从一条路径的起始顶点开始追溯，直到到达最后一个顶点，然后回溯，
+继续追溯下一条路径，直到到达最后的顶点，如此往复，直到没有路径为止。*/
+/*深度优先搜索算法比较简单：访问一个没有访问过的顶点，将它标记为已访问，再递归地
+去访问在初始顶点的邻接表中其他没有访问过的顶点。*/
+
+function dfs(v){
+	this.marked[v] = true;
+	if(this.adj[v] != undefined)
+		print("Visited vertex: " + v);
+	for each(var w in this.adj[v]){
+		if(!this.marked[w]){
+			this.dfs(w);
+		}
+	}
+}
+
+// 广度优先搜索
+/*广度优先搜索从第一个顶点开始，尝试访问尽可能靠近它的顶点。
+广度优先搜索算法使用了抽象的队列而不是数组来对已访问过的顶点进行排序。
+*/
+
+function bfs(s){
+	var queue = [];
+	this.marked[s] = true;
+	queue.push(s);//添加到队尾
+	while(queue.length > 0){
+		var v = queue.shift();//从队首移除
+		if(v != undefined){
+			print("Visited vertex: " + v);
+		}
+		for each(var w in this.adj[v]){
+			if(!this.marked[w]){
+				this.edgeTo[w] = v;
+				this.marked[w] = true;
+				queue.push(w);
+			}
+		}
+	}
+}
+
+function pathTo(v){
+	var source = 0;
+	if(!this.hasPathTo(v)){
+		return undefined;
+	}
+	var psth = [];
+	for(var i=v;i != source;i=this.edgeTo[i]){
+		path.push(i);
+	}
+	path.push(s);
+	return path;
+}
+function hasPathTo(v){
+	return this.marked[v];
+}
+
+//拓扑排序算法   优先级约束调度
+/*拓扑排序算法与深度优先搜索类似。不同的是，拓扑排序算法不会立即输出已访问的顶
+点，而是访问当前顶点邻接表中的所有相邻顶点，直到这个列表穷尽时，才将当前顶点压
+入栈中。*/
\ No newline at end of file
diff --git a/Chapter11/test.js b/Chapter11/test.js
new file mode 100644
index 0000000..4b314c1
--- /dev/null
+++ b/Chapter11/test.js
@@ -0,0 +1,28 @@
+load('Graph.js');
+g = new Graph(5); 
+g.addEdge(0,1);
+g.addEdge(0,2);
+g.addEdge(1,3);
+g.addEdge(2,4);
+// g.showGraph();
+
+/*
+0-> 1 2
+1-> 0 3
+2-> 0 4
+3-> 1
+4-> 2
+*/
+
+// g.dfs(0);
+// g.bfs(0);
+
+var vertex = 4;
+var paths = g.pathTo(vertex);
+while (paths.length > 0) {
+	if (paths.length > 1) {
+		putstr(paths.pop() + '-');
+	}else {
+		putstr(paths.pop());
+	}
+}
diff --git a/Chapter12/CArray.js b/Chapter12/CArray.js
new file mode 100644
index 0000000..a5fe9ea
--- /dev/null
+++ b/Chapter12/CArray.js
@@ -0,0 +1,225 @@
+function CArray(numElements){//数组测试平台类
+	this.dataStore = [];
+	this.pos = 0;
+	this.numElements = numElements;//想要的元素数
+	this.insert = insert;
+	this.toString = toString;
+	this.clear = clear;
+	this.setData = setData;
+	this.swap = swap;//用于交换数组元素
+	for(var i=0;i<numElements;++i){
+		this.dataStore[i] = i;
+	}
+	this.bubbleSort = bubbleSort;
+	this.selectionSort = selectionSort;
+	this.insertionSort = insertionSort;
+
+	this.gaps = [5,3,1];//对间隔序列的定义
+	function setGaps(arr){
+		this.gaps = arr;
+	}
+	this.shellsort = shellsort;
+
+	this.mergeSort = mergeSort;
+	this.mergeArrays = mergeArrays;
+}
+
+function setData(){//生成了存储在数组中的随机数字
+	for(var i=0;i<this.numElements;++i){
+		this.dataStore[i] = Math.floor(Math.random() * (this.numElements + 1));
+	}
+}
+
+function clear(){
+	for(var i=0;i<this.dataStore;++i){
+		this.dataStore[i] = 0;
+	}
+}
+
+function insert(element){
+	this.dataStore[this.pos++] = element;
+}
+
+function toString(){
+	var retstr = "";
+	for(var i=0;i<this.dataStore.length;++i){
+		retstr += this.dataStore[i]+" ";
+		if(i>0 & i%10==0){
+			retstr += "\n";
+		}
+	}
+	return retstr;
+}
+
+function swap(arr,index1,index2){
+	var temp = arr[index1];
+	arr[index1] = arr[index2];
+	arr[index2] = temp;
+}
+
+//冒泡排序（最慢的排序算法之一，但也是最容易实现的排序算法）
+/*算法会多次在数组中移动，比较相邻的数据，当左侧值大于右侧值时将它们进行互换*/
+function bubbleSort(){
+	var numElements = this.dataStore.length;
+	var temp;
+	for(var outer=numElements;outer >= 2;--outer){
+		for(var inner=0;inner <= outer-1;++inner){
+			if(this.dataStore[inner] > this.dataStore[inner+1]){
+				swap(this.dataStore,inner,inner+1);
+			}
+		}
+		// print(this.toString());//为了能看到排序过程
+	}
+}
+
+//选择排序
+/*选择排序从数组的开头开始，先找到最小的放第一位，然后是次小放第二位*/
+function selectionSort(){
+	var min,temp;
+	for(var outer=0;outer <= this.dataStore.length-2;++outer){
+		min = outer;
+		for (var inner = outer + 1; 
+           inner <= this.dataStore.length-1; ++inner) { 
+			if(this.dataStore[inner] < this.dataStore[min]){
+				min = inner;
+			}
+		}
+		swap(this.dataStore,outer,min);
+		// print(this.toString());
+	}
+}
+
+//插入排序
+/*通过将较大的数组元素移动到右侧，为数组左侧的较小元素腾出位置。*/
+function insertionSort(){
+	var temp,inner;
+	for(var outer=1;outer<=this.dataStore.length-1;++outer){
+		temp = this.dataStore[outer];
+		inner = outer;
+		while(inner > 0 && (this.dataStore[inner-1] >= temp)){
+			this.dataStore[inner] = this.dataStore[inner-1];
+			--inner;
+		}
+		this.dataStore[inner] = temp;
+		// print(this.toString());
+	}
+}
+
+
+//高级排序算法
+//希尔排序 /*核心理念与插入排序不同，它会首先比较距离较远的元素，而非相邻的元素*/
+function shellsort(){
+	for(var g=0;g<this.gaps.length;++g){//外循环控制间隔序列的移动
+		for(var i=this.gaps[g];i<this.dataStore.length;++i){
+			var temp = this.dataStore[i];
+			for(var j=i;j >= this.gaps[g] && this.dataStore[j-this.gaps[g]]>temp;j -= this.gaps[g]){
+				this.dataStore[j] = this.dataStore[j-this.gaps[g]];
+			}
+			this.dataStore[j] = temp;
+		}
+		print("间隔"+ this.gaps[g] + ": " + this.toString());
+	}
+}
+/*动态间隔*/
+function shellsort1(){
+	var N = this.dataStore.length;
+	var h = 1;
+	while(h < N/3){
+		h = 3*h+1;
+	}
+	while(h >= 1){
+		for(var i=h;i<N;i++){
+			for(var j=i;j>=h && this.dataStore[j]<this.dataStore[j-h];j -= h){
+				swap(this.dataStore,j,j-h);
+			}
+		}
+		h = (h-1)/3;
+	}
+}
+/*硬编码间隔序列的希尔排序和动态间隔序列的希尔排序效率是一样的*/
+
+//归并排序 ： 把一系列排好序的子序列合并成一个大的完整有序序列
+//自顶向下的归并排序：递归
+
+//自底向上的归并排序：非递归或迭代版本
+function mergeArrays(arr,startLeft, stopLeft, startRight, stopRight) {
+   var rightArr = new Array(stopRight - startRight + 1);
+   var leftArr = new Array(stopLeft - startLeft + 1);
+   k = startRight;
+   for (var i = 0; i < (rightArr.length-1); ++i) {
+      rightArr[i] = arr[k];
+      ++k;
+   }
+   
+   k = startLeft;
+   for (var i = 0; i < (leftArr.length-1); ++i) {
+      leftArr[i] = arr[k];
+      ++k;
+   }
+  
+   rightArr[rightArr.length-1] = Infinity; // a sentinel value
+   leftArr[leftArr.length-1] = Infinity; // a sentinel value
+   var m = 0;
+   var n = 0;
+   for (var k = startLeft; k < stopRight; ++k) {
+      if (leftArr[m] <= rightArr[n]) {
+         arr[k] = leftArr[m];
+         m++;
+      }
+      else {
+         arr[k] = rightArr[n];
+         n++;
+      }
+   }
+   print("left array - ", leftArr);
+   print("right array - ", rightArr);
+}
+
+function mergeSort() {
+   if (this.dataStore.length < 2) {
+      return;
+   }
+   var step = 1;
+   var left, right;
+   while (step < this.dataStore.length) {
+      left = 0;
+      right = step;
+      while (right + step <= this.dataStore.length) {
+         mergeArrays(this.dataStore, left, left+step, right, right+step);
+         left = right + step;
+         right = left + step;
+      }
+      if (right < this.dataStore.length) {
+         mergeArrays(this.dataStore, left, left+step, right, this.dataStore.length);
+      }
+      step *= 2;
+   }
+}
+
+//快速排序  是处理大数据集最快的排序算法之一
+/*
+它是一种分而治之的算法，通过递归的方
+式将数据依次分解为包含较小元素和较大元素的不同子序列。该算法不断重复这个步骤直
+到所有数据都是有序的。
+这个算法首先要在列表中选择一个元素作为基准值（pivot）。数据排序围绕基准值进行，
+将列表中小于基准值的元素移到数组的底部，将大于基准值的元素移到数组的顶部。
+*///快速排序算法非常适用于大型数据集合；在处理小数据集时性能反而会下降
+function qSort(arr){
+	if(arr.length == 0){
+		return [];
+	}
+	var left = [];
+	var right = [];
+	var pivot = arr[0];//基准值
+	for(var i=1;i<arr.length;i++){
+		print("基准值: " + pivot + "当前元素：" + arr[i]);
+		if(arr[i] < pivot){
+			print(" 移动 " + arr[i] + " 到左边 ");
+			left.push(arr[i]);
+		}else{
+			print(" 移动 " + arr[i] + " 到右边 ");
+			right.push(arr[i]);
+		}
+	}
+	return qSort(left).concat(pivot, qSort(right));
+}
\ No newline at end of file
diff --git a/Chapter12/test.js b/Chapter12/test.js
new file mode 100644
index 0000000..dba689b
--- /dev/null
+++ b/Chapter12/test.js
@@ -0,0 +1,71 @@
+load("CArray.js");
+// var numElements = 100;
+// var myNums = new CArray(numElements);
+// myNums.setData();
+// print(myNums.toString());
+
+/*
+var numElements = 10;
+var mynums = new CArray(numElements);
+mynums.setData();
+print(mynums.toString());
+// mynums.bubbleSort();
+// mynums.selectionSort();
+mynums.insertionSort();
+print();
+print(mynums.toString());
+*/
+
+
+// //计时系统
+// var numElements = 1000;
+// var nums = new CArray(numElements);
+// nums.setData();
+// var start = new Date().getTime();/**********开始计时********/
+// nums.bubbleSort();
+// var stop = new Date().getTime();/*********计时结束**********/
+// var elapsed = stop-start;
+// print(" 对 " + numElements + " 个元素执行冒泡排序消耗的时间为：" +
+// elapsed + " 毫秒。");
+// start = new Date().getTime();
+// nums.selectionSort();
+// stop = new Date().getTime();
+// elapsed = stop - start;
+// print(" 对 " + numElements + " 个元素执行选择排序消耗的时间为：" +
+// elapsed + " 毫秒。");
+// start = new Date().getTime();
+// nums.insertionSort();
+// stop = new Date().getTime();
+// elapsed = stop - start;
+// print(" 对 " + numElements + " 个元素执行插入排序消耗的时间为：" +
+// elapsed + " 毫秒。");
+
+/*
+选择排序和插入排序要比冒泡排序快
+插入排序是这三种算法中最快的。
+*/
+
+/*var nums = new CArray(10);
+nums.setData();
+print(" 希尔排序前：\n");
+print(nums.toString());
+print("\n 希尔排序中：\n");
+nums.shellsort();
+print("\n 希尔排序后：\n");
+print(nums.toString());*/
+
+/*
+var nums = new CArray(10);
+nums.setData();
+print(nums.toString());
+nums.mergeSort();
+print(nums.toString());
+*/
+
+var a = [];
+for(var i=0;i<10;++i){
+	a[i] = Math.floor((Math.random()*100)+1);
+}
+print(a);
+print();
+print(qSort(a));
\ No newline at end of file
diff --git a/Chapter2/chap2.js b/Chapter2/chap2.js
index 00ac468..af01d5e 100644
--- a/Chapter2/chap2.js
+++ b/Chapter2/chap2.js
@@ -1,4 +1,62 @@
+// 创建数组
+var numbers = [];//得到一个长度为0的空数组  *****推荐使用
+var numbers = new Array();//调用Array的构造函数创建数组
+var numbers = new Array(10);//指定数组长度为10
+//调用字符串对象的split()方法生成数组
+var sentence = "the quick brown fox jumped over the lazy dog";
+var words = sentence.split(" ");
+for (var i = 0; i < words.length; ++i) {
+print("word " + i + ": " + words[i]);
+}
+
 var numbers = [1,2,3,4,5];
-if (Array.isArray(numbers)) {
+if (Array.isArray(numbers)) { //调用Array.isArray()来判断一个对象是否是数组
    // perform array tasks on numbers
 }
+
+//查找元素
+indexOf() //用来查找传进来的参数在目标数组中是否存在 如果存在，返回索引；不存在，返回-1
+lastIndexOf()//返回最后一个
+//数组的字符串表示 逗号分隔
+join()
+toString()
+//由已有数组创建新数组
+concat()//可以合并多个数组创建一个新数组
+splice(截取起始索引，截取长度)//截取一个数组的子集创建一个新数组
+//为数组添加元素
+push()
+unshift()
+//从数组中删除元素
+pop()
+shift()
+//从数组中间位置添加和删除元素
+splice(起始索引，删除个数，新添元素)
+//数组排序
+reverse()//翻转
+sort()//按字典顺序对元素进行排序
+
+var names = ["David","Mike","Cynthia","Clayton","Bryan","Raymond"];
+names.sort();
+print(names); // Bryan,Clayton,Cynthia,David,Mike,Raymond
+
+var nums = [3,1,2,100,4,200];
+nums.sort();
+print(nums); // 1,100,2,200,3,4
+
+function compare(num1, num2) {
+return num1 - num2;
+}
+var nums = [3,1,2,100,4,200];
+nums.sort(compare);
+print(nums); // 1,2,3,4,100,200
+
+//迭代器方法
+//不生成新数组的迭代器方法（要么对数组中的每个元素执行某种操作，要么返回一个值）
+forEach()//接受一个函数作为参数，对数组中的每个元素使用该函数
+every()//接受一个返回值为布尔类型的函数 如果所有元素都返回true 则该方法返回true
+some()//接受一个返回值为布尔类型的函数  只要有一个元素返回true 该方法就返回true
+reduce()//接受一个函数，返回一个值  累加
+reduceRight()//从右向左执行
+//生成新数组的迭代器方法
+map()//对数组每个元素都执行函数参数 类似forEach()
+filter()//类似every()
\ No newline at end of file
diff --git a/Chapter2/chap2_10.js b/Chapter2/chap2_10.js
index 93f7285..a2476ca 100644
--- a/Chapter2/chap2_10.js
+++ b/Chapter2/chap2_10.js
@@ -1,3 +1,4 @@
+//按列访问 外层循环对应行，内层循环对应列
 var grades = [[89, 77, 78],[76, 82, 81],[91, 94, 89]];
 var total = 0;
 var average = 0.0;
diff --git a/Chapter3/chap3_1.js b/Chapter3/chap3_1.js
index e1d8bb5..02e64c3 100644
--- a/Chapter3/chap3_1.js
+++ b/Chapter3/chap3_1.js
@@ -1,28 +1,29 @@
 function List() {
-   this.listSize = 0;
-   this.pos = 0;
-   this.dataStore = [];
-   this.clear = clear;
+   this.listSize = 0;//列表的元素个数
+   this.pos = 0;//列表的当前位置
+   this.dataStore = [];//初始化一个空数组来保存列表元素
+   this.clear = clear;//清空列表中的所有元素
    this.find = find;
-   this.toString = toString;
-   this.insert = insert;
-   this.append = append;
-   this.remove = remove;
-   this.front = front;
-   this.end = end;
-   this.prev = prev;
-   this.next = next;
-   this.length = length;
-   this.currPos = currPos;
-   this.moveTo = moveTo;
-   this.getElement = getElement;
-   this.length = length;
+   this.toString = toString;//返回列表的字符串形式
+   this.insert = insert;//在现有元素后插入新元素
+   this.append = append;//在列表的末尾添加新元素
+   this.remove = remove;//从列表中删除元素
+   this.front = front;//将列表的当前位置设移动到第一个元素
+   this.end = end;//将列表的当前位置移动到最后一个元素
+   this.prev = prev;//将当前位置后移一位
+   this.next = next;//将当前位置前移一位
+   this.length = length;//返回列表中元素的个数
+   this.currPos = currPos;//返回列表的当前位置
+   this.moveTo = moveTo;//将当前位置移动到指定位置
+   this.getElement = getElement;//返回当前位置的元素
+   this.contains = contains;//判断给定值是否在列表中
 }
 
+//给列表添加元素
 function append(element) {
    this.dataStore[this.listSize++] = element;
 }
-
+//查找指定元素
 function find(element) {
    for (var i = 0; i < this.dataStore.length; ++i) {
       if (this.dataStore[i] == element) {
@@ -31,25 +32,95 @@ function find(element) {
    }
    return -1;
 }
-
+//从列表中删除元素
 function remove(element) {
-   var foundAt = this.find(element);
+   var foundAt = this.find(element);//使用find方法返回的位置对数组进行截取
    if (foundAt > -1) {
       this.dataStore.splice(foundAt,1);
-      --this.listSize;
+      --this.listSize;//数组改变后，listSize减1，以反映列表的最新长度
       return true;
    }
    return false;
 }
-
+//返回列表中元素的个数
+function length(){
+   return this.listSize;
+}
+//显示列表中的元素
 function toString() {
     return this.dataStore;
 }
+//向列表中插入一个元素到after之后
+function insert(element,after){
+   var insertPos = this.find(after);
+   if(insertPos > -1){
+      this.dataStore.splice(insertPos,0,element);
+      ++this.listSize;
+      return true;
+   }
+   return false;
+}
+//清空列表中所有的元素
+function clear(){
+   delete this.dataStore;
+   this.dataStore = [];
+   this.listSize = this.pos = 0;//表明这个一个新的空列表
+}
+//判断给定值是否在列表中
+function contains(element){
+   for(var i=0;i<this.dataStore.length;i++){
+      if(this.dataStore[i] == element){
+         return true;
+      }
+   }
+   return false;
+}
 
+function front(){
+   this.pos = 0;
+}
+function end(){
+   this.pos = this.listSize - 1;
+}
+function prev(){
+   if(this.pos > 0){
+      --this.pos;
+   }
+}
+function next(){
+   if(this.pos < this.listSize){
+      ++this.pos;
+   }
+}
+function currPos(){
+   return this.pos;
+}
+function moveTo(position){
+   this.pos = position;
+}
+//返回列表的当前元素
+function getElement(){
+   return this.dataStore[this.pos];
+}
 var names = new List();
 names.append("Cynthia");
 names.append("Raymond");
 names.append("Barbara");
 print(names.toString());
-names.remove("Raymond");
-print(names.toString());
+// names.remove("Raymond");
+// print(names.toString());
+// names.front();
+// print(names.getElement());
+print(names.front());
+names.next();
+// print(names.getElement());
+print(names.currPos());
+print(names.front());
+print(names.length());
+
+function displayList(list){
+   for(list.front();list.currPos()<list.length();list.next()){
+         print(list.getElement());
+   }
+}
+displayList(names);
\ No newline at end of file
diff --git "a/Chapter3/\344\270\200\344\270\252\345\237\272\344\272\216\345\210\227\350\241\250\347\232\204\345\272\224\347\224\250/films.txt" "b/Chapter3/\344\270\200\344\270\252\345\237\272\344\272\216\345\210\227\350\241\250\347\232\204\345\272\224\347\224\250/films.txt"
new file mode 100644
index 0000000..8672eb5
--- /dev/null
+++ "b/Chapter3/\344\270\200\344\270\252\345\237\272\344\272\216\345\210\227\350\241\250\347\232\204\345\272\224\347\224\250/films.txt"
@@ -0,0 +1,20 @@
+The Shawshank Redemption（《肖申克的救赎》）
+The Godfather
+The Godfather: Part II（《教父 2》）
+Pulp Fiction（《低俗小说》）
+The Good, the Bad and the Ugly（《黄金三镖客》）
+12 Angry Men（《十二怒汉》）
+Schindler’s List（《辛德勒名单》）
+The Dark Knight（《黑暗骑士》）
+The Lord of the Rings: The Return of the King（《指环王：王者归来》）
+Fight Club（《搏击俱乐部》）
+Star Wars: Episode V - The Empire Strikes Back（《星球大战 5：帝国反击战》）
+One Flew Over the Cuckoo’s Nest（《飞越疯人院》）
+The Lord of the Rings: The Fellowship of the Ring（《指环王：护戒使者》）
+Inception（《盗梦空间》）
+Goodfellas（《好家伙》）
+Star Wars（《星球大战》）
+Seven Samurai（《七武士》）
+The Matrix（《黑客帝国》）
+Forrest Gump（《阿甘正传》）
+City of God（《上帝之城》）
\ No newline at end of file
diff --git "a/Chapter3/\344\270\200\344\270\252\345\237\272\344\272\216\345\210\227\350\241\250\347\232\204\345\272\224\347\224\250/test.js" "b/Chapter3/\344\270\200\344\270\252\345\237\272\344\272\216\345\210\227\350\241\250\347\232\204\345\272\224\347\224\250/test.js"
new file mode 100644
index 0000000..bb4fa64
--- /dev/null
+++ "b/Chapter3/\344\270\200\344\270\252\345\237\272\344\272\216\345\210\227\350\241\250\347\232\204\345\272\224\347\224\250/test.js"
@@ -0,0 +1,161 @@
+function List() {
+   this.listSize = 0;//列表的元素个数
+   this.pos = 0;//列表的当前位置
+   this.dataStore = [];//初始化一个空数组来保存列表元素
+   this.clear = clear;//清空列表中的所有元素
+   this.find = find;
+   this.toString = toString;//返回列表的字符串形式
+   this.insert = insert;//在现有元素后插入新元素
+   this.append = append;//在列表的末尾添加新元素
+   this.remove = remove;//从列表中删除元素
+   this.front = front;//将列表的当前位置设移动到第一个元素
+   this.end = end;//将列表的当前位置移动到最后一个元素
+   this.prev = prev;//将当前位置后移一位
+   this.next = next;//将当前位置前移一位
+   this.length = length;//返回列表中元素的个数
+   this.currPos = currPos;//返回列表的当前位置
+   this.moveTo = moveTo;//将当前位置移动到指定位置
+   this.getElement = getElement;//返回当前位置的元素
+   this.contains = contains;//判断给定值是否在列表中
+}
+
+//给列表添加元素
+function append(element) {
+   this.dataStore[this.listSize++] = element;
+}
+//查找指定元素
+function find(element) {
+   for (var i = 0; i < this.dataStore.length; ++i) {
+      if (this.dataStore[i] == element) {
+         return i;
+      }
+   }
+   return -1;
+}
+//从列表中删除元素
+function remove(element) {
+   var foundAt = this.find(element);//使用find方法返回的位置对数组进行截取
+   if (foundAt > -1) {
+      this.dataStore.splice(foundAt,1);
+      --this.listSize;//数组改变后，listSize减1，以反映列表的最新长度
+      return true;
+   }
+   return false;
+}
+//返回列表中元素的个数
+function length(){
+   return this.listSize;
+}
+//显示列表中的元素
+function toString() {
+    return this.dataStore;
+}
+//向列表中插入一个元素到after之后
+function insert(element,after){
+   var insertPos = this.find(after);
+   if(insertPos > -1){
+      this.dataStore.splice(insertPos,0,element);
+      ++this.listSize;
+      return true;
+   }
+   return false;
+}
+//清空列表中所有的元素
+function clear(){
+   delete this.dataStore;
+   this.dataStore = [];
+   this.listSize = this.pos = 0;//表明这个一个新的空列表
+}
+//判断给定值是否在列表中
+function contains(element){
+   for(var i=0;i<this.dataStore.length;i++){
+      if(this.dataStore[i] == element){
+         return true;
+      }
+   }
+   return false;
+}
+
+function front(){
+   this.pos = 0;
+}
+function end(){
+   this.pos = this.listSize - 1;
+}
+function prev(){
+   if(this.pos > 0){
+      --this.pos;
+   }
+}
+function next(){
+   if(this.pos < this.listSize){
+      ++this.pos;
+   }
+}
+function currPos(){
+   return this.pos;
+}
+function moveTo(position){
+   this.pos = position;
+}
+//返回列表的当前元素
+function getElement(){
+   return this.dataStore[this.pos];
+}
+// var movies = read('./films.txt').split("\n");
+// print(movies);
+var movies = createArr("films.txt");
+//当读进来的内容被分割成数组后，换行符被替换成空格。
+function createArr(file){
+	var arr = read(file).split("\n");
+	for(var i=0;i<arr.length;++i){
+		arr[i] = arr[i].trim();//使用trim()删除每个数组元素末尾的空格
+	}
+	return arr;
+}
+function Customer(name,movie){
+	this.name = name;
+	this.movie = movie;
+}
+//将数组movies中的元素保存到一个列表中
+var movieList = new List();
+var customers = new List();
+for(var i=0;i<movies.length;++i){
+	movieList.append(movies[i]);
+}
+//显示影碟店里现有的影碟清单
+function displayList(list){
+	for(list.front();list.currPos()<list.length();list.next()){
+		if(list.getElement() instanceof Customer){
+			print(list.getElement()["name"] + ", "+
+				list.getElement()["movie"]);
+		}else{
+			print(list.getElement());
+		}
+	}
+}
+
+function checkOut(name,movie,filmList,customerList){
+	if(movieList.contains(movie)){
+		var c = new Customer(name,movie);
+		customerList.append(c);
+		filmList.remove(movie);
+	}else{
+		print(movie + " is not available.");
+	}
+}
+
+// displayList(movieList);
+// print(movies);
+
+print("Available movies: \n");
+displayList(movieList);
+putstr("\nEnter your name: ");
+var name = readline();
+putstr("What movie would you like? ");
+var movie = readline();
+checkOut(name, movie, movieList, customers);
+print("\nCustomer Rentals: \n");
+displayList(customers);
+print("\nMovies Now Available\n");
+displayList(movieList);
\ No newline at end of file
diff --git a/Chapter4/test.js b/Chapter4/test.js
new file mode 100644
index 0000000..78335c0
--- /dev/null
+++ b/Chapter4/test.js
@@ -0,0 +1,136 @@
+function Stack(){
+	this.dataStore = [];//保存栈内元素 初始化为一个空数组
+	this.top = 0;//top记录栈顶位置
+	this.push = push;//压入一个新元素
+	this.pop = pop;//弹出栈顶元素
+	this.peek = peek;//返回栈顶元素，但不删除它
+	this.length = length;//通过返回变量top值的方式返回栈内的元素个数
+	this.clear = clear;//将变量top的值设为0，清空一个栈
+}
+
+//++放在this.top后面，这样新入栈的元素就被放在top的当前值对应的位置，
+//然后再将变量top的值加1，指向下一个位置
+function push(element){
+	this.dataStore[this.top++] = element;
+}
+
+function pop(){
+	return this.dataStore[--this.top];
+}
+
+//对一个空栈调用peek()，结果为undefined
+function peek(){
+	return this.dataStore[this.top-1];
+}
+
+function length(){
+	return this.top;
+}
+
+function clear(){
+	this.top = 0;
+}
+
+//测试Stack类的实现
+// var s = new Stack();
+// s.push("David");
+// s.push("Raymond");
+// s.push("Bryan");
+// print("length: " + s.length());//3
+// print(s.peek());//Bryan
+// var popped = s.pop();
+// print("The popped element is: " + popped);//Bryan
+// print(s.peek());//Raymond
+// s.push("Cynthia");
+// print(s.peek());//Cynthia
+// s.clear();
+// print("length: " + s.length());//0
+// print(s.peek());//undefined
+// s.push("Clayton");
+// print(s.peek());//Clayton
+
+//将数字n转换为以b为基数的数字
+function mulBase(num,base){
+	var s = new Stack();
+	do{
+		s.push(num%base);
+		num=Math.floor(num /= base);/************/
+	}while(num>0);
+	var converted="";
+	while(s.length()>0){
+		converted+=s.pop();
+	}
+	return converted;
+}
+
+// print(mulBase(13,2));
+
+// print(13/2);//6
+// print(Math.floor(13/2));//6.5
+
+//测试将数字转换为2进制和8进制
+// var num = 32;
+// var base = 2;
+// var newNum = mulBase(num, base);
+// print(num + " converted to base " + base + " is " + newNum);
+// num = 125;
+// base = 8;
+// var newNum = mulBase(num, base);
+// print(num + " converted to base " + base + " is " + newNum);
+
+
+//判断给定字符串是否是回文
+function isPalindrome(word){
+	var s = new Stack();
+	for(var i=0;i<word.length;i++){
+		s.push(word[i]);
+	}
+	var rword = "";
+	while(s.length()>0){
+		rword+=s.pop();
+	}
+	if(word == rword){
+		return true;
+	}else{
+		return false;
+	}
+}
+
+//测试
+// var word = "hello";
+// if (isPalindrome(word)) {
+// 	print(word + " is a palindrome.");
+// }
+// else {
+// 	print(word + " is not a palindrome.");
+// }
+// word = "racecar"
+// if (isPalindrome(word)) {
+// 	print(word + " is a palindrome.");
+// }
+// else {
+// 	print(word + " is not a palindrome.");
+// }
+
+//阶乘函数的递归定义
+function factorial(n){
+	if(n===0){
+		return 1;
+	}else{
+		return n * factorial(n-1);
+	}
+}
+// print(factorial(5));//120
+//使用栈模拟递归
+function fact(n){
+	var s = new Stack();
+	while(n>1){
+		s.push(n--);
+	}
+	var product = 1;
+	while(s.length()>0){
+		product *= s.pop();
+	}
+	return product;
+}
+print(fact(5));//120
\ No newline at end of file
diff --git a/Chapter5/test.js b/Chapter5/test.js
new file mode 100644
index 0000000..1a2a5bc
--- /dev/null
+++ b/Chapter5/test.js
@@ -0,0 +1,48 @@
+function Queue(){
+	this.dataStore = [];
+	this.enqueue = enqueue;//向队尾添加一个元素
+	this.dequeue = dequeue;//从队首删除一个元素
+	this.front =front;//读取队首元素
+	this.back = back;//读取队尾元素
+	this.toString = toString;//显示队列内的所有元素
+	this.empty = empty;//判断队列是否为空
+}
+function enqueue(element){
+	this.dataStore.push(element);
+}
+function dequeue(){
+	person = this.front();
+	this.dataStore.shift();
+	return person;
+}
+function front(){
+	return this.dataStore[0];
+}
+function back(){
+	return this.dataStore[this.dataStore.length-1];
+}
+function toString(){
+	var retStr = "";
+	for(var i=0;i<this.dataStore.length;i++){
+		retStr+=this.dataStore[i]+"\n";
+	}
+	return retStr;
+}
+function empty(){
+	if(this.dataStore.length == 0){
+		return true;
+	}else{
+		return false;
+	}
+}
+//测试
+var q = new Queue();
+q.enqueue("Meredith");
+q.enqueue("Cynthia");
+q.enqueue("Jennifer");
+print(q.toString());//M C J
+// q.dequeue();
+print("删除了 "+q.dequeue());
+print(q.toString());//C J
+// print("Front of queue: " + q.front());//C
+// print("Back of queue: " + q.back());//J
\ No newline at end of file
diff --git "a/Chapter5/\344\274\230\345\205\210\351\230\237\345\210\227/test.js" "b/Chapter5/\344\274\230\345\205\210\351\230\237\345\210\227/test.js"
new file mode 100644
index 0000000..84714bc
--- /dev/null
+++ "b/Chapter5/\344\274\230\345\205\210\351\230\237\345\210\227/test.js"
@@ -0,0 +1,78 @@
+function Queue(){
+	this.dataStore = [];
+	this.enqueue = enqueue;//向队尾添加一个元素
+	this.dequeue = dequeue;//从队首删除一个元素
+	this.front =front;//读取队首元素
+	this.back = back;//读取队尾元素
+	this.toString = toString;//显示队列内的所有元素
+	this.empty = empty;//判断队列是否为空
+	this.count = count;//显示队列的元素数
+}
+function enqueue(element){
+	this.dataStore.push(element);
+}
+function dequeue(){
+	var priority = this.dataStore[0].code;
+	for(var i=1;i<this.dataStore.length;i++){
+		if(this.dataStore[i].code<priority){
+			priority=i;
+		}
+	}
+	return this.dataStore.splice(priority,1);
+}
+function front(){
+	return this.dataStore[0];
+}
+function back(){
+	return this.dataStore[this.dataStore.length-1];
+}
+function toString(){
+	var retStr = "";
+	for(var i=0;i<this.dataStore.length;i++){
+		retStr+=this.dataStore[i].name+" code: "+this.dataStore[i].code +"\n";
+	}
+	return retStr;
+}
+function empty(){
+	if(this.dataStore.length == 0){
+		return true;
+	}else{
+		return false;
+	}
+}
+function count(){
+	return this.dataStore.length;
+}
+
+//定义存储队列元素的对象
+function Patient(name,code){
+	this.name = name;
+	this.code = code;//表示患者的优先级或病情严重程度 优先码值最小的元素优先级最高
+}
+
+//测试
+var p = new Patient("Smith",5);
+var ed = new Queue();
+ed.enqueue(p);
+p = new Patient("Jones", 4);
+ed.enqueue(p);
+p = new Patient("Fehrenbach", 6);
+ed.enqueue(p);
+p = new Patient("Brown", 1);
+ed.enqueue(p);
+p = new Patient("Ingram", 1);
+ed.enqueue(p);
+print(ed.toString());
+var seen = ed.dequeue();
+print("Patient being treated: " + seen[0].name);
+print("Patients waiting to be seen: ")
+print(ed.toString());
+// 下一轮
+var seen = ed.dequeue();
+print("Patient being treated: " + seen[0].name);
+print("Patients waiting to be seen: ")
+print(ed.toString());
+var seen = ed.dequeue();
+print("Patient being treated: " + seen[0].name);
+print("Patients waiting to be seen: ")
+print(ed.toString());
\ No newline at end of file
diff --git "a/Chapter5/\344\275\277\347\224\250\351\230\237\345\210\227\345\257\271\346\225\260\346\215\256\346\216\222\345\272\217/test.js" "b/Chapter5/\344\275\277\347\224\250\351\230\237\345\210\227\345\257\271\346\225\260\346\215\256\346\216\222\345\272\217/test.js"
new file mode 100644
index 0000000..69712d5
--- /dev/null
+++ "b/Chapter5/\344\275\277\347\224\250\351\230\237\345\210\227\345\257\271\346\225\260\346\215\256\346\216\222\345\272\217/test.js"
@@ -0,0 +1,92 @@
+function Queue(){
+	this.dataStore = [];
+	this.enqueue = enqueue;//向队尾添加一个元素
+	this.dequeue = dequeue;//从队首删除一个元素
+	this.front =front;//读取队首元素
+	this.back = back;//读取队尾元素
+	this.toString = toString;//显示队列内的所有元素
+	this.empty = empty;//判断队列是否为空
+	this.count = count;//显示队列的元素数
+}
+function enqueue(element){
+	this.dataStore.push(element);
+}
+function dequeue(){
+	delet = this.front();
+	this.dataStore.shift();
+	return delet;
+}
+function front(){
+	return this.dataStore[0];
+}
+function back(){
+	return this.dataStore[this.dataStore.length-1];
+}
+function toString(){
+	var retStr = "";
+	for(var i=0;i<this.dataStore.length;i++){
+		retStr+=this.dataStore[i]+"\n";
+	}
+	return retStr;
+}
+function empty(){
+	if(this.dataStore.length == 0){
+		return true;
+	}else{
+		return false;
+	}
+}
+function count(){
+	return this.dataStore.length;
+}
+
+//使用队列对数据进行排序
+
+//根据对应位（个位和十位）上的数组，将数字分配到相应队列的函数
+function distribute(nums,queues,n,digit){//digit表示个位或十位上的值
+	for(var i=0;i<n;i++){
+		if(digit == 1){
+			queues[nums[i]%10].enqueue(nums[i]);
+		}else{
+			queues[Math.floor(nums[i]/10)].enqueue(nums[i]);
+		}
+	}
+}
+
+//从队列中收集数字的函数
+function collect(queues,nums){
+	var i=0;
+	for(var digit=0;digit<10;digit++){
+		while(!queues[digit].empty()){
+			nums[i++]=queues[digit].dequeue();
+		}
+	}		
+}
+
+function dispArray(arr){
+	for(var i=0;i<arr.length;i++){
+		putstr(arr[i]+" ");
+	}
+}
+
+//主程序
+var queues = [];
+for (var i = 0; i < 10; ++i) {
+	queues[i] = new Queue();//创建9个队列
+}
+var nums = [];
+for (var i = 0; i < 10; ++i) {
+	nums[i] = Math.floor(Math.floor(Math.random() * 101));
+}
+
+// print(Math.random()*101);
+// print(Math.floor(Math.random() * 101));
+
+print("Before radix sort: ");
+dispArray(nums);
+distribute(nums, queues, 10, 1);
+collect(queues, nums);
+distribute(nums, queues, 10, 10);
+collect(queues, nums);
+print("\n\nAfter radix sort: ");
+dispArray(nums);
\ No newline at end of file
diff --git "a/Chapter5/\346\226\271\345\235\227\350\210\236\347\232\204\350\210\236\344\274\264\345\210\206\351\205\215\351\227\256\351\242\230/data.txt" "b/Chapter5/\346\226\271\345\235\227\350\210\236\347\232\204\350\210\236\344\274\264\345\210\206\351\205\215\351\227\256\351\242\230/data.txt"
new file mode 100644
index 0000000..89f2bc1
--- /dev/null
+++ "b/Chapter5/\346\226\271\345\235\227\350\210\236\347\232\204\350\210\236\344\274\264\345\210\206\351\205\215\351\227\256\351\242\230/data.txt"
@@ -0,0 +1,11 @@
+F Allison-McMillan   
+M Frank-Opitz   
+M Mason-McMillan  
+M Clayton-Ruff
+F Cheryl-Ferenback
+M Raymond-Williams
+F Jennifer-Ingram
+M Bryan-Frazer
+M David-Durr
+M Danny-Martin
+F Aurora-Adney
\ No newline at end of file
diff --git "a/Chapter5/\346\226\271\345\235\227\350\210\236\347\232\204\350\210\236\344\274\264\345\210\206\351\205\215\351\227\256\351\242\230/test.js" "b/Chapter5/\346\226\271\345\235\227\350\210\236\347\232\204\350\210\236\344\274\264\345\210\206\351\205\215\351\227\256\351\242\230/test.js"
new file mode 100644
index 0000000..5d429bc
--- /dev/null
+++ "b/Chapter5/\346\226\271\345\235\227\350\210\236\347\232\204\350\210\236\344\274\264\345\210\206\351\205\215\351\227\256\351\242\230/test.js"
@@ -0,0 +1,100 @@
+function Queue(){
+	this.dataStore = [];
+	this.enqueue = enqueue;//向队尾添加一个元素
+	this.dequeue = dequeue;//从队首删除一个元素
+	this.front =front;//读取队首元素
+	this.back = back;//读取队尾元素
+	this.toString = toString;//显示队列内的所有元素
+	this.empty = empty;//判断队列是否为空
+	this.count = count;//显示队列的元素数
+}
+function enqueue(element){
+	this.dataStore.push(element);
+}
+function dequeue(){
+	delet = this.front();
+	this.dataStore.shift();
+	return delet;
+}
+function front(){
+	return this.dataStore[0];
+}
+function back(){
+	return this.dataStore[this.dataStore.length-1];
+}
+function toString(){
+	var retStr = "";
+	for(var i=0;i<this.dataStore.length;i++){
+		retStr+=this.dataStore[i]+"\n";
+	}
+	return retStr;
+}
+function empty(){
+	if(this.dataStore.length == 0){
+		return true;
+	}else{
+		return false;
+	}
+}
+function count(){
+	return this.dataStore.length;
+}
+
+//舞者的信息都被存储在一个Dancer对象中
+function Dancer(name,sex){
+	this.name = name;
+	this.sex = sex;
+}
+
+// var names = read('./data.txt').split("\n");
+// print(names);
+
+//将舞者信息从文件中读到程序里
+function getDancers(males,females){
+	var names = read('./data.txt').split("\n");
+	for(var i=0;i<names.length;i++){
+		names[i]=names[i].trim();
+	}
+	for(var i=0;i<names.length;i++){
+		var dancer = names[i].split(" ");
+		var sex = dancer[0];
+		var name = dancer[1];
+		if(sex == "F"){
+			females.enqueue(new Dancer(name,sex));
+		}else{
+			males.enqueue(new Dancer(name,sex));
+		}
+	}
+}
+
+//将男性和女性组成舞伴，并宣布配对结果
+function dance(males,females){
+	print("The dance partners are: \n");
+	if(!males.empty() && !females.empty()){
+		// person = males.dequeue();
+		print("Male dancer is: " + males.dequeue().name);
+		// person = females.dequeue();
+		print("and the Female dancer is: " + females.dequeue().name);
+	}
+	print();
+}
+
+//测试
+var maleDancers = new Queue();
+var femaleDancers = new Queue();
+getDancers(maleDancers,femaleDancers);
+dance(maleDancers,femaleDancers);
+if (!femaleDancers.empty()) {
+	print(femaleDancers.front().name + " is waiting to dance.");
+}
+if (!maleDancers.empty()) {
+	print(maleDancers.front().name + " is waiting to dance.");
+}
+if (maleDancers.count() > 0) {
+	print("There are " + maleDancers.count() +
+" male dancers waiting to dance.");
+}
+if (femaleDancers.count() > 0) {
+	print("There are " + femaleDancers.count() +
+" female dancers waiting to dance.");
+}
\ No newline at end of file
diff --git a/Chapter6/chap6-3.txt b/Chapter6/chap6-3.txt
index bbd8142..2bd094d 100644
--- a/Chapter6/chap6-3.txt
+++ b/Chapter6/chap6-3.txt
@@ -19,10 +19,18 @@ function remove(item) {
    }
 }
 
-function findPrevious(item) {
+// function findPrevious(item) {
+//    var currNode = this.head;
+//    while (!(currNode.next == null) && 
+//            (currNode.next.element != item)) {
+//       currNode = currNode.next;
+//    }
+//    return currNode;
+// }
+
+function findPrevious(item){
    var currNode = this.head;
-   while (!(currNode.next == null) && 
-           (currNode.next.element != item)) {
+   while( (currNode.next != null) && (currNode.next.element != item) ){
       currNode = currNode.next;
    }
    return currNode;
diff --git "a/Chapter6/\345\215\225\351\223\276\350\241\250.js" "b/Chapter6/\345\215\225\351\223\276\350\241\250.js"
new file mode 100644
index 0000000..dd7faa3
--- /dev/null
+++ "b/Chapter6/\345\215\225\351\223\276\350\241\250.js"
@@ -0,0 +1,69 @@
+//设计一个基于对象的链表
+
+//Node类用来表示节点
+function Node(element){
+	this.element = element;//保存节点上的数据
+	this.next = null;//保存指向下一个节点的链接
+}
+//LinkedList类提供了插入节点、删除节点、显示列表元素的方法等
+function LList(){
+	this.head = new Node("head");//头节点
+	this.find = find;//在列表中查找给定的值
+	this.insert = insert;//插入节点
+	this.remove = remove;//删除节点
+	this.display = display;//显示链表中的元素
+	this.findPrevious = findPrevious;
+}
+//find检查每一个节点是否等于待查找数据
+function find(item){
+	var currNode = this.head;
+	while(currNode.element != item){/********************************************/
+		currNode = currNode.next;
+	}
+	return currNode;
+}
+
+//在已知节点item后面插入元素
+function insert(newElement,item){
+	var newNode = new Node(newElement);
+	var current = this.find(item);
+	newNode.next = current.next;
+	current.next = newNode;
+}
+//显示链表中的元素
+function display(){
+	var currNode = this.head;
+	while(!(currNode.next == null)){
+		print(currNode.next.element);
+		currNode = currNode.next;
+	}
+}
+
+//删除一个节点  首先要找到待删除节点前面的节点
+
+//findPrevious()遍历链表中的元素，检查每一个节点的下一个节点中是否存储着待删除数据，
+// 如果找到，返回该节点（即前一个节点）
+function findPrevious(item){
+	var currNode = this.head;
+	while(!(currNode.next == null) && (currNode.next.element != item) ){/*************************/
+		currNode = currNode.next;
+	}
+	return currNode;
+}
+function remove(item){
+	var prevNode = this.findPrevious(item);/***之前遗漏掉了this. 结果一直报错TypeError: currNode is undefined*****/
+	if(!(prevNode.element == null)){
+		prevNode.next = prevNode.next.next;
+	}
+}
+
+//测试
+var cities = new LList();
+cities.insert("Conway","head");
+cities.insert("Russellville", "Conway");
+cities.insert("Alma", "Russellville");
+cities.insert("Carlisle", "Russellville");
+cities.display();//Conway   Russellville   Alma
+console.log();
+cities.remove("Carlisle");
+cities.display();
\ No newline at end of file
diff --git "a/Chapter6/\345\217\214\345\220\221\351\223\276\350\241\250.js" "b/Chapter6/\345\217\214\345\220\221\351\223\276\350\241\250.js"
new file mode 100644
index 0000000..54f7dac
--- /dev/null
+++ "b/Chapter6/\345\217\214\345\220\221\351\223\276\350\241\250.js"
@@ -0,0 +1,78 @@
+function Node(element){
+	this.element = element;
+	this.next = null;
+	this.previous = null;
+}
+function LList(){
+	this.head = new Node('head');
+	this.insert = insert;
+	this.find = find;
+	this.remove = remove;
+	this.findLast = findLast;//查找链表中的最后节点
+	this.dispReverse = dispReverse;//反序显示双向链表中的元素
+	this.display = display;
+}
+function find(item){
+	var currNode = this.head;
+	while(currNode.element != item){
+		currNode = currNode.next;
+	}
+	return currNode;
+}
+
+function insert(newElement,item){
+	var newNode = new Node(newElement);
+	var current = this.find(item);
+	newNode.next = current.next;
+	newNode.previous = current;
+	// current.next.previous = newNode;
+	current.next = newNode;
+}
+function remove(item){
+	var currNode = this.find(item);
+	if(!(currNode.next == null)){
+		currNode.previous.next = currNode.next;
+		currNode.next.previous = currNode.previous;
+		currNode.next = null;
+		currNode.previous = null;
+	}
+}
+//查找链表最后的节点
+function findLast(){
+	var currNode = this.head;
+	while(!(currNode.next == null)){
+		currNode = currNode.next;
+	}
+	return currNode;
+}
+// 反序显示双向链表中的元素
+function dispReverse(){
+	var currNode = this.head;
+	currNode = this.findLast();
+	while(!(currNode.previous == null)){
+		print(currNode.element);
+		currNode = currNode.previous;
+	}
+}
+
+function display(){
+	var currNode = this.head;
+	while(!(currNode.next == null)){
+		print(currNode.next.element);
+		currNode = currNode.next;
+	}
+}
+
+
+//测试
+var cities = new LList();
+cities.insert("Conway","head");
+cities.insert("Russellville", "Conway");
+cities.insert("Alma", "Russellville");
+cities.insert("Carlisle", "Russellville");
+cities.display();//Conway   Russellville   Alma
+console.log();
+cities.remove("Carlisle");
+cities.display();
+print();
+cities.dispReverse();
\ No newline at end of file
diff --git a/Chapter7/Dictionary.js b/Chapter7/Dictionary.js
index 68c4c26..e42fe33 100644
--- a/Chapter7/Dictionary.js
+++ b/Chapter7/Dictionary.js
@@ -1,41 +1,41 @@
-function Dictionary() {
-   this.add = add;
-   this.datastore = new Array();
-   this.find = find;
-   this.remove = remove;
-   this.showAll = showAll;
-   this.count = count;
-   this.clear = clear;
+function Dictionary(){
+	this.datastore = new Array();
+	this.add = add;//添加一个键值对
+	this.find = find;//以键作为参数，返回和其关联的值
+	this.remove = remove;//同时删除键和与其关联的值
+	this.showAll = showAll;//显示字典中的所有键-值对
+	this.count = count;//返回字典中元素个数
+	this.clear = clear;//情况字典中的元素
 }
-
-function add(key, value) {
-   this.datastore[key] = value;
+function add(key,value){
+	this.datastore[key] = value;
 }
-
-function find(key) {
-   return this.datastore[key];
+function find(key){
+	return this.datastore[key];
 }
-
-function remove(key) {
-   delete this.datastore[key];
+function remove(key){
+	delete this.datastore[key];
 }
-
-function showAll() {
-   for each (var key in Object.keys(this.datastore).sort()) {
-      print(key + " -> " + this.datastore[key]);
-   }
+function showAll(){
+	var keys = Object.keys(this.datastore).sort(); //先将键进行排序
+	var res = new Dictionary();
+	for(var i=0;i<keys.length;i++){
+		res.add(keys[i],this.datastore[keys[i]]);
+		print(keys[i] + " -> " + this.datastore[keys[i]]);
+	}
 }
-
-function count() {
-   var n = 0;
-   for each (var key in Object.keys(this.datastore)) {
-      ++n;
-   }
-   return n;
+function count(){
+	// return Object.keys(this.datastore).length; 
+	var n = 0;
+	for(var key in this.datastore){
+		++n;
+	}
+	return n;
 }
-
-function clear() {
-   for each (var key in Object.keys(this.datastore)) {
-      delete this.datastore[key];
-   } 
+function clear(){
+	for(var key in this.datastore){
+		delete this.datastore[key];
+	}
 }
+
+
diff --git a/Chapter7/test.js b/Chapter7/test.js
new file mode 100644
index 0000000..5736303
--- /dev/null
+++ b/Chapter7/test.js
@@ -0,0 +1,19 @@
+//使用Dictionary类
+load("Dictionary.js");
+var pbook = new Dictionary();
+pbook.add("Mike","123");
+pbook.add("Mike","13");//重写了datastore[Mike]的值为13
+pbook.add("David", "345");
+pbook.add("Cynthia", "456");
+pbook.add("Mike", "723");
+pbook.add("Jennifer", "987");
+pbook.add("Danny", "012");
+pbook.add("Jonathan", "666");
+print("Number of entries: " + pbook.count());//Number of entries: 3
+print("David's extension: " + pbook.find("David"));//David's extension: 345
+pbook.remove("David");
+pbook.showAll();//Mike -> 13
+				//Cynthia -> 456
+pbook.clear();
+print("Number of entries: " + pbook.count());//Number of entries: 0
+pbook.showAll();//无输出
\ No newline at end of file
diff --git "a/Chapter7/\346\265\213\350\257\225length\345\261\236\346\200\247.js" "b/Chapter7/\346\265\213\350\257\225length\345\261\236\346\200\247.js"
new file mode 100644
index 0000000..e8dbb3b
--- /dev/null
+++ "b/Chapter7/\346\265\213\350\257\225length\345\261\236\346\200\247.js"
@@ -0,0 +1,13 @@
+var nums = new Array();
+nums[0] = 1;
+nums[1] = 2;
+print(nums.length); // 显示 2
+print(nums);//1,2
+
+//当键的类型为字符串的时候，length属性就不管用了
+
+var pbook = new Array();
+pbook["David"] = 1;
+pbook["Jennifer"] = 2;
+print(pbook.length); // 显示 0
+print(pbook);//无输出
\ No newline at end of file
diff --git a/Chapter8/Hash.js b/Chapter8/Hash.js
new file mode 100644
index 0000000..4322e89
--- /dev/null
+++ b/Chapter8/Hash.js
@@ -0,0 +1,130 @@
+// 使用散列表存储数据时，通过一个散列函数将键映射为一个数字，这个数字的范围是0到散列表的长度
+// 需要解决的问题
+	// 1.collision碰撞  即使使用一个高效的散列函数，依然存在将两个键映射成同一个值的可能
+	// 2.对数组大小常见的限制是：数组长度应该是一个质数
+//散列函数的选择依赖于键值的数据类型，如果键是整型，最简单的散列函数就是以数组的长度对键取余
+// 字符串类型的散列函数，将字符串中每个字符的ASCII码值相加的和除以数组长度 取的余数就是散列值
+	// 1.除留取余法
+
+function HashTable(){
+	this.table = new Array(137);
+	this.simpleHash = simpleHash;//计算散列值的方法
+	this.showDistro = showDistro;//显示散列表数据分布
+	this.betterHash = betterHash;
+	this.put = put;//向散列中插入数据
+	this.get = get;//从散列表中读取数据
+	this.buildChains = buildChains;
+}
+function simpleHash(data){
+	var total = 0;
+	for(var i=0;i<data.length;++i){
+		total += data.charCodeAt(i); 
+	}
+	print("Hash value: " + data + " -> " + total);
+	return total % this.table.length;
+}
+//使用霍纳算法的更好的散列函数
+function betterHash(string){
+	const H = 37;
+	var total = 0;
+	for(var i=0;i<string.length;i++){
+		total += H * total + string.charCodeAt(i);//求和时每次乘以一个质数
+	}
+	total = total % this.table.length;
+	if(total < 0){
+		total += this.table.length-1;
+	}
+	return parseInt(total);
+}
+// function put(data){
+// 	// var pos = this.simpleHash(data);
+// 	var pos = this.betterHash(data);
+// 	this.table[pos] = data;
+// }
+
+// function put(key,data){
+// 	var pos = this.betterHash(key);
+// 	this.table[pos] = data;
+// }
+
+function put(key, data) {
+	var pos = this.betterHash(key);
+	var index = 0;
+	if (this.table[pos][index] == undefined) {
+		this.table[pos][index+1] = data;
+	}
+	++index;
+	else{
+		while (this.table[pos][index] != undefined) {
+			++index;
+		}
+		this.table[pos][index+1] = data;
+	}
+}
+
+// function get(key){
+// 	return this.table[this.betterHash(key)];
+// }
+
+function get(key){
+	var index = 0;
+	var hash = this.betterHash(key);
+	if (this.table[pos][index] = key) {
+		return this.table[pos][index+1];
+	}
+	index += 2;
+	else {
+		while (this.table[pos][index] != key) {
+			index += 2;
+		}
+		return this.table[pos][index+1];
+	}
+	return undefined;
+}
+
+function showDistro(){
+	var n = 0;
+	for(var i=0;i<this.table.length;++i){
+		if(this.table[i][0] != undefined){
+			print(i + ": " + this.table[i]);
+		}
+	}
+}
+
+//散列化整型键
+function getRandomInt(min,max){
+	return Math.floor(Math.random() * (max-min+1)) + min; //随机产生min-max之间的值  包括min和max
+}
+function genStuData(arr){//生成学生的数据
+	for(var i=0;i<arr.length;++i){
+		var num = "";//将数字转成字符串 方便连接
+		for(var j=1;j<=9;j++){
+			num += Math.floor(Math.random()*10);
+		}//用来生成学生的ID
+		num += getRandomInt(50,100); //生成一个随机的成绩  并且把成绩缀在ID的后面
+		arr[i] = num;
+	}
+}
+
+//讨论两种解决碰撞的方法
+// 1.开链法
+// 开链法是指实现散列表的底层数组中，每个数组元素又是一个新的数据结构，比如另一个数组，这样就能存储多个键了
+// 使用这种技术，即使两个键散列后的值相同，依然被保存在同样的位置，只不过它们在第二个数组中的位置不一样罢了
+// 实现开链法的方法是：在创建存储散列过的键值的数组时，通过调用一个函数创建一个新
+
+// 的空数组，然后将该数组赋给散列表里的每个数组元素。这
+function buildChains(){
+	for(var i=0;i<this.table.length;++i){
+		this.table[i] = new Array();
+	}
+}
+
+// 2.线性探测法
+// 开放寻址散列 。当发生碰撞时，线性探测法检查散列表中的下一个位置是否为空。如果为空，
+// 就将数据存入该位置；如果不为空，则继续检查下一个位置，直到找到一个空的位置为
+// 止。
+
+// 当存储数据使用的数组特别大时，选择线性探测法要比开链法好。这里有一个公式，常常
+// 可以帮助我们选择使用哪种碰撞解决办法：如果数组的大小是待存储数据个数的 1.5 倍，
+// 那么使用开链法；如果数组的大小是待存储数据的两倍及两倍以上时，那么使用线性探
+// 测法。
\ No newline at end of file
diff --git a/Chapter8/test.js b/Chapter8/test.js
new file mode 100644
index 0000000..1324a0d
--- /dev/null
+++ b/Chapter8/test.js
@@ -0,0 +1,57 @@
+load("Hash.js");
+// var someNames = ["David", "Jennifer", "Donnie", "Raymond",
+// "Cynthia", "Mike", "Clayton", "Danny", "Jonathan"];
+// var hTable = new HashTable();
+// for (var i = 0; i < someNames.length; ++i) {
+// 	hTable.put(someNames[i]);
+// }
+// hTable.showDistro();
+
+
+
+// var numStudents = 10;
+// var arrSize = 97;
+// var idLen = 9;
+// var students = new Array(numStudents);
+// genStuData(students);
+// print ("Student data: \n");
+// for (var i = 0; i < students.length; ++i) {
+// 	print(students[i].substring(0,8) + " " +
+// 	students[i].substring(9));
+// }
+// print("\n\nData distribution: \n");
+// var hTable = new HashTable();
+// for (var i = 0; i < students.length; ++i) {
+// 	hTable.put(students[i]);
+// }
+// hTable.showDistro();
+
+
+// var pnumbers = new HashTable();
+// var name, number;
+// for (var i = 0; i < 3; i++) {
+// 	putstr("Enter a name (space to quit): ");
+// 	name = readline();
+// 	putstr("Enter a number: ");
+// 	number = readline();
+// }
+// name = "";
+// putstr("Name for number (Enter quit to stop): ");
+// while (name != "quit") {
+// 	name = readline();
+// 	if (name == "quit") {
+// 		break;
+// }
+// print(name + "'s number is " + pnumbers.get(name));
+// putstr("Name for number (Enter quit to stop): ");
+// }
+
+
+var hTable = new HashTable();
+hTable.buildChains();
+var someNames = ["David", "Jennifer", "Donnie", "Raymond",
+"Cynthia", "Mike", "Clayton", "Danny", "Jonathan"];
+for (var i = 0; i < someNames.length; ++i) {
+	hTable.put(someNames[i]);
+}
+hTable.showDistro();
\ No newline at end of file
diff --git a/Chapter9/Set.js b/Chapter9/Set.js
index 9be3e61..3e1d8ff 100644
--- a/Chapter9/Set.js
+++ b/Chapter9/Set.js
@@ -1,112 +1,72 @@
-function Set() {
-   this.dataStore = [];
-   this.add = add;
-   this.remove = remove;
-   this.size = size;
-   this.union = union;
-   this.contains = contains;
-   this.intersect = intersect;
-   this.subset = subset;
-   this.difference = difference;
-   this.show = show;
-}
+/*集合是一种包含不同元素的数据结构
+集合中的元素称为成员
+集合中的成员是无序的
+集合中不允许相同成员存在*/
 
-function add(data) {
-   if (this.dataStore.indexOf(data) < 0) {
-      this.dataStore.push(data);
-      return true;
-   } 
-   else {
-      return false;
-   }
+function Set(){
+	this.dataStore = [];
+	this.add = add;
+	this.remove = remove;
+	this.size = size;
+	this.contains = contains;//检查一个成员是否属于该集合
+	this.union = union;//并集
+	this.intersect = intersect;
+	this.subset = subset;
+	this.difference = difference;
+	this.show = show;
 }
 
-function remove(data) {
-   var pos = this.dataStore.indexOf(data);
-   if (pos > -1) {
-      this.dataStore.splice(pos,1);
-      return true;
-   }
-   else {
-      return false;
-   }
+//因为集合中不能包含相同的元素，所以插入前使用 indexOf() 检查新加入的元素在数组中是否存在。如果找到，
+// 该方法返回该元素在数组中的位置；如果没有找到，该方法返回 -1
+function add(data){
+	if(this.dataStore.indexOf(data) < 0){
+		this.dataStore.push(data);
+		return true;
+	}else{
+		return false;
+	}
 }
 
-function size() {
-   return this.dataStore.length;
+function remove(data){
+	var pos = this.dataStore.indexOf(data);
+	if(pos > -1){
+		this.dataStore.splice(pos,1);
+		return true;
+	}else{
+		return false;
+	}
 }
 
-function show() {
-   return "[" + this.dataStore + "]";
+function show(){
+	return this.dataStore;
 }
 
-function contains(data) {
-   if (this.dataStore.indexOf(data) > -1) {
-      return true;
-   }
-   else {
-      return false;
-   }
+function contains(data){
+	if(this.dataStore.indexOf(data) > -1){
+		return true;
+	}else{
+		return false;
+	}
 }
-
-function union(set) {
-   var tempSet = new Set();
-   for (var i = 0; i < this.dataStore.length; ++i) {
-      tempSet.add(this.dataStore[i]);
-   }
-   for (var i = 0; i < set.dataStore.length; ++i) {
-      if (!tempSet.contains(set.dataStore[i])) {
-         tempSet.dataStore.push(set.dataStore[i]);
-      }
-   }
-   return tempSet;
+function union(set){
+	var tempSet = new Set();
+	for(var i=0;i<this.dataStore.length;++i){
+		tempSet.add(this.dataStore[i]);
+	}
+	for(var i=0;i<set.dataStore.length;++i){
+		if(!tempSet.contains(set.dataStore[i])){
+			tempSet.dataStore.push(set.dataStore[i]);
+		}
+	}
+	return tempSet;
 }
 
 function intersect(set) {
-   var tempSet = new Set();
-   for (var i = 0; i < this.dataStore.length; ++i) {
-      if (set.contains(this.dataStore[i])) {
-         tempSet.add(this.dataStore[i]);
-      }
-   }
-   return tempSet;
-}
-
-function subset(set) {
-   if (this.size() > set.size()) {
-      return false;
-   }
-   else {
-      for each (var member in this.dataStore) {
-         if (!set.contains(member)) {
-            return false;
-         }
-      }
-   }
-   return true;
-}
-
-function difference(set) {
-   var tempSet = new Set();
-   for (var i = 0; i < this.dataStore.length; ++i) {
-      if (!set.contains(this.dataStore[i])) {
-         tempSet.add(this.dataStore[i]);
-      }
-   }
-   return tempSet;
-}  
-
-
-// main program
-
-var cis = new Set();
-var it = new Set();
-cis.add("Clayton");
-cis.add("Jennifer");
-cis.add("Danny");
-it.add("Bryan");
-it.add("Clayton");
-it.add("Jennifer");
-var diff = new Set();
-diff = cis.difference(it);
-print(cis.show() + " difference " + it.show() + " -> " + diff.show());
\ No newline at end of file
+	var tempSet = new Set();
+	for (var i = 0; i < this.dataStore.length; ++i) {
+		if (set.contains(this.dataStore[i])) {
+			tempSet.add(this.dataStore[i]);
+		}
+	}
+	return tempSet;
+}
\ No newline at end of file
diff --git a/Chapter9/Set1.js b/Chapter9/Set1.js
new file mode 100644
index 0000000..d288398
--- /dev/null
+++ b/Chapter9/Set1.js
@@ -0,0 +1,112 @@
+function Set() {
+   this.dataStore = [];
+   this.add = add;
+   this.remove = remove;
+   this.size = size;
+   this.union = union;
+   this.contains = contains;
+   this.intersect = intersect;
+   this.subset = subset;
+   this.difference = difference;
+   this.show = show;
+}
+
+function add(data) {
+   if (this.dataStore.indexOf(data) < 0) {
+      this.dataStore.push(data);
+      return true;
+   } 
+   else {
+      return false;
+   }
+}
+
+function remove(data) {
+   var pos = this.dataStore.indexOf(data);
+   if (pos > -1) {
+      this.dataStore.splice(pos,1);
+      return true;
+   }
+   else {
+      return false;
+   }
+}
+
+function size() {
+   return this.dataStore.length;
+}
+
+function show() {
+   return "[" + this.dataStore + "]";
+}
+
+function contains(data) {
+   if (this.dataStore.indexOf(data) > -1) {
+      return true;
+   }
+   else {
+      return false;
+   }
+}
+
+function union(set) {
+   var tempSet = new Set();
+   for (var i = 0; i < this.dataStore.length; ++i) {
+      tempSet.add(this.dataStore[i]);
+   }
+   for (var i = 0; i < set.dataStore.length; ++i) {
+      if (!tempSet.contains(set.dataStore[i])) {
+         tempSet.dataStore.push(set.dataStore[i]);
+      }
+   }
+   return tempSet;
+}
+
+function intersect(set) {
+   var tempSet = new Set();
+   for (var i = 0; i < this.dataStore.length; ++i) {
+      if (set.contains(this.dataStore[i])) {
+         tempSet.add(this.dataStore[i]);
+      }
+   }
+   return tempSet;
+}
+
+function subset(set) {
+   if (this.size() > set.size()) {
+      return false;
+   }
+   else {
+      for each (var member in this.dataStore) {
+         if (!set.contains(member)) {
+            return false;
+         }
+      }
+   }
+   return true;
+}
+
+function difference(set) {
+   var tempSet = new Set();
+   for (var i = 0; i < this.dataStore.length; ++i) {
+      if (!set.contains(this.dataStore[i])) {
+         tempSet.add(this.dataStore[i]);
+      }
+   }
+   return tempSet;
+}  
+
+
+// main program
+
+var cis = new Set();
+var it = new Set();
+cis.add("Clayton");
+cis.add("Jennifer");
+cis.add("Danny");
+it.add("Bryan");
+it.add("Clayton");
+it.add("Jennifer");
+var diff = new Set();
+diff = cis.difference(it);
+print(cis.show() + " difference " + it.show() + " -> " + diff.show());
\ No newline at end of file
diff --git a/Chapter9/test.js b/Chapter9/test.js
new file mode 100644
index 0000000..3268ed1
--- /dev/null
+++ b/Chapter9/test.js
@@ -0,0 +1,27 @@
+load("Set.js");
+var names = new Set();
+names.add("David");
+names.add("Jennifer");
+names.add("Cynthia");
+names.add("Mike");
+names.add("Raymond");
+if (names.add("Mike")) {
+	print("Mike added")
+}else {
+	print("Can't add Mike, must already be in set");
+}
+print(names.show());
+var removed = "Mike";
+if (names.remove(removed)) {
+	print(removed + " removed.");
+}else {
+	print(removed + " not removed.");
+}
+names.add("Clayton");
+print(names.show());
+removed = "Alisa";
+if (names.remove("Mike")) {
+	print(removed + " removed.");
+}else {
+	print(removed + " not removed.");
+}
\ No newline at end of file
diff --git "a/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test1.js" "b/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test1.js"
new file mode 100644
index 0000000..f0a518d
--- /dev/null
+++ "b/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test1.js"
@@ -0,0 +1,26 @@
+// 创建一个记录学生成绩的对象，
+// 提供一个添加成绩的方法，
+// 以及一个显示学生平均成绩的方法。
+function grade(){
+	this.dataStore = [];//记录成绩
+	this.add = add;//添加成绩
+	this.average = average;//求平均成绩
+}
+function add(temp){
+	this.dataStore.push(temp);
+}
+function average(){
+	var total = 0;
+	for(var i=0;i<this.dataStore.length;i++){
+		total+=this.dataStore[i];
+	}
+	return total/this.dataStore.length;
+}
+var grades = new grade();
+grades.add(78);
+grades.add(80);
+grades.add(68);
+grades.add(84);
+grades.add(85);
+grades.add(90);
+print(grades.average().toFixed(2));//80.83
\ No newline at end of file
diff --git "a/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test2.js" "b/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test2.js"
new file mode 100644
index 0000000..816f866
--- /dev/null
+++ "b/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test2.js"
@@ -0,0 +1,30 @@
+// 将一组单词存储在一个数组中，
+// 并按正序和倒序分别显示这些单词。
+
+// var str = ["Hello","Java","and","JavaScript"];
+// print(str.join(" "));//Hello Java and JavaScript  //正序输出
+// print(str.reverse().join(" "));//JavaScript and Java Hello //倒序输出
+
+var SortWord = function(){
+	var _this = this;
+	_this.wordStore = ["David","Mike","Cynthia","Clayton","Bryan","Raymond","And","and"];
+	var strategy = {
+		//正序
+		asc:function(){
+			_this.wordStore.sort();
+		},
+		//倒序
+		desc:function(){
+			// _this.wordStore.sort(function(a,b){
+			// 	return b>a;
+			// });  //方法1
+			_this.wordStore.sort().reverse();  //方法2
+		}
+	};
+	_this.sort = function(rule){
+		strategy[rule]();
+		return _this.wordStore;
+	}
+}
+print(new SortWord().sort('asc'));//And,Bryan,Clayton,Cynthia,David,Mike,Raymond,and
+print(new SortWord().sort('desc'));//and,Raymond,Mike,David,Cynthia,Clayton,Bryan,And
diff --git "a/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test3.js" "b/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test3.js"
new file mode 100644
index 0000000..98f1747
--- /dev/null
+++ "b/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test3.js"
@@ -0,0 +1,29 @@
+// 修改本章前面出现过的 weeklyTemps 对象，
+// 使它可以使用一个二维数组来存储每月的有用数据。
+// 增加一些方法用以显示月平均数、
+// 具体某一周平均数和所有周的平均数。
+function weekTemps(){
+	this.dataStore = [];
+	this.add = add;
+	this.average = average;
+}
+function add(temp) {
+	this.dataStore.push(temp);
+}
+function average() {
+	var total = 0;
+	for (var i = 0; i < this.dataStore.length; ++i) {
+		total += this.dataStore[i];
+	}
+	return total / this.dataStore.length;
+}
+var thisWeek = new weekTemps();
+thisWeek.add(52);
+thisWeek.add(55);
+thisWeek.add(61);
+thisWeek.add(65);
+thisWeek.add(55);
+thisWeek.add(50);
+thisWeek.add(52);
+thisWeek.add(49);
+print(thisWeek.average()); // 显示 54.875
\ No newline at end of file
diff --git "a/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test4.js" "b/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test4.js"
new file mode 100644
index 0000000..3d104d7
--- /dev/null
+++ "b/\350\257\276\345\220\216\347\273\203\344\271\240\351\242\230/Chapter2/test4.js"
@@ -0,0 +1,9 @@
+// 创建这样一个对象，它将字母存储在一个数组中，
+// 并且用一个方法可以将字母连在一起，显示成一个单词。
+var Word = {
+	letters:['H','e','l','l','o'],
+	getWord:function(){
+		return this.letters.join('');//Hello
+	}
+};
+print(Word.getWord());
\ No newline at end of file