数据结构(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 ...
- 栈的应用实例——中缀表达式转换为后缀表达式
声明:本程序读入一个中缀表达式,将该中缀表达式转换为后缀表达式并输出后缀表达式. 注意:支持+.-.*./.(),并且输入时每输入完一个数字或符号都要加一个空格,特别注意的是在整个表达式输入完成时也要 ...
随机推荐
- 导致“mysql has gone away”的两种情况
导致“mysql has gone away”的两种情况 By Cruise 1. wait_timeout参数 在开发代理server时, 我使用了jdbc连接数据库,并采用长连接的方式连接数据库 ...
- swift 笔记 (十四) —— 构造过程
构造过程 为了生成类.结构体.枚举等的实例,而做的准备过程,叫做构造过程. 为了这个过程,我们一般会定义一个方法来完毕,这种方法叫做构造器.当然它的逆过程,叫做析构器,用于在实例被释放前做一些清理工作 ...
- 【FastDev4Android框架开发】打造QQ6.X最新版本号側滑界面效果(三十八)
转载请标明出处: http://blog.csdn.net/developer_jiangqq/article/details/50253925 本文出自:[江清清的博客] (一).前言: [好消息] ...
- Linux 强行终止
kill -9 pid pid是进程号 -9 代表的是数字 INT 2 这个就是你在bash下面用Ctrl+C 来结束一个程序时,bash会向进程发送这个信号,默认的,进程收到这个程序会结束. 你可以 ...
- BZOJ 4517: [Sdoi2016]排列计数 错排+逆元
4517: [Sdoi2016]排列计数 Description 求有多少种长度为 n 的序列 A,满足以下条件: 1 ~ n 这 n 个数在序列中各出现了一次 若第 i 个数 A[i] 的值为 i, ...
- 分享3个Putty配色方案【转】
本文转载自:https://www.coder4.com/archives/1506 分享3个Putty配色方案 4 Replies 虽然服务器都是Linux的,平时也基本用Linux,但是难免还是要 ...
- Android系统之Recovery移植教程 【转】
本文转载自:http://luckytcl.blog.163.com/blog/static/14258648320130165626644/ recovery的移植,这方面的资料真实少之又少啊,谷歌 ...
- Linux - 环境变量与位置变量
环境变量 [root@local ~]# echo $PATH /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin 注:只有自己执行 ...
- AdaBoostClassifier实战
AdaBoostClassifier实战 部分内容摘自:http://blog.csdn.net/sun_shengyun/article/details/54289955 这里我们用一个具体的例子来 ...
- Spring MVC简介 2.5 Spring MVC执行的流程
package org.fkit.controller; import javax.servlet.http.HttpServletRequest; import javax.servlet.http ...