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);