update

Author: longshilin

src/dataStructure/linkedList/README.md

@@ -16,7 +16,7 @@
 准备在 链表操作中需要用到的变量及类。
 ```java
 class DATA{
-	String key;	// 结点的关键字
+	String key;				// 结点的关键字
 	String name;
 	int age;
 }
@@ -44,7 +44,7 @@ CLType CLAddEnd(CLType head, DATA nodeData){
 		System.out.println("申请内存失败!\n");
 		return null;
 	}else{
-		node.nodeData = nodeData;			// 在新申请的结点中保存数据
+		node.nodeData = nodeData;				// 在新申请的结点中保存数据
 		node.nextNode = null;					// 设置结点引用为空，即为表尾
 		if(head == null){						// 当head为空时，加入的新结点即为头引用
 			head = node;
@@ -73,7 +73,7 @@ CLType CLAddFirst(CLType head, DATA nodeData){
 		System.out.println("申请内存失败!\n");
 		return null;
 	}else{
-		node.nodeData = nodeData;			// 保存数据
+		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;
 		}
@@ -133,12 +133,12 @@ int CLDeleteNode(CLType head, String key){		// 删除关键字结点
 	htemp = head;
 	tempnode = head;
 	while(htemp != null){
-		if(htemp.nodeData.key.compareTo(key)==0){ // 遍历查找
-			tempnode.nextNode = htemp.nextNode;	// 当前结点的引用指向下一个结点的引用，以此删除htemp结点
+		if(htemp.nodeData.key.compareTo(key)==0){ 	// 遍历查找
+			tempnode.nextNode = htemp.nextNode;		// 当前结点的引用指向下一个结点的引用，以此删除htemp结点
 			return 1;
 		}
 		tempnode = htemp;							// 保存当前结点
-		htemp = htemp.nextNode;					// 指向下一个结点
+		htemp = htemp.nextNode;						// 指向下一个结点
 	}
 	return 0;
 }
@@ -162,7 +162,7 @@ int CLLength(CLType head){			//返回结点总数
 
 ## 显示所有结点
 ```java
