Java数据结构与算法_03 栈 （小型计算器、逆波兰表达式）

秒速五厘米 2023-07-09 02:03 66阅读 0赞

Java数据结构与算法_03

  • 栈
    • 数组模拟栈
      • 完整代码
    • 应用场景1：小型计算器（使用栈计算表达式）
      • 完整代码
    • 应用场景2：前缀、中缀、后缀表达式(逆波兰表达式)
      • 前缀表达式
      • 中缀表达式
      • 后缀表达式
      • 具体任务要求
      • 完整代码

本人是个新手，写下博客用于自我复习、自我总结。
如有错误之处，请各位大佬指出。
学习资料来源于：尚硅谷

栈

（1）栈的英文为(stack)
（2）栈是一个先入后出(FILO-First In Last Out)的有序列表。
（3）栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
（4）根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶。删除元素时，最后放入的元素最先删除，最先放入的元素最后删除。
（5）入栈（push）和出栈（pop）的概念：
在这里插入图片描述
在这里插入图片描述

数组模拟栈

在这里插入图片描述
实现栈的思路分析：
1.定义一个 top 来表示栈顶，初始化 为 -1
2.入栈的操作，当有数据加入到栈时， top++; stack[top] = data;
3.出栈的操作， int value = stack[top]; top–, return value

完整代码

  1. import java.util.Scanner;
  3. public class ArrayStackDemo { 
  5.     public static void main(String[] args) { 
  6.         //先创建一个ArrayStack对象->表示栈
  7.         ArrayStack stack = new ArrayStack(4);
  8.         String key = "";
  9.         boolean loop = true; //控制是否退出菜单
  10.         Scanner scanner = new Scanner(System.in);
  12.         while(loop) { 
  13.             System.out.println("show: 表示显示栈");
  14.             System.out.println("exit: 退出程序");
  15.             System.out.println("push: 表示添加数据到栈(入栈)");
  16.             System.out.println("pop: 表示从栈取出数据(出栈)");
  17.             System.out.println("请输入你的选择");
  18.             key = scanner.next();
  19.             switch (key) { 
  20.             case "show":
  21.                 stack.list();
  22.                 break;
  23.             case "push":
  24.                 System.out.println("请输入一个数");
  25.                 int value = scanner.nextInt();
  26.                 stack.push(value);
  27.                 break;
  28.             case "pop":
  29.                 try { 
  30.                     int res = stack.pop();
  31.                     System.out.printf("出栈的数据是 %d\n", res);
  32.                 } catch (Exception e) { 
  33.                     // TODO: handle exception
  34.                     System.out.println(e.getMessage());
  35.                 }
  36.                 break;
  37.             case "exit":
  38.                 scanner.close();
  39.                 loop = false;
  40.                 break;
  41.             default:
  42.                 break;
  43.             }
  44.         }
  46.         System.out.println("程序退出。");
  47.     }
  49. }
  51. //定义一个 ArrayStack 表示栈
  52. class ArrayStack { 
  53.     private int maxSize;  // 栈的大小
  54.     private int[] stack;  // 数组模拟栈，数据就放在该数组
  55.     private int top = -1; // top表示栈顶，初始化为-1
  57.     //构造器
  58.     public ArrayStack(int maxSize) { 
  59.         this.maxSize = maxSize;
  60.         stack = new int[this.maxSize];
  61.     }
  63.     //栈满
  64.     public boolean isFull() { 
  65.         return top == maxSize - 1;
  66.     }
  67.     //栈空
  68.     public boolean isEmpty() { 
  69.         return top == -1;
  70.     }
  71.     //入栈：push
  72.     public void push(int value) { 
  73.         //先判断栈是否满
  74.         if(isFull()) { 
  75.             System.out.println("栈满");
  76.             return;
  77.         }
  78.         top++;
  79.         stack[top] = value;
  80.     }
  81.     //出栈：pop, 将栈顶的数据返回
  82.     public int pop() { 
  83.         //先判断栈是否空
  84.         if(isEmpty()) { 
  85.             //抛出异常
  86.             throw new RuntimeException("栈空，没有数据。");
  87.         }
  88.         int value = stack[top];
  89.         top--;
  90.         return value;
  91.     }
  92.     //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
  93.     public void list() { 
  94.         if(isEmpty()) { 
  95.             System.out.println("栈空，没有数据~~");
  96.             return;
  97.         }
  98.         //需要从栈顶开始显示数据
  99.         for(int i = top; i >= 0 ; i--) { 
  100.             System.out.printf("stack[%d]=%d\n", i, stack[i]);
  101.         }
  102.     }
  104. }

