数据结构(3) 第三天 栈的应用:就近匹配/中缀表达式转后缀表达式 、树/二叉树的概念、二叉树的递归与非递归遍历(DLR LDR LRD)、递归求叶子节点数目/二叉树高度/二叉树拷贝和释放
01 上节课回顾
受限的线性表
栈和队列的链式存储其实就是链表 但是不能任意操作 所以叫受限的线性表
02 栈的应用_就近匹配
案例1就近匹配:
#include <stdio.h> int main() { int a[4][4];int(*p)[4];p = a[0]; return 0;}
扫描字符串 如果碰到左括号 直接入栈
如果碰到右括号 从栈顶弹出括号,判断是否是左括号, 如果是 匹配成功
如果不是 匹配失败
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include "linkstack.h"
// 算法:就近匹配
// 定义结构体 (企业链表
// 结构体内保存了字符地址和index位置
typedef str4uct MYCHAR{
// 企业链表
LinkNode node;
// 保存字符地址
char * pAddress;
// index位置
int index;
} MyChar;
// 判断是否是左括号
int IsLeft(char c) {
return c == '(';
}
// 判断是否是右括号
int isRight(char c) {
return c == ')';
}
// 在堆上创建myChar结构体 将字符的地址和index传给myChar结构体
MyChar* CreatemyChar(char *p,int index) {
// 创建mychar结构体
MyChar * mychar = (MyChar *)malloc(sizeof(MyChar));
// 字符串p的地址传给pAddress
mychar->pAddress = p;
// index传给index
mychar->index = index;
// 返回mychar结构体
return mychar;
}
void ShowError(char * str, int pos)
{
// 公有两种错误: 1 左括号没有匹配的右括号 2 右括号没有匹配的左括号
printf("%s\n",str);
for (int i = 0; i < pos;i++) {
printf(" ");
}
// 用↑指向有问题的字符
printf("↑");
}
int main(void)
{
// 就近匹配案例
char * str = "1+2+6(dsf)dfsflp((sdfs)";
//char * str = "1212())))";
// 创建栈容器
LinkStack * stack = Init_LinkStack();
// p指向str 此时*p 就是str1
char * p = str;
// index初始化为0
int index = 0;
// 循环 如果没到结尾 就一直循环, *p代表第1个字符 如果没到\0, 没到字符串的结尾
while (*p != '\0') {
// 如果遇到左括号 左括号这个字符进栈 栈里只存放( 这一种括号
if (IsLeft(*p)) {
// 如果是左括号 就创建MYCHAR结构体并推入到栈内
Push_LinkStack(stack, (LinkNode *)CreatemyChar(p,index));
}
// 如果遇到右括号 从栈顶弹出元素 本次把和这个右括号对称的左括号弹出
if (isRight(*p)) {
// （（）
// 如果栈里面有内容
if (Size_LinkStack(stack) > 0) {
// 构造mychar结构体指向 栈顶元素
MyChar* mychar = (MyChar *)Top_LinkStack(stack);
// 如果是左括号
if (IsLeft(*(mychar->pAddress))) {
// 出栈
Pop_LinkStack(stack);
free(mychar);
}
}
else {
// 如果遇到了右括号 但是栈里没有内容 说明已经出错了
// 如果栈里没有内容 输出:右括号没有匹配的左括号
printf("右括号没有匹配的左括号\n");
// 显示错误信息
// 此时的index指向的是哪里?
ShowError(str, index);
break;
}
}
// 地址++
p++;
// index++
index++;
}
// 如果栈里有内容
while (Size_LinkStack(stack) > 0) {
// 构造mychar结构体指向栈顶元素
MyChar * mychar = (MyChar *)Top_LinkStack(stack);
printf(" 左括号没有匹配的右括号:\n");
ShowError(str, mychar->index);
// 出栈
Pop_LinkStack(stack);
free(mychar);
}
printf("\n");
system("pause");
return 0;
}
03 栈的应用_中缀表达式转后缀表达式
案例2:
int ret = a + b + c *(5/3)
char * ret = “a + b + c * (5/3)“
中缀转后缀表达式算法:
优先级顺序: x* > +- > ()
举例:
04 栈的应用_中缀表达式转后缀表达式实现1
05 栈的应用_中缀表达式转后缀表达式实现2
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include "linkstack.h"
// 中缀表达式 转 后缀表达式
// 判断是否是数字
int IsNumber(char c) {
return c >= '0' && c <= '9';
}
// 判断是不是左括号
int IsLeft(char c) {
return c == '(';
}
// 判断是不是右括号
int IsRight(char c) {
return c == ')';
}
// 判断是不是运算符号
int IsOperator(char c) {
return c == '+' || c == '-' || c == '*' || c == '/';
}
// 返回运算符号优先级
int GetPriority( char c) {
if (c == '*' || c == '/')
{
return 2;
}
if (c == '+' || c == '-') {
return 1;
}
// 什么都没有返回0
return 0;
}
// 定义Mychar结构体
// 包含一个小结点和 字符位置(企业链表
typedef struct MYCHAR {
LinkNode node;
char *p;
} Mychar;
// 创建MyChar
Mychar * CreateMyChar(char *p) {
// 在堆空间 开辟MyChar结构体大小
Mychar * mychar = (Mychar *)malloc(sizeof(Mychar));
// mychar的p 是p
mychar->p = p;
// 返回结构体
return mychar;
}
// 数字操作 遇到数字就输出
void NumberOperate(char * p) {
printf("%c", *p);
}
// 左括号的操作
void LeftOperate(LinkStack * stack,char *p) {
// 遇到左括号 把左括号推入到栈中
Push_LinkStack(stack, (LinkNode *)CreateMyChar(p));
}
// 右括号操作 遇到右括号 将栈顶元素弹出并输出 直至遇到左括号
void RightOperate(LinkStack * stack)
{
// 当栈中还有元素的时候 循环,
while (Size_LinkStack(stack) > 0) {
// 取到栈顶的元素
Mychar* mychar = (Mychar *)Top_LinkStack(stack);
// 如果是这个栈顶符号是左括号
if (IsLeft(*(mychar->p))) {
// 左括号出栈 (#不输出左括号
Pop_LinkStack(stack);
// break跳出循环
break;
}
// 输出字符
printf("%c", *(mychar->p));
// 弹出栈
Pop_LinkStack(stack);
// 释放内存
free(mychar);
}
}
// 运算符号的操作
void OperatorOperate(LinkStack *stack, char * p)
{
// 先取出栈顶符号
Mychar * mychar = (Mychar *)Top_LinkStack(stack);
// 如果栈顶是空的 就把运算符号压栈
if (mychar == NULL) {
Push_LinkStack(stack, (LinkNode *)CreateMyChar(p));
return;
}
// 如果栈顶优先级低当前字符的优先级 直接入栈 (栈里还可能没有元素
if (GetPriority(*(mychar->p)) > GetPriority(Top_LinkStack(p))) {
Push_LinkStack(stack, (LinkNode *)CreateMyChar(p));
return;
}
else {
// 如果栈顶优先级不低(大于等于当前字符优先级) 把栈顶符号弹出并输出 之后进栈
// 如果栈里有元素
while (Size_LinkStack(stack) > 0) {
// 取到栈顶元素
Mychar* mychar2 = (Mychar*)Top_LinkStack(stack);
// 如果栈顶元素优先级低于当前字符优先级 直接入栈 这个字符处理完成了 跳出循环
if (GetPriority(*(mychar2->p)) < GetPriority(*p)) {
// 入栈
Push_LinkStack(stack, (LinkNode*)CreateMyChar(p));
// 跳出循环
break;
}
// 输出 这个高优先级的字符
printf("%c",*(mychar2->p));
// 弹出栈元素
Pop_LinkStack(stack);
// 释放
free(mychar2);
}
}
}
int main(void)
{
// 中缀表达式
char *str = "8+(3-1)*5"; // 结果应该是8 3 1 - 5 * +
// 定义*p 指向str
char *p = str;
// 初始化栈容器
LinkStack * stack = Init_LinkStack();
// 没到结尾的时候 就一直遍历循环
while ( *p != '\0')
{
// 如果是数字
if (IsNumber(*p)) {
// 对数字进行操作(输出数字
NumberOperate(p);
}
// 如果左括号 直接进栈
if (IsLeft(*p)) {
// 对左括号进行操作 进栈
LeftOperate(stack,p);
}
// 如果右括号 将栈顶符号弹出 直到匹配到
if (IsRight(*p)) {
// 对右符号操作 将栈顶符号弹出
RightOperate(stack);
}
// 如果是运算符号
if (IsOperator(*p)) {
OperatorOperate(stack, p);
}
// p++
p++;
}
// 如果栈内还有元素 输出
while (Size_LinkStack(stack) > 0) {
Mychar * mychar = (Mychar *)Top_LinkStack(stack);
printf("%c", *(mychar->p));
Pop_LinkStack(stack);
free(mychar);
}
system("pause");
return 0;
}
06 栈的应用_后缀表达式求解
8 3 1 – 5 * +
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linkstack.h"
// 判断是否是数字
int IsNumber(char c)
{
return c >= '0' && c <= '9';
}
// 定义MyNum结构体
typedef struct MYNUM {
LinkNode node;
// int类型
int val;
} MyNum;
// 计算函数 传入 左操作数 右操作数 和 运算符号
int Calculate(int left, int right ,char c) {
int ret = 0;
switch (c)
{
case '+':
ret = left + right;
break;
case '-':
ret = left - right;
break;
case '*':
ret = left * right;
break;
case '/':
ret = left / right;
break;
default:
break;
}
// 计算并返回ret
return ret;
}
int main(void)
{
// 后缀表达式
char *str = "831-5*+";
char * p = str;
// 创建栈
LinkStack* stack = Init_LinkStack();
// 到字符结束前
while (*p != '\0') {
// 如果是数字 直接入栈
if (IsNumber(*p)) {
// 在堆空间分配MyNum大小结构体
MyNum * num = (MyNum *)malloc(sizeof(MyNum));
num->val = *p - '0'; //拿到数字
// 数字直接进栈
Push_LinkStack(stack, (LinkNode *)num);
}
else {
// 先从栈中弹出右操作数
MyNum * right = (MyNum *)Top_LinkStack(stack);
// 拿到rightNum
int rightNum = right->val;
// 出栈
Pop_LinkStack(stack);
free(right);
// 从栈中弹出左操作数
MyNum * left = (MyNum *)Top_LinkStack(stack);
// 拿到leftNum
int leftNum = left->val;
// 出栈
Pop_LinkStack(stack);
free(left);
// 结果进行计算拿到ret
int ret = Calculate(leftNum, rightNum, *p);
// 在堆空间创建num结构体
MyNum * num = (MyNum *)malloc(sizeof(MyNum));
// 赋值
num->val = ret;
// 将结果入栈
Push_LinkStack(stack, (LinkNode *)num);
}
p++;
}
// 如果运算完后容器内只有一个元素
if (Size_LinkStack(stack) == 1) {
// 拿到栈顶元素
MyNum * num = (MyNum *)Top_LinkStack(stack);
// 打印运算结果
printf("运算结果是:%d\n", num->val);
// 出栈
Pop_LinkStack(stack);
// 释放内存
free(num);
}
// 释放栈
FreeSpace_LinkStack(stack);
system("pause");
return 0;
}
07 树的基本概念
树和二叉树
线性表: 第一个数据只有一个后继 没有前驱，最后一个只有前驱 没有后继，其他都有前驱和后继，结点之间一对一的关系。
树里面包含树 递归性
08 树的存储
线性表: 顺序存储 链式存储
树:
双亲表示法
孩子表示法
(第二个元素是一个链表将这些孩子串起来)
左孩子右兄弟表示法
(转化成了一颗二叉树
09 二叉树的基本概念
满二叉树
Full Tree 满二叉树
Complete tree 完全二叉树
http://web.cecs.pdx.edu/~sheard/course/Cs163/Doc/FullvsComplete.html
09 二叉树的基本概念
10 二叉树先序遍历_中序遍历_后序遍历
we let L, D, R stand for moving left, process(print & proess) the data, and moving right
PRE-ORDER(DLR) Traversal 前序
IN-ORDER(LDR) Traversal 中序
POST_ORDER(LRD) Traversal 后序
拿中序遍历举例:
LDR:
LDR的意思就是先访问左节点 然后打印当前结点 最后访问右节点
从A开始 A开始访问左节点是B，
看B ，先访问B的左节点没有，打印当前结点 即B 访问B的右节点C
看C，先访问C的左节点，到D
看D 先访问D的左节点 没有 然后打印当前节点 即D
打印C 访问C的右节点E
。。。。
输出 BDCEA….
11 二叉树递归遍历
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 二叉树结点
typedef struct BINARYNODE {
char ch;
struct BINARYNODE * lchild;
struct BINARYNODE * rchild;
} BinaryNode;
void CreateBinaryTree() {
// 初始化结点
BinaryNode node1 = { 'A',NULL,NULL };
BinaryNode node2 = { 'B',NULL,NULL };
BinaryNode node3 = { 'C',NULL,NULL };
BinaryNode node4 = { 'D',NULL,NULL };
BinaryNode node5 = { 'E',NULL,NULL };
BinaryNode node6 = { 'F',NULL,NULL };
BinaryNode node7 = { 'G',NULL,NULL };
BinaryNode node8 = { 'H',NULL,NULL };
// 建立结点关系
node1.lchild = &node2;
node1.rchild = &node6;
node2.rchild = &node3;
node3.lchild = &node4;
node3.rchild = &node5;
node6.rchild = &node7;
node7.lchild = &node8;
// 递归遍历
Recursion(&node1);
printf("\n");
}
// 递归遍历
void Recursion(BinaryNode * root) {
// 递归一般都把退出条件放在最开始 如果遇到推出条件就不再执行了
if (root == NULL) {
return;
}
// 先访问根节点
printf("%c", root->ch);
// 再遍历左子树
Recursion(root->lchild);
// 再遍历右子树
Recursion(root->rchild);
}
int main(void) {
CreateBinaryTree();
printf("\n");
system("pause");
return 0;
}
BFS和DFS的概念:
上面讲的前序中序后序都是指深度优先遍历
以前遇到的一道面试题
对于二叉树:
?? 深度优先 使用栈 如果右边有就入栈
?? 广度优先
补:
LDR中序遍历:
//**
**//
补充: LRD后序遍历
(使用两个栈)
LRD
思路:
建立两个栈
第一个栈推入根节点
如果第一个栈元素数量大于0
{
从第一个栈中弹出元素 将元素推入第二个栈
如果这个元素有左结点 推入左结点到第一个栈
如果这个元素有右结点 推入右结点到第一个站
}
当第一个栈空以后将第二个栈中元素依次输出并打印
function postOrder(root)
{
let stack1,stack2
stack1.push(root)
while( stack1.size > 0 )
{
let tmpNode = stack1.pop()
stack2.push(tmpNode)
if(tmpNode>left) // left先入
stack1.push(tmpNode->left)
if(tmpNode->right)
stack1.push(tmpNode->right)
}
while( stack2.size > 0 ){
node = pop(stack2)
cout << node->data << " ";
}
}
前序中序后序都是属于深度优先遍历
广度优先遍历
12 二叉树编程实战_求叶子结点数目
叶子结点:
(度为0的结点称为叶子结点)
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 二叉树结点
typedef struct BINARYNODE {
char ch;
struct BINARYNODE * lchild;
struct BINARYNODE * rchild;
} BinaryNode;
int num = 0;
// 递归计算叶子结点
void CalculateLeafNum(BinaryNode * root){
// 设置递归退出条件
if (root == NULL) {
return;
}
// 左边也没有 右边也没有 就是叶子节点
if (root->lchild == NULL && root->rchild == NULL) {
num++;
}
// 左子树叶子结点的数目
CalculateLeafNum(root->lchild);
// 右子树叶子结点的数目
CalculateLeafNum(root->rchild);
}
void CreateBinaryTree() {
// 初始化结点
BinaryNode node1 = { 'A',NULL,NULL };
BinaryNode node2 = { 'B',NULL,NULL };
BinaryNode node3 = { 'C',NULL,NULL };
BinaryNode node4 = { 'D',NULL,NULL };
BinaryNode node5 = { 'E',NULL,NULL };
BinaryNode node6 = { 'F',NULL,NULL };
BinaryNode node7 = { 'G',NULL,NULL };
BinaryNode node8 = { 'H',NULL,NULL };
// 建立结点关系
node1.lchild = &node2;
node1.rchild = &node6;
node2.rchild = &node3;
node3.lchild = &node4;
node3.rchild = &node5;
node6.rchild = &node7;
node7.lchild = &node8;
CalculateLeafNum(&node1);
printf("叶子结点的数目:%d\n",num);
}
int main(void) {
CreateBinaryTree();
printf("\n");
system("pause");
return 0;
}
13 二叉树编程实战_求二叉树的高度
递归计算二叉树高度
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 二叉树结点
typedef struct BINARYNODE {
char ch;
struct BINARYNODE * lchild;
struct BINARYNODE * rchild;
} BinaryNode;
int num = 0;
// 递归计算树的高度
int CalculateHeight(BinaryNode *root) {
int height;
int leftHeight = 0;
int rightHeight = 0;
// 如果有左子树
if (root->lchild != NULL) {
// 就计算左子树高度
leftHeight = CalculateHeight(root->lchild);
}
// 如果有右子树
if (root->rchild != NULL) {
// 就计算右子树高度
rightHeight = CalculateHeight(root->rchild);
}
// 高度是左子树高度，右子树高度中最大的 然后+1
height = (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
// 返回高度
return height;
}
void CreateBinaryTree() {
// 初始化结点
BinaryNode node1 = { 'A',NULL,NULL };
BinaryNode node2 = { 'B',NULL,NULL };
BinaryNode node3 = { 'C',NULL,NULL };
BinaryNode node4 = { 'D',NULL,NULL };
BinaryNode node5 = { 'E',NULL,NULL };
BinaryNode node6 = { 'F',NULL,NULL };
BinaryNode node7 = { 'G',NULL,NULL };
BinaryNode node8 = { 'H',NULL,NULL };
// 建立结点关系
node1.lchild = &node2;
node1.rchild = &node6;
node2.rchild = &node3;
node3.lchild = &node4;
node3.rchild = &node5;
node6.rchild = &node7;
node7.lchild = &node8;
int num = CalculateHeight(&node1);
printf("二叉树的高度是:%d\n",num);
}
int main(void) {
CreateBinaryTree();
printf("\n");
system("pause");
return 0;
}
14 二叉树的拷贝和释放
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 二叉树结点
typedef struct BINARYNODE {
char ch;
struct BINARYNODE * lchild;
struct BINARYNODE * rchild;
} BinaryNode;
// 遍历二叉树
void Recursion(BinaryNode * root) {
if (root == NULL) {
return;
}
printf("%c", root->ch);
// 遍历左子树
Recursion(root->lchild);
// 遍历右子树
Recursion(root->rchild);
}
// 递归拷贝二叉树
BinaryNode * CopyBinaryTree(BinaryNode * root) {
if (root == NULL) {
return NULL;
}
// 拷贝左子树
BinaryNode * lchild = CopyBinaryTree(root->lchild);
// 拷贝右子树
BinaryNode * rchild = CopyBinaryTree(root->rchild);
// 创建结点
BinaryNode * newnode = (BinaryNode *)malloc(sizeof(BinaryNode));
newnode->ch = root->ch;
newnode->lchild = lchild;
newnode->rchild = rchild;
return newnode;
}
// 递归释放二叉树内存
void FreeSpaceBinaryTree(BinaryNode* root) {
if (root == NULL) {
return;
}
// 释放左子树
FreeSpaceBinaryTree(root->lchild);
// 释放右子树
FreeSpaceBinaryTree(root->rchild);
// 释放当前结点
free(root);
}
void CreateBinaryTree() {
// 初始化结点
BinaryNode node1 = { 'A',NULL,NULL };
BinaryNode node2 = { 'B',NULL,NULL };
BinaryNode node3 = { 'C',NULL,NULL };
BinaryNode node4 = { 'D',NULL,NULL };
BinaryNode node5 = { 'E',NULL,NULL };
BinaryNode node6 = { 'F',NULL,NULL };
BinaryNode node7 = { 'G',NULL,NULL };
BinaryNode node8 = { 'H',NULL,NULL };
// 建立结点关系
node1.lchild = &node2;
node1.rchild = &node6;
node2.rchild = &node3;
node3.lchild = &node4;
node3.rchild = &node5;
node6.rchild = &node7;
node7.lchild = &node8;
BinaryNode * root = CopyBinaryTree(&node1);
Recursion(root);
FreeSpaceBinaryTree(root);
}
int main(void) {
CreateBinaryTree();
printf("\n");
system("pause");
return 0;
}
数据结构(3) 第三天 栈的应用:就近匹配/中缀表达式转后缀表达式 、树/二叉树的概念、二叉树的递归与非递归遍历(DLR LDR LRD)、递归求叶子节点数目/二叉树高度/二叉树拷贝和释放的更多相关文章
- C语言- 基础数据结构和算法 - 09 栈的应用_中缀表达式转后缀表达式20220611
09 栈的应用_中缀表达式转后缀表达式20220611 听黑马程序员教程<基础数据结构和算法 (C版本)>, 照着老师所讲抄的, 视频地址https://www.bilibili.com/ ...
- Python与数据结构[1] -> 栈/Stack[1] -> 中缀表达式与后缀表达式的转换和计算
中缀表达式与后缀表达式的转换和计算 目录 中缀表达式转换为后缀表达式 后缀表达式的计算 1 中缀表达式转换为后缀表达式 中缀表达式转换为后缀表达式的实现方式为: 依次获取中缀表达式的元素, 若元素为操 ...
- 栈的简单应用之中缀表达式转后缀表达式(C语言实现逆波兰式)
一.前言 普通人在书写计算式时会选择中缀表达式,这样符合人脑的认知习惯.可计算机处理时后缀表达式才能使处理速度更快,其原因是利用堆栈结构减少计算机内存访问.同时它也是一个很好锻炼栈这个数据结构的应 ...
- 数据结构Java实现06----中缀表达式转换为后缀表达式
本文主要内容: 表达式的三种形式 中缀表达式与后缀表达式转换算法 一.表达式的三种形式: 中缀表达式:运算符放在两个运算对象中间,如:(2+1)*3.我们从小做数学题时,一直使用的就是中缀表达式. 后 ...
- C#数据结构与算法系列（十）：逆波兰计算器——逆波兰表达式（后缀表达式）
1.介绍 后缀表达式又称逆波兰表达式,与前缀表达式相似,只是运算符位于操作数之后 2.举例说明 (3+4)*5-6对应的后缀表达式就是3 4 +5 * 6 - 3.示例 输入一个逆波兰表达式(后缀表达 ...
- 中缀表达式转后缀表达式（用于求字符串表达式值）（js栈和队列的实现是通过数组的push和unshift方法插值，pop方法取值）
中缀表达式:就是我通常用的算术或逻辑公式: 后缀表达式:不包含括号,运算符放在两个运算对象后面,所有的计算按运算符出现的顺序,严格从左向右进行,不用考虑运算符优先级: 如,(2+1)*3 转换后,2 ...
- javascript使用栈结构将中缀表达式转换为后缀表达式并计算值
1.概念 你可能听说过表达式,a+b,a+b*c这些,但是前缀表达式,前缀记法,中缀表达式,波兰式,后缀表达式,后缀记法,逆波兰式这些都是也是表达式. a+b,a+b*c这些看上去比较正常的是中缀表达 ...
- C#数据结构与算法系列（十）：中缀表达式转后缀表达式
1.具体步骤 1)初始化两个栈:运算符栈s1和储存中间结果的栈s2:2)从左至右扫描中缀表达式:3)遇到操作数时,将其压s2:4)遇到运算符时,比较其与s1栈顶运算符的优先级: (1)如果s1 ...
- 栈的应用实例——中缀表达式转换为后缀表达式
声明:本程序读入一个中缀表达式,将该中缀表达式转换为后缀表达式并输出后缀表达式. 注意:支持+.-.*./.(),并且输入时每输入完一个数字或符号都要加一个空格,特别注意的是在整个表达式输入完成时也要 ...
随机推荐
- 关于 图论·并查集·HDU1232&1856
其核心是追溯其根数和链接两个数,而HDU 1856要多一步,每一个根数要标记自己和自己子数的个数,因此用结构体.注意:1856 用C写没超时,用C++写超时了╮(╯﹏╰)╭ 接下来是题目和代码: 畅通 ...
- 洛谷 P1198 BZOJ 1012 [JSOI2008]最大数
题目描述 有一棵点数为 N 的树,以点 1 为根,且树点有边权.然后有 M 个操作,分为三种:操作 1 :把某个节点 x 的点权增加 a .操作 2 :把某个节点 x 为根的子树中所有点的点权都增加 ...
- 0622 CentOS 6.4下编译安装MySQL 5.6.14
转自http://www.cnblogs.com/xiongpq/p/3384681.html 概述: CentOS 6.4下通过yum安装的MySQL是5.1版的,比较老,所以就想通过源代码安装高版 ...
- 手动重启weblogic脚本
手动重启weblogic脚本 pid=`ps -ef|grep fzjc_Admin_Server|grep -v grep|awk '{print $2}'` echo $pid kill -9 $ ...
- [Cypress] Find and Test Focused Input with Chrome’s DevTools in Cypress
In this lesson, we’ll add tests that finds a focused input. We’ll use Chrome’s dev tools from inside ...
- 数据结构（三）——栈Stack
栈是一种特殊的线性表,插入和删除操作均在栈顶进行,插入操作称为入栈,删除操作称为出栈. 一.顺序栈 利用顺序存储方式实现的栈称为顺序栈,下面是它的一些基本操作实现算法,需要理解和记忆. 1.顺序栈的类 ...
- hdu4849 Wow! Such City!(最短路dijkstra)
转载请注明出处:http://blog.csdn.net/u012860063? viewmode=contents 题目链接:pid=4849">http://acm.hdu.edu ...
- Python环境设置-zlib not available
今天在Linux中安Python3的时候,出现了一个错误:zipimport.ZipImportError: can‘t decompress data; zlib not available 网上找 ...
- Chrome 行情抓取插件
Chrome 行情抓取插件 上班想偷偷摸摸看行情?自己动手写插件啊,尝试写了一个,新建文件夹,命名为StockMonitor,放入文件如下: 3个.png图标文件,19X19.48X48.128X12 ...
- POJ 1416 DFS
题目翻译: 公司现在要发明一种新的碎纸机,要求新的碎纸机能够把纸条上的数字切成最接近而不超过target值.比如,target的值是50,而纸条上的数字是12346,应该把数字切成四部分,分别是1.2 ...