update

Author: longshilin

src/dataStructure/linkedList/README.md

@@ -16,7 +16,7 @@
 准备在 链表操作中需要用到的变量及类。
 ```java
 class DATA{
-	String key;				// 结点的关键字
+	String key;			// 结点的关键字
 	String name;
 	int age;
 }
@@ -44,18 +44,18 @@ CLType CLAddEnd(CLType head, DATA nodeData){
 		System.out.println("申请内存失败!\n");
 		return null;
 	}else{
-		node.nodeData = nodeData;				// 在新申请的结点中保存数据
-		node.nextNode = null;					// 设置结点引用为空，即为表尾
-		if(head == null){						// 当head为空时，加入的新结点即为头引用
+		node.nodeData = nodeData;		// 在新申请的结点中保存数据
+		node.nextNode = null;		// 设置结点引用为空，即为表尾
+		if(head == null){		// 当head为空时，加入的新结点即为头引用
 			head = node;
 			return head;
 		}
 		htemp = head;
-		while(htemp.nextNode != null){			// 查找链表的末尾
+		while(htemp.nextNode != null){		// 查找链表的末尾
 			htemp = htemp.nextNode;
 		}
-		htemp.nextNode = node;					// 在链表的末尾插入该结点
-		return head;							// 返回指代整个链表的头引用
+		htemp.nextNode = node;		// 在链表的末尾插入该结点
+		return head;		// 返回指代整个链表的头引用
 	}
 }
 ```
@@ -73,9 +73,9 @@ CLType CLAddFirst(CLType head, DATA nodeData){
 		System.out.println("申请内存失败!\n");
 		return null;
 	}else{
-		node.nodeData = nodeData;				// 保存数据
-		node.nextNode = head;					// 新加入的头结点的nextNode指向头引用所指的结点
-		head = node;							// 头引用指向新节点
+		node.nodeData = nodeData;		// 保存数据
+		node.nextNode = head;		// 新加入的头结点的nextNode指向头引用所指的结点
+		head = node;		// 头引用指向新节点
 		return head;
 	}
 }