应用场景1：小型计算器（使用栈计算表达式）

在这里插入图片描述
问题：计算如上这种只有 乘法、除法、加法、减法 的，很简单的表达式。只允许用栈的方式。

分析：

1.首先，存储表达式的栈应该有两个。如果只用一个栈来存储表达式，那么可想而知的是，会出现很多的麻烦，因为需要判断哪个是数字，哪个是计算符号，同时还要判断计算的优先级。现在使用两个栈来完成操作，一个栈是数栈，另一个栈是符号栈，分别存放数字和运算符。

2.通过一个 index 值（索引），遍历输入的表达式。

如果我们发现是一个数字，需要注意：因为这个表达式只能是String类型，所以遍历表达式的时候，可能会出现多位数的情况，所以还需要能够拼接多位数。也就是说我们如果判断出这是一个数字，还要让index多探索几位，直到发现下一位是符号。然后将得到的中间这几个“数”，拼接起来，然后入数栈；

如果发现是一个符号, 就分如下情况：
2.1 如果发现当前的符号栈为 空，就直接入栈
2.2 如果符号栈有操作符，就进行比较。
如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数，在从符号栈中pop出一个符号，进行运算，将得到的结果入数栈，然后将当前的操作符入符号栈；
如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈。

3.当表达式扫描完毕，按顺序的从 数栈 和 符号栈 中pop出相应的数和符号，并运行。

4.最后在数栈只有一个数字，它就是表达式的结果。

5.关于判断优先级：优先级是程序员来确定的，优先级在以下代码里使用数字表示，当然可以自己设计一些其他的判断优先级方式。当然，实际上想计算表达式直接让计算机去计算就可以了，这里只是用栈的方式来体现一下原理，没有太多实际上的帮助。当然也可以计算一些更复杂的表达式，需要更改的只有判断优先级，这对理解栈没有任何帮助，所以也不需要思索更复杂的表达式。

6.计算时，需要注意减法和除法。因为栈的特性是先入后出，所以对于表达式，一定是后取出的数减去（或除）先取出的数。