-void CLAllNode(CLType head){			// 遍历链表输出所有数据
+void CLAllNode(CLType head){		// 遍历链表输出所有数据
 	CLType htemp;
 	htemp = head;
 	System.out.printf("\n当前链表共有%d个结点。链表所有数据如下：\n",CLLength(head));

src/dataStructure/orderList/README.md

@@ -6,7 +6,7 @@
 ## 准备数据
 准备在顺序表操作中需要用到的变量及数据结构等。
 ```java
-class DATA{						// 定义数据元素结构
+class DATA{							// 定义数据元素结构
 	String key;						// 结点的关键字
 	String name;
 	int age;
@@ -19,7 +19,7 @@ class DATA{						// 定义数据元素结构
 class SLType{
 	static final int MAXLEN=100;
 	DATA[] ListData = new DATA[MAXLEN+1];	// 保存顺序表的结构数组
-	int ListLen;				// 顺序表已存结点的数量
+	int ListLen;							// 顺序表已存结点的数量
 }
 ```
 ## 初始化顺序表
@@ -39,25 +39,25 @@ int SLLength(SLType SL){			// 返回顺序表的元素数量
 ## 插入结点
 插入结点就是在线性表L的第i个位置插入一个新的结点，使得其后的结点编号依次加1。
 ```java
-int SLInsert(SLType SL, int n, DATA data){		// 插入结点到顺序表中间的位置
+int SLInsert(SLType SL, int n, DATA data){	// 插入结点到顺序表中间的位置
 
-	if(SL.ListLen>=MAXLEN){			// 顺序表已满
+	if(SL.ListLen>=MAXLEN){				// 顺序表已满
 		System.out.println("顺序表已满，不能插入结点!\n");
 		return 0;
 	}
 
-	if(n<1 || n>SL.ListLen-1){		// 校验插入位置的合法性
+	if(n<1 || n>SL.ListLen-1){			// 校验插入位置的合法性
 		System.out.println("插入元素序号错误，不能插入元素!\n");
 		return 0;
 	}
 
 	for(int i=SL.ListLen;i>=n;i--){		// 将插入位置n后续的结点都向后移动一位
 		SL.ListData[i+1]=SL.ListData[i];
 	}
-	SL.ListData[n]=data;			// 插入结点
-	SL.ListLen++;					// 顺序表节点数量加1
-	return 1;						//成功插入，返回1
-}
+	SL.ListData[n]=data;					// 插入结点
+	SL.ListLen++;							// 顺序表节点数量加1
+	return 1;								//成功插入，返回1
+}		
 ```
 ## 追加结点
 追加结点并不是一个基本的数据结构运算，其可以看作插入结点的一种特殊形式，相当于在顺序表的末尾新增一个数据结点。由于追加结点的特殊性，其代码实现比插入结点要简单，因为不必进行大量数据的移动。
@@ -74,7 +74,7 @@ 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){		// 删除结点序号不正确
 		System.out.println("删除结点序号错误，不能删除结点!\n");
@@ -94,7 +94,7 @@ int SLDelete(SLType SL, int n){		// 按位删除顺序表的结点
 1）按照序号查找结点
 按照序号查找结点是顺序表查找结点最常用的方法，这是因为顺序表的存储本身就是一个数组。
 ```java
-DATA SLFindByNum(SLType SL, int n){	// 根据序号返回数据元素
+DATA SLFindByNum(SLType SL, int n){		// 根据序号返回数据元素
 
 	if(n<1 || n>SL.ListLen+1){
 		System.out.println("结点序号错误，不能返回结点!\n");
@@ -106,8 +106,8 @@ DATA SLFindByNum(SLType SL, int n){	// 根据序号返回数据元素
 2）按照关键字查找结点
 关键字可以是数据元素结构中的任意一项
 ```java
-int SLFindByKey(SLType SL, String key){		// 按关键字查询结点
-	for (int i = 1; i <= SL.ListLen; i++) {	// 搜寻整个顺序表，返回和key匹配的结点
+int SLFindByKey(SLType SL, String key){			// 按关键字查询结点
+	for (int i = 1; i <= SL.ListLen; i++) {		// 搜寻整个顺序表，返回和key匹配的结点
 		if(SL.ListData[i].key.compareTo(key)==0){
 			return i;
 		}
@@ -118,7 +118,7 @@ int SLFindByKey(SLType SL, String key){		// 按关键字查询结点
 ## 显示所有结点
 打印线性表中的所有数据元素
 ```java
-int SLALL(SLType SL){				// 显示顺序表中的所有结点
+int SLALL(SLType SL){		// 显示顺序表中的所有结点
 
 	for(int i=1; i<=SL.ListLen; i++){
 		System.out.printf("(%s,%s,%d)\n", SL.ListData[i].key, SL.ListData[i].name, SL.ListData[i].age);

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,9 +24,9 @@ class SQType{
 1. 按符号常量QUEUELEN指定的大小申请一片内存空间，用来保存队列中的数据。
 2. 设置head=0和tail=0，表示一个空栈。
 ```java
-SQType SQTypeInit(){										// 队列初始化
+SQType SQTypeInit(){				// 队列初始化
 	SQType q;
-	if((q=new SQType())!=null){								// 申请内存
+	if((q=new SQType())!=null){		// 申请内存
 		q.head = 0;											
 		q.tail = 0;
 		return q;
@@ -68,7 +68,7 @@ void SQTypeClear(SQType q){			// 清空队列
 ```
 ## 释放空间
 ```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
 	}
 }
 ```
@@ -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

@@ -12,8 +12,8 @@ class DATA{
  */
 class StackType{				
 	static final int MAXLEN = 50;
-	DATA[] data = new DATA[MAXLEN+1];		// 构建栈结构
-	int top;				// 栈顶
+	DATA[] data = new DATA[MAXLEN+1];	// 构建栈结构
+	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;					// 返回指向栈的引用
+	if((p=new StackType())!=null){		// 申请栈内存
+		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;
 }
 ```
@@ -89,15 +89,15 @@ DATA PopST(StackType s){				// 出栈
 		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);