@@ -86,7 +86,7 @@ CLType CLAddFirst(CLType head, DATA nodeData){
 CLType CLFindNode(CLType head, String key){
 	CLType htemp;
 	htemp = head;
-	while(htemp!=null){							// 循环遍历，寻找关键字匹配的结点
+	while(htemp!=null){			// 循环遍历，寻找关键字匹配的结点
 		if(htemp.nodeData.key.compareTo(key)==0){	
 			return htemp;
 		}
@@ -137,8 +137,8 @@ int CLDeleteNode(CLType head, String key){		// 删除关键字结点
 			tempnode.nextNode = htemp.nextNode;		// 当前结点的引用指向下一个结点的引用，以此删除htemp结点
 			return 1;
 		}
-		tempnode = htemp;							// 保存当前结点
-		htemp = htemp.nextNode;						// 指向下一个结点
+		tempnode = htemp;			// 保存当前结点
+		htemp = htemp.nextNode;			// 指向下一个结点
 	}
 	return 0;
 }

src/dataStructure/orderList/README.md

@@ -51,7 +51,7 @@ int SLInsert(SLType SL, int n, DATA data){			// 插入结点到顺序表中间
 		return 0;
 	}
 
-	for(int i=SL.ListLen;i>=n;i--){		// 将插入位置n后续的结点都向后移动一位
+	for(int i=SL.ListLen;i>=n;i--){			// 将插入位置n后续的结点都向后移动一位
 		SL.ListData[i+1]=SL.ListData[i];
 	}
 	SL.ListData[n]=data;			// 插入结点
@@ -62,7 +62,7 @@ int SLInsert(SLType SL, int n, DATA data){			// 插入结点到顺序表中间
 ## 追加结点
 追加结点并不是一个基本的数据结构运算，其可以看作插入结点的一种特殊形式，相当于在顺序表的末尾新增一个数据结点。由于追加结点的特殊性，其代码实现比插入结点要简单，因为不必进行大量数据的移动。
 ```java
-int SLAdd(SLType SL, DATA data){			// 增加元素到顺序表尾部
+int SLAdd(SLType SL, DATA data){		// 增加元素到顺序表尾部
 	if(SL.ListLen>=MAXLEN){			// 顺序表已满
 		System.out.println("顺序表已满，不能再添加结点!\n");
 		return 0;
@@ -74,14 +74,14 @@ int SLAdd(SLType SL, DATA data){			// 增加元素到顺序表尾部
 ## 删除结点
 删除结点即删除线性表L中的第i个结点，使得其后的所有结点编号依次减1。删除一个结点之后，线性表L的长度将变为n-1。删除结点和插入结点类似，都需要进行大量数据的移动。
 ```java
-int SLDelete(SLType SL, int n){			// 按位删除顺序表的结点
+int SLDelete(SLType SL, int n){		// 按位删除顺序表的结点
 
-	if(n<1 || n>SL.ListLen+1){			// 删除结点序号不正确
+	if(n<1 || n>SL.ListLen+1){		// 删除结点序号不正确
 		System.out.println("删除结点序号错误，不能删除结点!\n");
 		return 0;
 	}
 
-	for(int i=n;i<SL.ListLen;i++){			// 将插入位置n后续的结点都向前移动一位
+	for(int i=n;i<SL.ListLen;i++){		// 将插入位置n后续的结点都向前移动一位
 		SL.ListData[i]=SL.ListData[i+1];
 	}
 	SL.ListLen--;

src/dataStructure/queue/README.md

@@ -13,8 +13,8 @@ class DATA{
 class SQType{
 	static final int QUEUELEN = 15;
 	DATA[] data = new DATA[QUEUELEN];		// 队列顺序结构数组
-	int head;								// 队头
-	int tail;								// 队尾
+	int head;		// 队头
+	int tail;		// 队尾
 }
 ```
 在上述代码中，定义了队列结构的最大长度QUEUELEN，队列结构数据元素的类DATA及队列结构的类SQType。在类SQType中，data为数据元素，head为队头的序号，tail为队尾的序号。当head=0时表示队列为空，当tail=QUEUELEN时表示队列已满。
@@ -24,7 +24,7 @@ class SQType{
 1. 按符号常量QUEUELEN指定的大小申请一片内存空间，用来保存队列中的数据。
 2. 设置head=0和tail=0，表示一个空栈。
 ```java
-SQType SQTypeInit(){				// 队列初始化
+SQType SQTypeInit(){	// 队列初始化
 	SQType q;
 	if((q=new SQType())!=null){		// 申请内存
 		q.head = 0;											
@@ -40,7 +40,7 @@ SQType SQTypeInit(){				// 队列初始化
 ## 判断空队列
 判断空队列即判断一个队列结构是否为空。如果是空队列，则表示该队列结构中没有数据。此时可以进行入队列，但不可以进行出队列。
 ```java
-int SQTypeIsEmpty(SQType q){		// 判断队列空
+int SQTypeIsEmpty(SQType q){	// 判断队列空
 	int temp = 0;
 	if(q.head == q.tail)
 		temp = 1;
@@ -51,7 +51,7 @@ int SQTypeIsEmpty(SQType q){		// 判断队列空
 ## 判断满队列
 判断满队列即判断一个队列结构是否为满。如果是满队列，则表示该队列结构中没有多余的空间来保存额外数据。此时不可以进行入队列操作，但是可以进行出队列操作。
 ```java
-int SQTypeIsFull(SQType q){			// 判断队列满
+int SQTypeIsFull(SQType q){		// 判断队列满
 	int temp = 0;
 	if(q.tail==QUEUELEN){
 		temp=1;
@@ -61,14 +61,14 @@ int SQTypeIsFull(SQType q){			// 判断队列满
 ```
 ## 清空队列
 ```java
-void SQTypeClear(SQType q){			// 清空队列
+void SQTypeClear(SQType q){		// 清空队列
 	q.head = 0;
 	q.tail = 0;
 }
 ```
 ## 释放空间
 ```java
-void SQTypeFree(SQType q){			// 释放队列
+void SQTypeFree(SQType q){		// 释放队列
 	if(q != null){
 		q = null;
 	}
@@ -85,7 +85,7 @@ int InSQType(SQType q, DATA data){		// 入队列
 		System.out.println("队列已满! 操作失败!\n");
 		return 0;
 	}
-	q.data[q.tail++] = data;			// 顺序入队列，并将队尾指针+1
+	q.data[q.tail++] = data;		// 顺序入队列，并将队尾指针+1
 	return 1;
 }
 ```
@@ -97,12 +97,12 @@ int InSQType(SQType q, DATA data){		// 入队列
 2. 从队列首部取出队头元素（实际是返回队头元素的引用）。
 3. 设修改队头head的序号，使其指向后一个元素。
 ```java
-DATA OutSQType(SQType q){				// 出队列
+DATA OutSQType(SQType q){		// 出队列
 	if(q.head==q.tail){
 		System.out.println("队列已空! 操作失败!\n");
 		return null;
 	}else{
-		return q.data[q.head++];		// 顺序出队列，并将队首指针+1
+		return q.data[q.head++];	// 顺序出队列，并将队首指针+1
 	}
 }
 ```
@@ -111,7 +111,7 @@ DATA OutSQType(SQType q){				// 出队列
 ## 读结点数据
 读操作其实是读取队列头的数据。需要注意的是，读结点数据的操作和出队列操作不同。读结点数据的操作仅显示队列顶结点数据的内容，而出队列操作则将队列顶数据弹出，该数据不再存在。
 ```java
-DATA PeekSQType(SQType q){			//读结点数据
+DATA PeekSQType(SQType q){		//读结点数据
 	if(SQTypeIsEmpty(q)==1){
 		System.out.println("\n空队列");
 		return null;
@@ -124,7 +124,7 @@ DATA PeekSQType(SQType q){			//读结点数据
 ## 计算队列长度
 计算队列长度即统计该队列中数据结点的个数。计算队列长度的方法比较简单，用队尾序号减去队头序号即可。
 ```java
-int SQTypeLen(SQType q){			// 计算队列长度
+int SQTypeLen(SQType q){		// 计算队列长度
 	int temp;
 	temp=q.tail - q.head;
 	return temp;

src/dataStructure/stack/README.md

@@ -13,7 +13,7 @@ class DATA{
 class StackType{				
 	static final int MAXLEN = 50;
 	DATA[] data = new DATA[MAXLEN+1];	// 构建栈结构
-	int top;							// 栈顶
+	int top;		// 栈顶
 }
 ```
 在上述代码中，定义了栈结构的最大长度MAXLEN，栈结构数据元素的类DATA及栈结构的类StackType。在类StackType中，data为数据元素，top为栈顶的序号。当top=0时表示栈为空，当top=SIZE时表示栈满。
@@ -24,40 +24,40 @@ Java语言中数组都是从下标0开始的。在这里，为了讲述和理解
 1. 按符号常量SIZE指定的大小申请一片内存空间，用来保存栈中的数据。
 - 设置栈顶引用的值为0，表示一个空栈。
 ```java
-StackType STInit(){						// 栈的初始化
+StackType STInit(){		// 栈的初始化
 	StackType p;
 	if((p=new StackType())!=null){		// 申请栈内存
-		p.top = 0;						// 设置栈顶为0
-		return p;						// 返回指向栈的引用
+		p.top = 0;		// 设置栈顶为0
+		return p;		// 返回指向栈的引用
 	}
 	return null;
 }
 ```
 ## 判断空栈
 判断空栈即判断一个栈结构是否为空。如果是空栈，则表示该结构中没有数据。此时可以进行入栈操作，但不可以进行出栈操作。
 ```java
-boolean STIsEmpty(StackType s){			// 判断栈是否为空
+boolean STIsEmpty(StackType s){		// 判断栈是否为空
 	return s.top==0;
 }
 ```
 ## 判断满栈
 如果是满栈，则表示该结构中没有多余的空间来保存额外数据。此时不可以进行入栈操作，但是可以进行出栈操作。
 ```java
-boolean STIsFull(StackType s){			// 判断栈是否已满
+boolean STIsFull(StackType s){		// 判断栈是否已满
 	return s.top==MAXLEN;
 }
 ```
 ## 清空栈
 清空栈即清除栈中的所有数据，在程序中简单地将栈顶引用top设置为0，表示执行清空栈操作。
 ```java
-void STClear(StackType s){				// 清空栈
+void STClear(StackType s){		// 清空栈
 	s.top = 0;
 }
 ```
 ## 释放空间
 释放空间即释放栈结构所占用的内存单元，程序中，直接赋值null操作释放所分配的内存。一般在不需要使用栈结构的时候使用，特别是程序结束时。
 ```java
-void STFree(StackType s){				// 释放栈所占用的空间
+void STFree(StackType s){		// 释放栈所占用的空间
 	if(s != null){
 		s = null;
 	}
@@ -74,7 +74,7 @@ int PushST(StackType s, DATA data){		// 入栈
 		System.out.println("栈溢出!\n");
 		return 0;
 	}
-	s.data[++s.top] = data;				// 元素入栈，top指针+1
+	s.data[++s.top] = data;		// 元素入栈，top指针+1
 	return 1;
 }
 ```
@@ -84,20 +84,20 @@ int PushST(StackType s, DATA data){		// 入栈
 2. 将栈顶引用top所指位置的元素返回。
 3. 设置top=top-1，也就是使栈顶引用减1，指向栈的下一个元素，原来栈顶元素被弹出。
 ```java
-DATA PopST(StackType s){				// 出栈
+DATA PopST(StackType s){		// 出栈
 	if(s.top==0){
 		System.out.println("栈为空!\n");
 		return null;
 	}
-	return s.data[s.top--];				// 元素出栈，top指针-1
+	return s.data[s.top--];		// 元素出栈，top指针-1
 }
 ```
 ## 读结点数据
 读结点数据即读取栈结构中结点的数据。由于栈结构只能在一段进行操作，因此这里的读操作其实就是读取栈顶的数据。
 
 需要注意的是，读结点数据的操作和出栈的操作不同。读结点数据的操作仅显示栈顶结点数据的内容，而出栈操作则是将栈顶数据弹出，该数据不再存在了。
 ```java
-DATA PeekST(StackType s){				// 读栈顶数据
+DATA PeekST(StackType s){		// 读栈顶数据
 	if(s.top==0){
 		System.out.println("栈为空! 出栈失败!\n");
 		System.exit(0);