完整代码

  1. public class Calculator { 
  3.     public static void main(String[] args) { 
  4.         //设定表达式
  5.         String expression = "7*2*2-5+1-5+3-4"; 
  6.         //创建两个栈，数栈，一个符号栈
  7.         ArrayStack2 numStack = new ArrayStack2(10);
  8.         ArrayStack2 operStack = new ArrayStack2(10);
  9.         //定义需要的相关变量
  10.         int index = 0; //用于扫描
  11.         int num1 = 0; 
  12.         int num2 = 0;
  13.         int oper = 0;
  14.         int res = 0;
  15.         char ch = ' '; //将每次扫描得到char保存到ch
  16.         String keepNum = ""; //用于拼接 多位数
  17.         //开始while循环的扫描expression
  18.         while(true) { 
  19.             //依次得到expression 的每一个字符
  20.             ch = expression.substring(index, index+1).charAt(0);
  21.             //判断ch是什么，然后做相应的处理
  22.             if(operStack.isOper(ch)) { //如果是运算符
  23.                 //判断当前的符号栈是否为空
  24.                 if(!operStack.isEmpty()) { 
  25.                     //如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
  26.                     //再从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
  27.                     if(operStack.priority(ch) <= operStack.priority(operStack.peek())) { 
  28.                         num1 = numStack.pop();
  29.                         num2 = numStack.pop();
  30.                         oper = operStack.pop();
  31.                         res = numStack.cal(num1, num2, oper);
  32.                         //把运算的结果如数栈
  33.                         numStack.push(res);
  34.                         //然后将当前的操作符入符号栈
  35.                         operStack.push(ch);
  36.                     } else { 
  37.                         //如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
  38.                         operStack.push(ch);
  39.                     }
  40.                 }else { 
  41.                     //如果为空直接入符号栈
  42.                     operStack.push(ch); 
  43.                 }
  44.             } else {  //如果是数
  45.                 //分析：
  46.                 //1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
  47.                 //2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
  48.                 //3. 因此我们需要定义一个变量 字符串，用于拼接
  49.                 //处理多位数
  50.                 keepNum += ch;
  52.                 //如果ch已经是expression的最后一位，就直接入栈
  53.                 if (index == expression.length() - 1) { 
  54.                     numStack.push(Integer.parseInt(keepNum));
  55.                 }else{ 
  56.                     //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
  57.                     if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))) { 
  58.                         //如果后一位是运算符，则入栈 
  59.                         numStack.push(Integer.parseInt(keepNum));
  60.                         //重要的!!!!!!, keepNum清空
  61.                         keepNum = "";
  62.                     }
  63.                 }
  64.             }
  65.             //让index + 1, 并判断是否扫描到expression最后.
  66.             index++;
  67.             if (index >= expression.length()) { 
  68.                 break;
  69.             }
  70.         }
  72.         //当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
  73.         while(true) { 
  74.             //如果符号栈为空，则计算到最后的结果, 数栈中只有一个数字【结果】
  75.             if(operStack.isEmpty()) { 
  76.                 break;
  77.             }
  78.             num1 = numStack.pop();
  79.             num2 = numStack.pop();
  80.             oper = operStack.pop();
  81.             res = numStack.cal(num1, num2, oper);
  82.             numStack.push(res);//入栈
  83.         }
  84.         //将数栈的最后数，pop出，就是结果
  85.         int res2 = numStack.pop();
  86.         System.out.printf("表达式 %s = %d", expression, res2);
  87.     }
  89. }
  91. //定义一个 ArrayStack2栈
  92. class ArrayStack2 { 
  93.     private int maxSize;  // 栈的大小
  94.     private int[] stack;  // 数组模拟栈，数据就放在该数组
  95.     private int top = -1; // top表示栈顶，初始化为-1
  97.     //构造器
  98.     public ArrayStack2(int maxSize) { 
  99.         this.maxSize = maxSize;
  100.         stack = new int[this.maxSize];
  101.     }
  103.     //增加一个方法，可以返回当前栈顶的值, 但它不是真正的pop
  104.     public int peek() { 
  105.         return stack[top];
  106.     }
  108.     //栈满
  109.     public boolean isFull() { 
  110.         return top == maxSize - 1;
  111.     }
  112.     //栈空
  113.     public boolean isEmpty() { 
  114.         return top == -1;
  115.     }
  117.     //入栈：push
  118.     public void push(int value) { 
  119.         //先判断栈是否满
  120.         if(isFull()) { 
  121.             System.out.println("栈满");
  122.             return;
  123.         }
  124.         top++;
  125.         stack[top] = value;
  126.     }
  127.     //出栈：pop, 将栈顶的数据返回
  128.     public int pop() { 
  129.         //先判断栈是否空
  130.         if(isEmpty()) { 
  131.             //抛出异常
  132.             throw new RuntimeException("栈空，没有数据~");
  133.         }
  134.         int value = stack[top];
  135.         top--;
  136.         return value;
  137.     }
  138.     //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
  139.     public void list() { 
  140.         if(isEmpty()) { 
  141.             System.out.println("栈空，没有数据~~");
  142.             return;
  143.         }
  144.         //需要从栈顶开始显示数据
  145.         for(int i = top; i >= 0 ; i--) { 
  146.             System.out.printf("stack[%d]=%d\n", i, stack[i]);
  147.         }
  148.     }
  149.     //返回运算符的优先级，优先级是程序员来确定的, 优先级使用数字表示
  150.     //数字越大，则优先级就越高.
  151.     public int priority(int oper) { 
  152.         if(oper == '*' || oper == '/'){ 
  153.             return 1;
  154.         } else if (oper == '+' || oper == '-') { 
  155.             return 0;
  156.         } else { 
  157.             return -1; 
  158.         }
  159.     }
  160.     //判断是不是一个运算符
  161.     public boolean isOper(char val) { 
  162.         return val == '+' || val == '-' || val == '*' || val == '/';
  163.     }
  164.     //计算方法
  165.     //注意计算顺序
  166.     public int cal(int num1, int num2, int oper) { 
  167.         int res = 0; // res 用于存放计算的结果
  168.         switch (oper) { 
  169.         case '+':
  170.             res = num1 + num2;
  171.             break;
  172.         case '-':
  173.             res = num2 - num1;
  174.             break;
  175.         case '*':
  176.             res = num1 * num2;
  177.             break;
  178.         case '/':
  179.             res = num2 / num1;
  180.             break;
  181.         default:
  182.             break;
  183.         }
  184.         return res;
  185.     }
  186. }

应用场景2：前缀、中缀、后缀表达式(逆波兰表达式)

前缀表达式

在这里插入图片描述
前缀表达式的计算机求值

从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。

例如： (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达式求值步骤如下：

（1）从右至左扫描，将6、5、4、3压入堆栈；
（2）遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7入栈；
（3）接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈；
（4）最后是-运算符，计算出35-6的值，即29，由此得出最终结果；

中缀表达式

在这里插入图片描述

后缀表达式

在这里插入图片描述
后缀表达式的计算机求值

从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。

例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下：

（1）从左至右扫描，将3和4压入堆栈；
（2）遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
（3）将5入栈；
（4）接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
（5）将6入栈；
（7）最后是-运算符，计算出35-6的值，即29，由此得出最终结果

具体任务要求

完成一个逆波兰计算器，要求完成如下任务:

（1）输入一个逆波兰表达式(后缀表达式)，使用栈(Stack)，计算其结果。
（2）支持小括号和多位数整数。和应用场景一里的说明一样，只支持对整数的计算即可，只是体验栈的用法，没必要计算一些太过于复杂的。

除此以外，用前缀表达式也可以，毕竟一个是运算符在前，一个是运算符在后，只不过通常是使用后缀表达式。后缀表达式适合计算机进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下。因此在开发中，我们需要将 中缀表达式转成后缀表达式。

具体分析如下：

(1)初始化两个栈：运算符栈s1和储存中间结果的栈s2；

(2)从左至右扫描中缀表达式；

(3)遇到操作数时，将其压入s2；

(4)遇到运算符时，比较其与s1栈顶运算符的优先级：
1.如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
2.否则，若优先级比栈顶运算符的高，就将运算符压入s1；若优先级和栈顶运算符的相等或低，则将s1栈顶的运算符弹出并压入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较；

(5)遇到括号时：
① 如果是左括号“(”，则直接压入s1
② 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃。

(6)重复步骤2至5，直到表达式的最右边

(7)将s1中剩余的运算符依次弹出并压入s2

(8)依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

(9)最后利用上面后缀表达式的计算机求值步骤计算得到结果即可。

比如：
在这里插入图片描述在这里插入图片描述

完整代码

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Stack;
  5. public class PolandNotation { 
  7.     public static void main(String[] args) { 
  9.         //完成将一个中缀表达式转成后缀表达式的功能
  10.         //说明
  11.         //1. 1+((2+3)×4)-5 => 转成 1 2 3 + 4 × + 5 –
  12.         //2. 因为直接对str 进行操作，不方便，因此 先将 "1+((2+3)×4)-5" =》 中缀的表达式对应的List
  13.         // 即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
  14.         //3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
  15.         // 即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
  17.         String expression = "1+((2+3)*4)-5";
  18.         List<String> infixExpressionList = toInfixExpressionList(expression);
  19.         System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
  20.         List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
  21.         System.out.println("后缀表达式对应的List" + suffixExpreesionList); //ArrayList [1,2,3,+,4,*,+,5,–] 
  23.         System.out.printf("expression=%d", calculate(suffixExpreesionList)); 
  24.     }
  26.     //即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
  27.     //方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
  28.     public static List<String> parseSuffixExpreesionList(List<String> ls) { 
  29.         //定义两个栈
  30.         Stack<String> s1 = new Stack<String>(); // 符号栈
  31.         //说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
  32.         //因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
  33.         List<String> s2 = new ArrayList<String>(); // 储存中间结果的Lists2
  35.         //遍历ls
  36.         for(String item: ls) { 
  37.             //如果是一个数，加入s2
  38.             if(item.matches("\\d+")) { 
  39.                 s2.add(item);
  40.             } else if (item.equals("(")) { 
  41.                 s1.push(item);
  42.             } else if (item.equals(")")) { 
  43.                 //如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止
  44.                 while(!s1.peek().equals("(")) { 
  45.                     s2.add(s1.pop());
  46.                 }
  47.                 s1.pop();//将 ( 弹出 s1栈， 消除小括号
  48.             } else { 
  49.                 //当item的优先级小于等于s1栈顶运算符, 将s1栈顶的运算符弹出并加入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较
  50.                 while(s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item) ) { 
  51.                     s2.add(s1.pop());
  52.                 }
  53.                 //还需要将item压入栈
  54.                 s1.push(item);
  55.             }
  56.         }
  58.         //将s1中剩余的运算符依次弹出并加入s2
  59.         while(s1.size() != 0) { 
  60.             s2.add(s1.pop());
  61.         }
  63.         return s2; //因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
  65.     }
  67.     // 方法：将 中缀表达式转成对应的List
  68.     // s="1+((2+3)×4)-5";
  69.     public static List<String> toInfixExpressionList(String s) { 
  70.         //定义一个List,存放中缀表达式 对应的内容
  71.         List<String> ls = new ArrayList<String>();
  72.         int i = 0;   //这是一个指针，用于遍历 中缀表达式字符串
  73.         String str;  //对多位数的拼接
  74.         char c;      //每遍历到一个字符，就放入到c
  75.         do { 
  76.             //如果c是一个非数字，就加入到ls
  77.             //'0'[48]->'9'[57]
  78.             if((c=s.charAt(i)) < 48 ||  (c=s.charAt(i)) > 57) { 
  79.                 ls.add("" + c);
  80.                 i++; //i需要后移
  81.             } else {  //如果是一个数，需要考虑多位数
  82.                 str = ""; //先将str 置成"" 
  83.                 while(i < s.length() && (c=s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57) { 
  84.                     str += c;//拼接
  85.                     i++;
  86.                 }
  87.                 ls.add(str);
  88.             }
  89.         }while(i < s.length());
  90.         return ls;//返回
  91.     }
  93.     //完成对逆波兰表达式的运算 
  94.     public static int calculate(List<String> ls) { 
  95.         // 创建一个栈即可
  96.         Stack<String> stack = new Stack<String>();
  97.         // 遍历 ls
  98.         for (String item : ls) { 
  99.             // 这里使用正则表达式来取出数
  100.             if (item.matches("\\d+")) {  // 匹配的是多位数
  101.                 // 入栈
  102.                 stack.push(item);
  103.             } else { 
  104.                 // pop出两个数，并运算， 再入栈
  105.                 int num2 = Integer.parseInt(stack.pop());
  106.                 int num1 = Integer.parseInt(stack.pop());
  107.                 int res = 0;
  108.                 if (item.equals("+")) { 
  109.                     res = num1 + num2;
  110.                 } else if (item.equals("-")) { 
  111.                     res = num1 - num2;
  112.                 } else if (item.equals("*")) { 
  113.                     res = num1 * num2;
  114.                 } else if (item.equals("/")) { 
  115.                     res = num1 / num2;
  116.                 } else { 
  117.                     throw new RuntimeException("运算符有误");
  118.                 }
  119.                 //把res 入栈
  120.                 stack.push("" + res);
  121.             }
  123.         }
  124.         //最后留在stack中的数据是运算结果
  125.         return Integer.parseInt(stack.pop());
  126.     }
  128. }
  130. //编写一个类 Operation 可以返回一个运算符 对应的优先级
  131. class Operation { 
  132.     private static int ADD = 1;
  133.     private static int SUB = 1;
  134.     private static int MUL = 2;
  135.     private static int DIV = 2;
  137.     //写一个方法，返回对应的优先级数字
  138.     public static int getValue(String operation) { 
  139.         int result = 0;
  140.         switch (operation) { 
  141.         case "+":
  142.             result = ADD;
  143.             break;
  144.         case "-":
  145.             result = SUB;
  146.             break;
  147.         case "*":
  148.             result = MUL;
  149.             break;
  150.         case "/":
  151.             result = DIV;
  152.             break;
  153.         case "(":
  154.             break;
  155.         case ")":
  156.             break;
  157.         default:
  158.             System.out.println("不存在该运算符" + operation);
  159.             break;
  160.         }
  161.         return result;
  162.     }
  164. }

发表评论

表情：
评论列表 （有 0 条评论，66人围观）

还没有评论，来说两句吧...

相关阅读