Fran OvO

期末复习笔记——树和二叉树

一、树

1，树型结构

树型结构是一种非线性结构，与之前的线性表，栈，队列还有字符串，数组，广义表不同。相比与之前一对一的线性结构，树型结构展示为一对多的非线性结构。

2，树的定义，术语，森林

太多了，不打了。。。直接二叉树

二、二叉树

二叉树，这个树比较重要，结构简单，规律性强，普通树也可以通过转化为二叉树进行运算，简化步骤。其中运用二叉树的算法也有很多，像最优二叉树哈夫曼树，树状数组，线段树等等，都是在二叉树上进行操作。

1.几个性质

1，一个节点最多只用有两个孩子，所以在二叉树的第i层上至多有 $2^{i-1}$ 个结点

2，深度为k的二叉树至多有 $2^{k}-1$ 个结点

3，对于任何一棵二叉树T,如果其叶子树为 $n{_0}$ ，度为2的结点数为 $n{_2}$ ，则 $n{_0}=n{_2}+1$

咋算的

总边数：

1，每个孩子和双亲都有一条连线，只有根没有双亲，所以n个节点对于有条边。

2，再者总边数还可以为度为2结点的边和度为1节点的边的和

所以 $n-1=n{_2}*2+n{_1}*1$ ，又因为节点数等于度为2，度为1，度为0的 $n=n{_0}+n{_1}+n{_2}$ 带入就为 $n{_0}=n{_2}+1$ 。

4，具有n个结点的完全二叉树的深度为 $log _{2}{}^{n}+1$

1，满二叉树：深度为k，且结点数为 $2^{k}-1$ 的二叉树

2，完全二叉树：

我们可以联想到到在排序那章讲的堆排序，堆就是一个完全二叉树，堆中的某个结点的值总是大于等于（最大堆）或小于等于（最小堆）其孩子结点的值,第 k 层所有的结点都连续集中在最左边。

所以二叉树的深度为k，除第 k 层外，其它各层 (1～k-1) 的结点数都达到最大个数，

第 k 层所有的结点都连续集中在最左边,且其中每一个结点都能与满二叉树匹配的二叉树.

2，二叉树的存储结构

学习了前面的队列，栈，串等，思考存储结构可以想到两个方面：顺序存储，链式存储

1，顺序存储

#define MAXTSIZE 100
typedef char SqbiTree[MAXTSIZE];
SqbiTree bt;

1	2	3	4	5	6	7	8	9	10	11	12
a	e	b	f		d	c	g				h

空的结点算上，12个结点， $log{_2}{ }^{12}+1$ 有四层

先画出满二叉树，再填上去

2，链式存储

重点还是看链式存储。。。

typedef struct BiNode {
	char data;
	struct BiNode* lchild, * rchild;
}Binode,*BiTree;

还可以利用双向链表改写二叉链表的指针域为三叉链表，使其可以询问结点的双亲结点

typedef struct BiNode {
	char data;
	struct BiNode* lchild, * rchild;
	struct BiNode* parent;
}Binode,*BiTree;

3，遍历二叉树

1，遍历二叉树的方法有六种

根左右，左根右，左右根，根右左，右根左，右左根

后三个和前三个对称，所以只研究前三个

根左右	先序（根）遍历
左根右	中序（根）遍历
左右根	后序（根）遍历

思考：栈和队列的前缀表达式，中缀表达式，后缀表达式，应该是由二叉树的三种遍历方式展现出来的

可以看出上次使用入栈操作也可以得到三种表达式的结果，猜测三种遍历方式也可以使用栈进行实现。

1.1先根遍历：访问根结点——>左子树——>右子树

递归实现：

void Preordertravers(BiTree T) {
	if (T == NULL)return ;
	else {
		cout << T->data;
		Preordertravers(T->lchild);
		Preordertravers(T->rchild);
	}
}

栈实现：思路和递归一致，先将根压入栈，然后左子树一并压入栈直到空为止开始弹栈，取栈顶结点判断右子树是否存在，如果存在继续压入左子树操作。

void PrevOrder_stack(Binode* T)
{
	stack s;
	Binode*  Bi = T;
	while (Bi || !s.empty())
	{
		if(Bi)
		{
			cout << Bi->data;
			s.push(Bi);
			Bi = Bi->lchild;
		}
		else {
			Bi = s.top();
			s.pop();
			Bi = Bi->rchild;
		}
	}
	cout << "先序遍历_栈" << endl;
}

1.2中根遍历：访问左子树——>根结点——>右子树

void Inordertraverse(BiTree T) {
	if (T == NULL)return;
	else {
	
		Inordertraverse(T->lchild);
		cout << T->data;
		Inordertraverse(T->rchild);
	}
}

栈实现：和先序差不多，左子树压入栈直到叶子开始弹栈并输出，然后再将右子树压入栈中

void InOrder_stack(Binode* T)
{
	stack s;

	Binode* Bi = T;

	while (Bi || !s.empty())
	{
		if (Bi)
		{
			s.push(Bi);
			Bi = Bi->lchild;
		}
		else {
			Bi = s.top();
			cout << Bi->data;
			s.pop();
			Bi = Bi->rchild;
		}
	}
	cout << "中序遍历_栈" << endl;
}

1.3后根遍历：访问左子树——>右子树——>根结点

void Postordertraverse(BiTree T) {
	if (T == NULL)return;
	else {

		Postordertraverse(T->lchild);
		Postordertraverse(T->rchild);
		cout << T->data;
	}
}

栈实现：也是先把左子树压入栈直到空，然后判断是否存在右子树，如果有用vis记录该结点，然后开始重复上述操作，继续将右子树中的左子树压入栈，直到为叶子结点

void PastOrder_stack(Binode* T)
{
	Binode* Bi = T;
	Binode* vis = NULL;
	stack s;
	while (Bi||!s.empty())
	{
		if (Bi)
		{
			s.push(Bi);
			Bi = Bi->lchild;
		}
		else {
			Bi = s.top();
			if (Bi->rchild && vis != Bi->rchild)
				Bi = Bi->rchild;
			else if (( Bi->rchild==NULL) || (vis == Bi->rchild))
			{
				cout << Bi->data;
				vis = Bi;
				s.pop();
				Bi = NULL;
			}
		}
	}
	cout << "后序遍历_栈" << endl;
}

1.4层次遍历：

从上到下，从左到右

void HierarchyOrder(Binode * T)
{
	queueq;
	q.push(T);
	Binode* temp;
	while (!q.empty()) {
		temp = q.front();
		q.pop();
		cout << temp->data;
		if (temp->lchild != NULL) {
			q.push(temp->lchild);
		}
		if (temp->rchild != NULL) {
			q.push(temp->rchild);
		}
	}
}

2，二叉树的创建和easyx的可视化操作

二叉树的创建以先根遍历的方式

void CreateBiTree(BiTree* T){
	char ch;
	cin >> ch;
	if (ch == '.') {
		*T = NULL;
	}
	else {
		*T = (BiTree)malloc(sizeof(Binode));
		(*T)->data = ch;
		CreateBiTree(&((*T)->lchild));
		CreateBiTree(&((*T)->rchild));
	}
}

用easyx首先画一张图，我想让这棵树的根节点从坐标（360，200）的位置开始生成根结点画个圈，然后先从左子树开始向他六十度方向连线并为当前结点画个圈，直到左子树为空，开始回溯，判断是否有右子树，有则向六十度方向画出右子树为当前结点画个圈并重复上述画左子树的方法。

当然，因为二叉树如果左子树和右子树的连线角度和线长都相等，这可以理解为一个对称图形，那么可能内侧的结点会有重叠覆盖，所以，我将角度设为变量，每增加一层，角度 $x{_p}$ 都除以2，对应的(x,y)到终点（xf,yf）的距离也缩短1.2倍

$x{_f}=x\pm (x{_t}*\left |cos(x{_p}) \right |)/1.2$

$y{_f}=y\pm (x{_t}*\left |sin(y{_p}) \right |)/1.2$

程序到这里也这里也只是画了一张图，最求高级的我想让这份作业高级一点，把他变成动画：

线段细化为无数个点排列在一起，我通过两点公式求出这条显得函数关系式： $y=\frac{y{_t}}{x{_t}}*x-\frac{y{_t}}{x{_t}}*x{_x{_0}}+y{_0}$

之后我们将x到 $x{_f}$ 细化为500份，y由公式可得，通过循环遍历每个点可得到生成线段的动画

void PrevOrderDraw(BiTree T, double x, double y, double xt, double yt,double xp,int time,int dep)//xp为角度,
{
	if (T)
	{
		setfillcolor(BLUE);
		setbkmode(TRANSPARENT);
		fillcircle(x, y, 20);
		outtextxy(x - 5, y - 5, T->data);
	}
	if (T->lchild)//左子树
	{
		double i ,j;
		for (i = x,j=y; i >=x - xt,j<=y+yt;) {
			i -= (x - xt) / 500, j =(-yt/xt)*i-(-yt/xt)*x+y;
			line(x,y , i, j);
			Sleep(time);
		}
		setfillcolor(BLUE);
		setbkmode(TRANSPARENT);
		fillcircle(x, y, 20);
		outtextxy(x - 5, y - 5, T->data);
		PrevOrderDraw(T->lchild, x - xt, y + yt, xt / 1.2 * abs(cos(xp)), yt / 1.2 * abs(sin(xp)), xp / 2, time + 4 * dep, dep + 1);
	}
	
	if (T->rchild)//右子树
	{
		double i, j;
		for (i = x, j = y; i >= x + xt, j <= y + yt;) {
			i += (x + xt) / 500, j = (yt / xt) * i - (yt / xt) * x + y;
			line(x, y, i, j);
			Sleep(time);
		}
		setfillcolor(BLUE);
		setbkmode(TRANSPARENT);
		fillcircle(x, y, 20);
		outtextxy(x - 5, y - 5, T->data);
		PrevOrderDraw(T->rchild, x + xt, y + yt, xt / 1.2 * abs(cos(xp)), yt / 1.2 * abs(sin(xp)), xp / 2, time + 4 * dep, dep + 1);
	}
}

void PrintBiTree(BiTree T)
{
	PrevOrderDraw(T, 360,200, 200* abs(sin(PI / 3)), 200* abs(cos(PI / 3)), PI / 3,6,1);
}

考虑到后面线段变短，所以每次睡眠时间通过层数增加，还有每次画完线需要再画一次圆盖掉线的痕迹，不然影响美观。

二叉树AB.C..DE.G..F.H..先序遍历生成动画结束的样子

当然这只是一棵小二叉树，对于5层以上的建议大家长度由短到长，角度由小到大，不会显得太密集。

3,二叉树的遍历和easyx可视化

想法很简单：分别在输出值上加个结点颜色改变的函数，之前想过用圆变大变小来操作，但是变大变小完线会被盖掉，这样我们要重新画线，代表了我们要访问他的双亲结点的x，y，这样需要用到之前说的三叉链表存储，我懒，没有实现。

注意一下，这里加了xy，所以画二叉树那也要更改一下：

typedef struct BiNode {
	char data;

	double x, y;
	struct BiNode* lchild, * rchild;
}Binode,*BiTree;

各种遍历：

这个变色是闪三下，写的有点暴力

void circhange(int x, int y, int data)
{
	settextcolor(BLACK);
	setfillcolor(YELLOW);
	setbkmode(TRANSPARENT);
	fillcircle(x, y, 20);
	outtextxy(x - 5, y - 5, data);
	Sleep(400);
	setfillcolor(BLUE);
	setbkmode(TRANSPARENT);
	fillcircle(x, y, 20);
	outtextxy(x - 5, y - 5, data);
	Sleep(400);
	setfillcolor(YELLOW);
	setbkmode(TRANSPARENT);
	fillcircle(x, y, 20);
	outtextxy(x - 5, y - 5, data);
	Sleep(400);
}

void Preordertravers(BiTree T) {
	if (T == NULL)return ;
	else {
		cout << T->data;
		circhange(T->x, T->y,T->data);
		Preordertravers(T->lchild);
		Preordertravers(T->rchild);
	}
}

void Inordertraverse(BiTree T) {
	if (T == NULL)return;
	else {
	
		Inordertraverse(T->lchild);
		cout << T->data;
		circhange(T->x, T->y, T->data);
		Inordertraverse(T->rchild);
	}
}

void Postordertraverse(BiTree T) {
	if (T == NULL)return;
	else {

		Postordertraverse(T->lchild);
		Postordertraverse(T->rchild);
		cout << T->data;
		circhange(T->x, T->y, T->data);
	}
}

void HierarchyOrder(Binode * T)
{
	queueq;
	q.push(T);
	Binode* temp;
	while (!q.empty()) {
		temp = q.front();
		q.pop();
		cout << temp->data;
		circhange(temp->x, temp->y, temp->data);
		if (temp->lchild != NULL) {
			q.push(temp->lchild);
		}
		if (temp->rchild != NULL) {
			q.push(temp->rchild);
		}
	}
}

测试了一下，每个算法没啥问题，接下来就可以实现选择功能的界面了

4,easyx设计操控界面

首先设定生产二叉树窗口

在main中打开文件，利用easyx的鼠标读取对四种二叉树进行读取并生成

int main() {
	initgraph(720, 720, EW_SHOWCONSOLE);
	ifstream file;
	BiTree T;
	file.open("test.txt");
	file >> s1 >> s2 >> s3 >> s4;
	showjpg();
	BeginBatchDraw();

	ExMessage msg;
	int x[5], y[5], w[5], h[5];
	x[0] = 260;
	y[0] = 100;
	w[0] = 200;
	h[0] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
	botton_table(x[0], y[0], w[0], h[0], "Bitree_1");
	x[1] = 260;
	y[1] = 200;
	w[1] = 200;
	h[1] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
	botton_table(x[0], y[0], w[0], h[0], "Bitree_2");
	x[2] = 260;
	y[2] = 300;
	w[2] = 200;
	h[2] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
	botton_table(x[2], y[2], w[2], h[2], "Bitree_3");
	x[3] = 260;
	y[3] = 400;
	w[3] = 200;
	h[3] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
	botton_table(x[3], y[3], w[3], h[3], "Bitree_4");
	x[4] = 260;
	y[4] = 500;
	w[4] = 200;
	h[4] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
	botton_table(x[4], y[4], w[4], h[4], "退出");
	bool checkt = 0;
	while (1) {
		if (peekmessage(&msg, EM_MOUSE)) {
			switch (msg.message) {
			case WM_LBUTTONDOWN://点击
				if (msg.x >= x[0] && msg.x <= x[0] + w[0]  && msg.y >= y[0]  && msg.y <= y[0] + h[0] ) 
				{

					s = s1;
					ip = 0;
					cleardevice();
					CreateBiTree(&T);
					PrintBiTree(T);
					Sleep(800);
					cleardevice();
					showjpg();
					Orderchoice(T);
				}
				if (msg.x >= x[1] && msg.x <= x[1] + w[1]  && msg.y >= y[1]  && msg.y <= y[1] + h[1] )
				{
					s = s2;
					ip = 0;
					cleardevice();
					CreateBiTree(&T);
					PrintBiTree(T);
					Sleep(800);
					cleardevice();
					showjpg();
					Orderchoice(T);
				}
				if (msg.x >= x[2]  && msg.x <= x[2] + w[2]  && msg.y >= y[2] && msg.y <= y[2] + h[2])
				{
					s = s3;
					ip = 0;
					cleardevice();
					CreateBiTree(&T);
					PrintBiTree(T);
					Sleep(800);
					cleardevice();
					showjpg();
					Orderchoice(T);
				}
				if (msg.x >= x[3] && msg.x <= x[3] + w[3] && msg.y >= y[3] && msg.y <= y[3] + h[3])
				{
					s = s4;
					ip = 0;
					CreateBiTree(&T);
					cleardevice();
					PrintBiTree(T);
					Sleep(800);
					cleardevice();
					showjpg();
					Orderchoice(T);
				}
				if (msg.x >= x[4] && msg.x <= x[4] + w[4] && msg.y >= y[4] && msg.y <= y[4] + h[4])
				{
					checkt = true;
				}
				FlushBatchDraw();
			case WM_MOUSEFIRST://移动
				if (msg.x >= x[0] && msg.x <= x[0] + w[0]  && msg.y >= y[0]  && msg.y <= y[0] + h[0]) 
				{
					setfillcolor(RED);
					fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
					botton_table(x[0], y[0], w[0], h[0], "Bitree_1");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
					botton_table(x[0], y[0], w[0], h[0], "Bitree_1");
				}
				if (msg.x >= x[1]  && msg.x <= x[1] + w[1]  && msg.y >= y[1]  && msg.y <= y[1] + h[1]) {
					setfillcolor(RED);
					fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
					botton_table(x[1], y[1], w[1], h[1], "Bitree_2");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
					botton_table(x[1], y[1], w[1], h[1], "Bitree_2");
				}
				if (msg.x >= x[2]  && msg.x <= x[2] + w[2]  && msg.y >= y[2]  && msg.y <= y[2] + h[2]) {
					setfillcolor(RED);
					fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
					botton_table(x[2], y[2], w[2], h[2], "Bitree_3");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
					botton_table(x[2], y[2], w[2], h[2], "Bitree_3");
				}
				if (msg.x >= x[3] && msg.x <= x[3] + w[3] && msg.y >= y[3] && msg.y <= y[3] + h[3]) {
					setfillcolor(RED);
					fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
					botton_table(x[3], y[3], w[3], h[3], "Bitree_4");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
					botton_table(x[3], y[3], w[3], h[3], "Bitree_4");
				}
				if (msg.x >= x[4] && msg.x <= x[4] + w[4] && msg.y >= y[4] && msg.y <= y[4] + h[4]) {
					setfillcolor(RED);
					fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
					botton_table(x[4], y[4], w[4], h[4], "退出");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
					botton_table(x[4], y[4], w[4], h[4], "退出");
				}
			}
			EndBatchDraw();
		}
		if (checkt) {
			break;
		}
	}
	return 0;
}

再定义一个遍历选择函数，即选择并生成完所示二叉树，并选择遍历方式

void Orderchoice(BiTree T) {

	showjpg();
	BeginBatchDraw();

	ExMessage msg;
	int x[5], y[5], w[5], h[5];
	x[0] = 260;
	y[0] = 100;
	w[0] = 200;
	h[0] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
	botton_table(x[0], y[0], w[0], h[0], "先序遍历");
	x[1] = 260;
	y[1] = 200;
	w[1] = 200;
	h[1] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
	botton_table(x[0], y[0], w[0], h[0], "中序遍历");
	x[2] = 260;
	y[2] = 300;
	w[2] = 200;
	h[2] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
	botton_table(x[2], y[2], w[2], h[2], "后序遍历");
	x[3] = 260;
	y[3] = 400;
	w[3] = 200;
	h[3] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
	botton_table(x[3], y[3], w[3], h[3], "层次遍历");
	x[4] = 260;
	y[4] = 500;
	w[4] = 200;
	h[4] = 50;
	setfillcolor(YELLOW);
	fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
	botton_table(x[4], y[4], w[4], h[4], "退出");
	bool checkt = 0;
	while (1) {
		if (peekmessage(&msg, EM_MOUSE)) {
			switch (msg.message) {
			case WM_LBUTTONDOWN://点击
				if (msg.x >= x[0] && msg.x <= x[0] + w[0] && msg.y >= y[0] && msg.y <= y[0] + h[0])
				{
					cleardevice();
					Draw(T, 360, 200, 180 * abs(sin(PI / 3)), 180 * abs(cos(PI / 3)), PI / 3);
					Preordertravers(T);
					cleardevice();
					showjpg();
				
				}
				if (msg.x >= x[1] && msg.x <= x[1] + w[1] && msg.y >= y[1] && msg.y <= y[1] + h[1])
				{
					cleardevice();
					Draw(T, 360, 200, 180 * abs(sin(PI / 3)), 180 * abs(cos(PI / 3)), PI / 3);
					Inordertraverse(T);
					cleardevice();
					showjpg();
				}
				if (msg.x >= x[2] && msg.x <= x[2] + w[2] && msg.y >= y[2] && msg.y <= y[2] + h[2])
				{
					cleardevice();
					Draw(T, 360, 200, 180 * abs(sin(PI / 3)), 180 * abs(cos(PI / 3)), PI / 3);
					Postordertraverse(T);
					cleardevice();
					showjpg();
				}
				if (msg.x >= x[3] && msg.x <= x[3] + w[3] && msg.y >= y[3] && msg.y <= y[3] + h[3])
				{
					cleardevice();
					Draw(T, 360, 200, 180 * abs(sin(PI / 3)), 180 * abs(cos(PI / 3)), PI / 3);
					HierarchyOrder(T);
					cleardevice();
					showjpg();
				}
				if (msg.x >= x[4] && msg.x <= x[4] + w[4] && msg.y >= y[4] && msg.y <= y[4] + h[4])
				{
					checkt = true;
				}
				FlushBatchDraw();
			case WM_MOUSEFIRST://移动
				if (msg.x >= x[0] && msg.x <= x[0] + w[0] && msg.y >= y[0] && msg.y <= y[0] + h[0])
				{
					setfillcolor(RED);
					fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
					botton_table(x[0], y[0], w[0], h[0], "先序遍历");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
					botton_table(x[0], y[0], w[0], h[0], "先序遍历");
				}
				if (msg.x >= x[1] && msg.x <= x[1] + w[1] && msg.y >= y[1] && msg.y <= y[1] + h[1]) {
					setfillcolor(RED);
					fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
					botton_table(x[1], y[1], w[1], h[1], "中序遍历");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
					botton_table(x[1], y[1], w[1], h[1], "中序遍历");
				}
				if (msg.x >= x[2] && msg.x <= x[2] + w[2] && msg.y >= y[2] && msg.y <= y[2] + h[2]) {
					setfillcolor(RED);
					fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
					botton_table(x[2], y[2], w[2], h[2], "后序遍历");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
					botton_table(x[2], y[2], w[2], h[2], "后序遍历");
				}
				if (msg.x >= x[3] && msg.x <= x[3] + w[3] && msg.y >= y[3] && msg.y <= y[3] + h[3]) {
					setfillcolor(RED);
					fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
					botton_table(x[3], y[3], w[3], h[3], "层次遍历");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
					botton_table(x[3], y[3], w[3], h[3], "层次遍历");
				}
				if (msg.x >= x[4] && msg.x <= x[4] + w[4] && msg.y >= y[4] && msg.y <= y[4] + h[4]) {
					setfillcolor(RED);
					fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
					botton_table(x[4], y[4], w[4], h[4], "退出");
				}
				else {
					setfillcolor(YELLOW);
					fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
					botton_table(x[4], y[4], w[4], h[4], "退出");
				}

			}
			EndBatchDraw();
		}
		if (checkt) {
			break;
		}
	}
	return;
}

总程序

#include
#include
#include
#include
#include
#include
using namespace std;

#define PI 3.1415
typedef struct BiNode {
   char data;

   double x, y;
   struct BiNode* lchild, * rchild;
   struct BiNode* parent;
}Binode,*BiTree;
string s,s1, s2, s3, s4;

void botton_table(int x, int y, int w, int h, const char* text) {

   settextcolor(RGB(0, 0, 0));
   setbkmode(TRANSPARENT);
   char text_[50];
   strcmp(text_, text);
   int tx = x + (w - textwidth(text)) / 2;
   int ty = y + (h - textheight(text)) / 2;
   outtextxy(tx, ty, text);
}

void showjpg() {
   IMAGE img;
   loadimage(&img, "./1.jpg", 720, 720);
   putimage(0, 0, &img);

}

void circhange(int x, int y, int data)
{
   settextcolor(BLACK);
   setfillcolor(YELLOW);
   setbkmode(TRANSPARENT);
   fillcircle(x, y, 20);
   outtextxy(x - 5, y - 5, data);
   Sleep(400);
   setfillcolor(BLUE);
   setbkmode(TRANSPARENT);
   fillcircle(x, y, 20);
   outtextxy(x - 5, y - 5, data);
   Sleep(400);
   setfillcolor(YELLOW);
   setbkmode(TRANSPARENT);
   fillcircle(x, y, 20);
   outtextxy(x - 5, y - 5, data);
   Sleep(400);
}

void Preordertravers(BiTree T) {
   if (T == NULL)return ;
   else {
       cout << T->data;
       circhange(T->x, T->y,T->data);
       Preordertravers(T->lchild);
       Preordertravers(T->rchild);
   }
}

void Inordertraverse(BiTree T) {
   if (T == NULL)return;
   else {

       Inordertraverse(T->lchild);
       cout << T->data;
       circhange(T->x, T->y, T->data);
       Inordertraverse(T->rchild);
   }
}

void Postordertraverse(BiTree T) {
   if (T == NULL)return;
   else {

       Postordertraverse(T->lchild);
       Postordertraverse(T->rchild);
       cout << T->data;
       circhange(T->x, T->y, T->data);
   }
}

void HierarchyOrder(Binode * T)
{
   queueq;
   q.push(T);
   Binode* temp;
   while (!q.empty()) {
       temp = q.front();
       q.pop();
       cout << temp->data;
       circhange(temp->x, temp->y, temp->data);
       if (temp->lchild != NULL) {
           q.push(temp->lchild);
       }
       if (temp->rchild != NULL) {
           q.push(temp->rchild);
       }
   }
}
int ip ;
char ch;
void CreateBiTree(BiTree* T){

   ch = s[ip++];
   if (ch == '.') {
       *T = NULL;
   }
   else {
       *T = (BiTree)malloc(sizeof(Binode));
       (*T)->data = ch;
       CreateBiTree(&((*T)->lchild));
       CreateBiTree(&((*T)->rchild));
   }
}
void PrevOrder_stack(Binode* T)
{
   stack s;
   Binode* Bi = T;
   while (Bi || !s.empty())
   {
       if(Bi)
       {
           cout << Bi->data;
           s.push(Bi);
           Bi = Bi->lchild;
       }
       else {
           Bi = s.top();
           s.pop();
           Bi = Bi->rchild;
       }
   }
   cout << "先序遍历_栈" << endl;
}
void InOrder_stack(Binode* T)
{
   stack s;

   Binode* Bi = T;

   while (Bi || !s.empty())
   {
       if (Bi)
       {
           s.push(Bi);
           Bi = Bi->lchild;
       }
       else {
           Bi = s.top();
           cout << Bi->data;
           s.pop();
           Bi = Bi->rchild;
       }
   }
   cout << "中序遍历_栈" << endl;
}
void PastOrder_stack(Binode* T)
{
   Binode* Bi = T;
   Binode* vis = NULL;
   stack s;
   while (Bi||!s.empty())
   {
       if (Bi)
       {
           s.push(Bi);
           Bi = Bi->lchild;
       }
       else {
           Bi = s.top();
           if (Bi->rchild && vis != Bi->rchild)
               Bi = Bi->rchild;
           else if (( Bi->rchild==NULL) || (vis == Bi->rchild))
           {
               cout << Bi->data;
               vis = Bi;
               s.pop();
               Bi = NULL;
           }
       }
   }
   cout << "后序遍历栈" << endl;
}

void PrevOrderDraw(BiTree T, double x, double y, double xt, double yt,double xp,int time,int dep)//xp为角度,
{
   if (T)
   {
       T->x = x;
       T->y = y;
       setfillcolor(BLUE);
       settextcolor(WHITE);
       setbkmode(TRANSPARENT);
       fillcircle(x, y, 20);
       outtextxy(x - 5, y - 5, T->data);
   }
   if (T->lchild)//左子树
   {
       double i ,j;
       for (i = x,j=y; i >=x - xt,j<=y+yt;) {
           i -= (x - xt) / 500, j =(-yt/xt)*i-(-yt/xt)*x+y;
           line(x,y , i, j);
           Sleep(time);
       }
       setfillcolor(BLUE);
       setbkmode(TRANSPARENT);
       fillcircle(x, y, 20);
       settextcolor(WHITE);
       T->x = x;
       T->y = y;
       outtextxy(x - 5, y - 5, T->data);
       PrevOrderDraw(T->lchild, x - xt, y + yt, xt / 1.1 * abs(cos(xp)), yt / 1.1 * abs(sin(xp)), xp / 2, time + pow(7, dep), dep + 1);
   }

   if (T->rchild)//右子树
   {
       double i, j;
       for (i = x, j = y; i >= x + xt, j <= y + yt;) {
           i += (x + xt) / 500, j = (yt / xt) * i - (yt / xt) * x + y;
           line(x, y, i, j);
           Sleep(time);
       }
       setfillcolor(BLUE);
       setbkmode(TRANSPARENT);
       fillcircle(x, y, 20);
       T->x = x;
       T->y = y;
       settextcolor(WHITE);
       outtextxy(x - 5, y - 5, T->data);
       PrevOrderDraw(T->rchild, x + xt, y + yt, xt / 1.1 * abs(cos(xp)), yt / 1.1 * abs(sin(xp)), xp / 2, time + pow(7, dep), dep + 1);
   }
}

void PrintBiTree(BiTree T)
{
   PrevOrderDraw(T, 360,200, 180* abs(sin(PI / 3)), 180* abs(cos(PI / 3)), PI / 3,3,1);
}

void Draw(BiTree T, double x, double y, double xt, double yt, double xp)//xp为角度,
{
   if (T)
   {
       T->x = x;
       T->y = y;
       setfillcolor(BLUE);
       setbkmode(TRANSPARENT);
       fillcircle(x, y, 20);
       outtextxy(x - 5, y - 5, T->data);
   }
   if (T->lchild)//左子树
   {
       line(x, y, x-xt,y+yt);
       setfillcolor(BLUE);
       setbkmode(TRANSPARENT);
       fillcircle(x, y, 20);
       T->x = x;
       T->y = y;
       outtextxy(x - 5, y - 5, T->data);
       Draw(T->lchild, x - xt, y + yt, xt / 1.1 * abs(cos(xp)), yt / 1.1 * abs(sin(xp)), xp / 2);
   }

   if (T->rchild)//右子树
   {
       line(x, y, x+xt,y+yt);
       setfillcolor(BLUE);
       setbkmode(TRANSPARENT);
       fillcircle(x, y, 20);
       T->x = x;
       T->y = y;
       outtextxy(x - 5, y - 5, T->data);
       Draw(T->rchild, x + xt, y + yt, xt / 1.1 * abs(cos(xp)), yt / 1.1 * abs(sin(xp)), xp / 2);
   }
}

//int main()
//{
//   ifstream file;
//   file.open("test.txt");
//   file >> s1 >> s2 >> s3 >> s4;
//   s = s1;
//
//   BiTree T;
//
//   CreateBiTree(&T,0);
//
//   PrevOrder_stack(T);
//   InOrder_stack(T);
//   PastOrder_stack(T);
//
//   PrintBiTree(T);
//
//
//
//
//   HierarchyOrder(T);
//   cout << "层次遍历栈" << endl;
//   Draw(T, 360, 200, 180 * abs(sin(PI / 3)), 180 * abs(cos(PI / 3)), PI / 3);
//   /*Preordertravers(T);
//   cout << "先序遍历" << endl;
//   Inordertraverse(T);
//   cout << "中序遍历" << endl;
//   Postordertraverse(T);
//   cout << "后序遍历" << endl;*/
//
//
//   Sleep(80000);
//}

void Orderchoice(BiTree T) {

   showjpg();
   BeginBatchDraw();

   ExMessage msg;
   int x[5], y[5], w[5], h[5];
   x[0] = 260;
   y[0] = 100;
   w[0] = 200;
   h[0] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
   botton_table(x[0], y[0], w[0], h[0], "先序遍历");
   x[1] = 260;
   y[1] = 200;
   w[1] = 200;
   h[1] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
   botton_table(x[0], y[0], w[0], h[0], "中序遍历");
   x[2] = 260;
   y[2] = 300;
   w[2] = 200;
   h[2] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
   botton_table(x[2], y[2], w[2], h[2], "后序遍历");
   x[3] = 260;
   y[3] = 400;
   w[3] = 200;
   h[3] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
   botton_table(x[3], y[3], w[3], h[3], "层次遍历");
   x[4] = 260;
   y[4] = 500;
   w[4] = 200;
   h[4] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
   botton_table(x[4], y[4], w[4], h[4], "退出");
   bool checkt = 0;
   while (1) {
       if (peekmessage(&msg, EM_MOUSE)) {
           switch (msg.message) {
           case WM_LBUTTONDOWN://点击
               if (msg.x >= x[0] && msg.x <= x[0] + w[0] && msg.y >= y[0] && msg.y <= y[0] + h[0])
               {
                   cleardevice();
                   Draw(T, 360, 200, 180 * abs(sin(PI / 3)), 180 * abs(cos(PI / 3)), PI / 3);
                   Preordertravers(T);
                   cleardevice();
                   showjpg();

               }
               if (msg.x >= x[1] && msg.x <= x[1] + w[1] && msg.y >= y[1] && msg.y <= y[1] + h[1])
               {
                   cleardevice();
                   Draw(T, 360, 200, 180 * abs(sin(PI / 3)), 180 * abs(cos(PI / 3)), PI / 3);
                   Inordertraverse(T);
                   cleardevice();
                   showjpg();
               }
               if (msg.x >= x[2] && msg.x <= x[2] + w[2] && msg.y >= y[2] && msg.y <= y[2] + h[2])
               {
                   cleardevice();
                   Draw(T, 360, 200, 180 * abs(sin(PI / 3)), 180 * abs(cos(PI / 3)), PI / 3);
                   Postordertraverse(T);
                   cleardevice();
                   showjpg();
               }
               if (msg.x >= x[3] && msg.x <= x[3] + w[3] && msg.y >= y[3] && msg.y <= y[3] + h[3])
               {
                   cleardevice();
                   Draw(T, 360, 200, 180 * abs(sin(PI / 3)), 180 * abs(cos(PI / 3)), PI / 3);
                   HierarchyOrder(T);
                   cleardevice();
                   showjpg();
               }
               if (msg.x >= x[4] && msg.x <= x[4] + w[4] && msg.y >= y[4] && msg.y <= y[4] + h[4])
               {
                   checkt = true;
               }
               FlushBatchDraw();
           case WM_MOUSEFIRST://移动
               if (msg.x >= x[0] && msg.x <= x[0] + w[0] && msg.y >= y[0] && msg.y <= y[0] + h[0])
               {
                   setfillcolor(RED);
                   fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
                   botton_table(x[0], y[0], w[0], h[0], "先序遍历");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
                   botton_table(x[0], y[0], w[0], h[0], "先序遍历");
               }
               if (msg.x >= x[1] && msg.x <= x[1] + w[1] && msg.y >= y[1] && msg.y <= y[1] + h[1]) {
                   setfillcolor(RED);
                   fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
                   botton_table(x[1], y[1], w[1], h[1], "中序遍历");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
                   botton_table(x[1], y[1], w[1], h[1], "中序遍历");
               }
               if (msg.x >= x[2] && msg.x <= x[2] + w[2] && msg.y >= y[2] && msg.y <= y[2] + h[2]) {
                   setfillcolor(RED);
                   fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
                   botton_table(x[2], y[2], w[2], h[2], "后序遍历");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
                   botton_table(x[2], y[2], w[2], h[2], "后序遍历");
               }
               if (msg.x >= x[3] && msg.x <= x[3] + w[3] && msg.y >= y[3] && msg.y <= y[3] + h[3]) {
                   setfillcolor(RED);
                   fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
                   botton_table(x[3], y[3], w[3], h[3], "层次遍历");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
                   botton_table(x[3], y[3], w[3], h[3], "层次遍历");
               }
               if (msg.x >= x[4] && msg.x <= x[4] + w[4] && msg.y >= y[4] && msg.y <= y[4] + h[4]) {
                   setfillcolor(RED);
                   fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
                   botton_table(x[4], y[4], w[4], h[4], "退出");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
                   botton_table(x[4], y[4], w[4], h[4], "退出");
               }

           }
           EndBatchDraw();
       }
       if (checkt) {
           break;
       }
   }
   return;
}

int main() {
   initgraph(720, 720, EW_SHOWCONSOLE);
   ifstream file;
   BiTree T;
   file.open("test.txt");
   file >> s1 >> s2 >> s3 >> s4;
   showjpg();
   BeginBatchDraw();

   ExMessage msg;
   int x[5], y[5], w[5], h[5];
   x[0] = 260;
   y[0] = 100;
   w[0] = 200;
   h[0] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
   botton_table(x[0], y[0], w[0], h[0], "Bitree_1");
   x[1] = 260;
   y[1] = 200;
   w[1] = 200;
   h[1] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
   botton_table(x[0], y[0], w[0], h[0], "Bitree_2");
   x[2] = 260;
   y[2] = 300;
   w[2] = 200;
   h[2] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
   botton_table(x[2], y[2], w[2], h[2], "Bitree_3");
   x[3] = 260;
   y[3] = 400;
   w[3] = 200;
   h[3] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
   botton_table(x[3], y[3], w[3], h[3], "Bitree_4");
   x[4] = 260;
   y[4] = 500;
   w[4] = 200;
   h[4] = 50;
   setfillcolor(YELLOW);
   fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
   botton_table(x[4], y[4], w[4], h[4], "退出");
   bool checkt = 0;
   while (1) {
       if (peekmessage(&msg, EM_MOUSE)) {
           switch (msg.message) {
           case WM_LBUTTONDOWN://点击
               if (msg.x >= x[0] && msg.x <= x[0] + w[0] && msg.y >= y[0] && msg.y <= y[0] + h[0] )
               {

                   s = s1;
                   ip = 0;
                   cleardevice();
                   CreateBiTree(&T);
                   PrintBiTree(T);
                   Sleep(800);
                   cleardevice();
                   showjpg();
                   Orderchoice(T);
               }
               if (msg.x >= x[1] && msg.x <= x[1] + w[1] && msg.y >= y[1] && msg.y <= y[1] + h[1] )
               {
                   s = s2;
                   ip = 0;
                   cleardevice();
                   CreateBiTree(&T);
                   PrintBiTree(T);
                   Sleep(800);
                   cleardevice();
                   showjpg();
                   Orderchoice(T);
               }
               if (msg.x >= x[2] && msg.x <= x[2] + w[2] && msg.y >= y[2] && msg.y <= y[2] + h[2])
               {
                   s = s3;
                   ip = 0;
                   cleardevice();
                   CreateBiTree(&T);
                   PrintBiTree(T);
                   Sleep(800);
                   cleardevice();
                   showjpg();
                   Orderchoice(T);
               }
               if (msg.x >= x[3] && msg.x <= x[3] + w[3] && msg.y >= y[3] && msg.y <= y[3] + h[3])
               {
                   s = s4;
                   ip = 0;
                   CreateBiTree(&T);
                   cleardevice();
                   PrintBiTree(T);
                   Sleep(800);
                   cleardevice();
                   showjpg();
                   Orderchoice(T);
               }
               if (msg.x >= x[4] && msg.x <= x[4] + w[4] && msg.y >= y[4] && msg.y <= y[4] + h[4])
               {
                   checkt = true;
               }
               FlushBatchDraw();
           case WM_MOUSEFIRST://移动
               if (msg.x >= x[0] && msg.x <= x[0] + w[0] && msg.y >= y[0] && msg.y <= y[0] + h[0])
               {
                   setfillcolor(RED);
                   fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
                   botton_table(x[0], y[0], w[0], h[0], "Bitree_1");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[0], y[0], x[0] + w[0], y[0] + h[0], 10, 10);
                   botton_table(x[0], y[0], w[0], h[0], "Bitree_1");
               }
               if (msg.x >= x[1] && msg.x <= x[1] + w[1] && msg.y >= y[1] && msg.y <= y[1] + h[1]) {
                   setfillcolor(RED);
                   fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
                   botton_table(x[1], y[1], w[1], h[1], "Bitree_2");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[1], y[1], x[1] + w[1], y[1] + h[1], 10, 10);
                   botton_table(x[1], y[1], w[1], h[1], "Bitree_2");
               }
               if (msg.x >= x[2] && msg.x <= x[2] + w[2] && msg.y >= y[2] && msg.y <= y[2] + h[2]) {
                   setfillcolor(RED);
                   fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
                   botton_table(x[2], y[2], w[2], h[2], "Bitree_3");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[2], y[2], x[2] + w[2], y[2] + h[2], 10, 10);
                   botton_table(x[2], y[2], w[2], h[2], "Bitree_3");
               }
               if (msg.x >= x[3] && msg.x <= x[3] + w[3] && msg.y >= y[3] && msg.y <= y[3] + h[3]) {
                   setfillcolor(RED);
                   fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
                   botton_table(x[3], y[3], w[3], h[3], "Bitree_4");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[3], y[3], x[3] + w[3], y[3] + h[3], 10, 10);
                   botton_table(x[3], y[3], w[3], h[3], "Bitree_4");
               }
               if (msg.x >= x[4] && msg.x <= x[4] + w[4] && msg.y >= y[4] && msg.y <= y[4] + h[4]) {
                   setfillcolor(RED);
                   fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
                   botton_table(x[4], y[4], w[4], h[4], "退出");
               }
               else {
                   setfillcolor(YELLOW);
                   fillroundrect(x[4], y[4], x[4] + w[4], y[4] + h[4], 10, 10);
                   botton_table(x[4], y[4], w[4], h[4], "退出");
               }
           }
           EndBatchDraw();
       }
       if (checkt) {
           break;
       }
   }
   return 0;
}

总结

第一次写这个。。。没啥经验，单纯想发发玩，有什么说错的地方可以指出来。

总体操作不算繁琐，600行轻松解决作业 OvO

你可能感兴趣的:(数据结构,数据结构)

数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
数据结构之哈希表 X同学的开始数据结构数据结构散列表
哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列 C语言
文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
[Python] 数据结构详解及代码 AIAdvocate 算法 python 数据结构链表
今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
4.C_数据结构_队列荣世蓥数据结构数据结构
概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【树一线性代数】005入门 Owlet_woodBird 算法
Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构 leetcode 算法
给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
【高阶数据结构】并查集椿融雪数据结构与算法数据结构并查集
文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
python中文版软件下载-Python中文版编程大乐趣
python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
开发游戏的学习规划杰克逊的日记游戏学习
第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
Golang Channel PandaSkr golang
Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表英雄哪里出来《LeetCode算法全集》算法数据结构链表 c++归并排序
饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述将两个不降序链表合并为一个新的不降
数据结构 1 五花肉村长数据结构算法开发语言 c语言 visualstudio
1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法 leetcode b树
数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
【Python】数据结构,链表,算法详解 AIAdvocate python 数据结构链表排序算法广度优先深度优先
今日内容大纲介绍自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树1.自定义代码-模拟链表完整版"""案例:自定义代码,模拟链表.背景: 顺序表在存储数据的时候,需要使用到连续的空间,如果空间不够,就会导致扩容失败,针对于这种情况,我们可以通过链表实现
AI教你学Python 第4天：函数和模块凡人的AI工具箱 AI教你学Python python 开发语言人工智能 AIGC
第四天：数据结构一、什么是数据结构？数据结构是计算机科学中用于组织和存储数据的特定方式。良好的数据结构能够提高数据的访问效率、修改频率和管理能力。Python提供了多种内置数据结构，如列表、元组、字典和集合，便于开发者更有效地处理数据。二、Python中的基本数据结构1.列表（List）定义：列表是一个有序的可变集合，允许重复元素。使用方括号[]表示。#示例：定义一个列表fruits=['appl
互联网 Java 工程师面试题（Java 面试题四）苹果酱0567 面试题汇总与解析 java 中间件开发语言 spring boot 后端
下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
C# Tuple、ValueTuple 語衣 C#知识补充 c#
栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
Rust中的所有权和借用规则详解代码云1 rust 开发语言后端
Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
二叉树--python 电子海鸥 Python数据结构与算法 python 开发语言数据结构
二叉树一、概述1、介绍是一种非线性数据结构，将数据一分为二，代表根与叶的派生关系，和链表的结构类似，二叉树的基本单元是结点，每个节点包括值和左右子节点引用。每个节点都有两个引用（类似于双向链表），分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的结点时，我们将在该节点的左子节点以及其以下结点所形成的树称为左子树，同理，右子节点的部分被称为右子树。在二叉树中，除了叶节点
使用WAF防御网络上的隐蔽威胁之反序列化攻击 baiolkdnhjaio 网络安全
什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
java 线程池队列封装_java线程池（线程池组---分离任务队列和线程池）爱打怪的小魔女 java 线程池队列封装
线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
统一思想认识永夜-极光思想
1.统一思想认识的基础,才能有的放矢原因: 总有一种描述事物的方式最贴近本质,最容易让人理解. 如何让教育更轻松,在于找到最适合学生的方式. 难点在于,如何模拟对方的思维基础选择合适的方式. &
Joda Time使用笔记 bylijinnan java joda time
Joda Time的介绍可以参考这篇文章： http://www.ibm.com/developerworks/cn/java/j-jodatime.html 工作中也常常用到Joda Time，为了避免每次使用都查API，记录一下常用的用法： /** * DateTime变化（增减） */ @Tes
FileUtils API eksliang FileUtils FileUtils API
转载请出自出处：http://eksliang.iteye.com/blog/2217374 一、概述这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。非常的好用。
各种新兴技术不懂事的小屁孩技术
1:gradle Gradle 是以 Groovy 语言为基础，面向Java应用为主。基于DSL（领域特定语言）语法的自动化构建工具。现在构建系统常用到maven工具，现在有更容易上手的gradle，搭建java环境: http://www.ibm.com/developerworks/cn/opensource/os-cn-gradle/ 搭建android环境： http://m
tomcat6的https双向认证酷的飞上天空 tomcat6
1.生成服务器端证书 keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 36
托管虚拟桌面市场势不可挡蓝儿唯美
用户还需要冗余的数据中心，dinCloud的高级副总裁兼首席营销官Ali Din指出。该公司转售一个MSP可以让用户登录并管理和提供服务的用于DaaS的云自动化控制台，提供服务或者MSP也可以自己来控制。在某些情况下，MSP会在dinCloud的云服务上进行服务分层，如监控和补丁管理。 MSP的利润空间将根据其参与的程度而有所不同，Din说。 “我们有一些合作伙伴负责将我们推荐给客户作为个
spring学习——xml文件的配置 a-john spring
在Spring的学习中，对于其xml文件的配置是必不可少的。在Spring的多种装配Bean的方式中，采用XML配置也是最常见的。以下是一个简单的XML配置文件： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.or
HDU 4342 History repeat itself 模拟 aijuans 模拟
来源：http://acm.hdu.edu.cn/showproblem.php?pid=4342 题意：首先让求第几个非平方数，然后求从1到该数之间的每个sqrt(i)的下取整的和。思路：一个简单的模拟题目，但是由于数据范围大，需要用__int64。我们可以首先把平方数筛选出来，假如让求第n个非平方数的话，看n前面有多少个平方数，假设有x个，则第n个非平方数就是n+x。注意两种特殊情况，即
java中最常用jar包的用途 asia007 java
java中最常用jar包的用途 jar包用途axis.jarSOAP引擎包commons-discovery-0.2.jar用来发现、查找和实现可插入式接口，提供一些一般类实例化、单件的生命周期管理的常用方法.jaxrpc.jarAxis运行所需要的组件包saaj.jar创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法，以及接收和处理SOAP错误的方法. w
ajax获取Struts框架中的json编码异常和Struts中的主控制器异常的解决办法百合不是茶 js json编码返回异常
一:ajax获取自定义Struts框架中的json编码出现以下问题: 1,强制flush输出 json编码打印在首页 2, 不强制flush js会解析json 打印出来的是错误的jsp页面却没有跳转到错误页面 3, ajax中的dataType的json 改为text 会
JUnit使用的设计模式 bijian1013 java 设计模式 JUnit
JUnit源代码涉及使用了大量设计模式 1、模板方法模式（Template Method）定义一个操作中的算法骨架，而将一些步骤延伸到子类中去，使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。这里需要复用的是算法的结构，也就是步骤，而步骤的实现可以在子类中完成。
Linux常用命令（摘录） sunjing crond chkconfig
chkconfig --list 查看linux所有服务 chkconfig --add servicename 添加linux服务 netstat -apn | grep 8080 查看端口占用 env 查看所有环境变量 echo $JAVA_HOME 查看JAVA_HOME环境变量安装编译器 yum install -y gcc
【Hadoop一】Hadoop伪集群环境搭建 bit1129 hadoop
结合网上多份文档，不断反复的修正hadoop启动和运行过程中出现的问题，终于把Hadoop2.5.2伪分布式安装起来，跑通了wordcount例子。Hadoop的安装复杂性的体现之一是，Hadoop的安装文档非常多，但是能一个文档走下来的少之又少，尤其是Hadoop不同版本的配置差异非常的大。Hadoop2.5.2于前两天发布，但是它的配置跟2.5.0，2.5.1没有分别。 &nb
Anychart图表系列五之事件监听白糖_ chart
创建图表事件监听非常简单：首先是通过addEventListener('监听类型',js监听方法)添加事件监听，然后在js监听方法中定义具体监听逻辑。以钻取操作为例，当用户点击图表某一个point的时候弹出point的name和value，代码如下： <script> //创建AnyChart var chart = new AnyChart(); //添加钻取操作&quo
Web前端相关段子 braveCS web前端
Web标准：结构、样式和行为分离使用语义化标签 0）标签的语义：使用有良好语义的标签，能够很好地实现自我解释，方便搜索引擎理解网页结构，抓取重要内容。去样式后也会根据浏览器的默认样式很好的组织网页内容，具有很好的可读性，从而实现对特殊终端的兼容。 1）div和span是没有语义的：只是分别用作块级元素和行内元素的区域分隔符。当页面内标签无法满足设计需求时，才会适当添加div
编程之美-24点游戏 bylijinnan 编程之美
import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Random; import java.util.Set; public class PointGame { /**编程之美
主页面子页面传值总结 chengxuyuancsdn 总结
1、showModalDialog returnValue是javascript中html的window对象的属性,目的是返回窗口值,当用window.showModalDialog函数打开一个IE的模式窗口时,用于返回窗口的值主界面 var sonValue=window.showModalDialog("son.jsp"); 子界面 window.retu
[网络与经济]互联网+的含义 comsci 互联网+
互联网+后面是一个人的名字 = 网络控制系统互联网+你的名字 = 网络个人数据库每日提示:如果人觉得不舒服,千万不要外出到处走动,就呆在床上,玩玩手游,更不能够去开车,现在交通状况不
oracle 创建视图 with check option daizj 视图 view oralce
我们来看下面的例子： create or replace view testview as select empno,ename from emp where ename like ‘M%’ with check option; 这里我们创建了一个视图，并使用了with check option来限制了视图。然后我们来看一下视图包含的结果： select * from testv
ToastPlugin插件在cordova3.3下使用 dibov Cordova
自己开发的Todos应用，想实现“ 再按一次返回键退出程序 ”的功能，采用网上的ToastPlugins插件，发现代码或文章基本都是老版本，运行问题比较多。折腾了好久才弄好。下面吧基于cordova3.3下的ToastPlugins相关代码共享。 ToastPlugin.java package&nbs
C语言22个系统函数 dcj3sjt126com c function
C语言系统函数一、数学函数下列函数存放在math.h头文件中Double floor(double num) 求出不大于num的最大数。Double fmod(x, y) 求整数x/y的余数。Double frexp(num, exp); double num; int *exp; 将num分为数字部分（尾数）x和以2位的指数部分n，即num=x*2n，指数n存放在exp指向的变量中，返回x。D
开发一个类的流程 dcj3sjt126com 开发
本人近日根据自己的开发经验总结了一个类的开发流程。这个流程适用于单独开发的构件，并不适用于对一个项目中的系统对象开发。开发出的类可以存入私人类库，供以后复用。以下是开发流程： 1. 明确类的功能，抽象出类的大概结构 2. 初步设想类的接口 3. 类名设计（驼峰式命名） 4. 属性设置(权限设置) 判断某些变量是否有必要作为成员属
java 并发 shuizhaosi888 java 并发
能够写出高伸缩性的并发是一门艺术在JAVA SE5中新增了3个包 java.util.concurrent java.util.concurrent.atomic java.util.concurrent.locks 在java的内存模型中，类的实例字段、静态字段和构成数组的对象元素都会被多个线程所共享，局部变量与方法参数都是线程私有的，不会被共享。
Spring Security（11）——匿名认证 234390216 Spring Security ROLE_ANNOYMOUS 匿名
匿名认证目录 1.1 配置 1.2 AuthenticationTrustResolver 对于匿名访问的用户，Spring Security支持为其建立一个匿名的AnonymousAuthenticat
NODEJS项目实践0.2[ express,ajax通信...] 逐行分析JS源代码 Ajax nodejs express
一、前言通过上节学习，我们已经 ubuntu系统搭建了一个可以访问的nodejs系统，并做了nginx转发。本节原要做web端服务及 mongodb的存取，但写着写着，web端就
在Struts2 的Action中怎样获取表单提交上来的多个checkbox的值 lhbthanks java html struts checkbox
第一种方法：获取结果String类型在 Action 中获得的是一个 String 型数据，每一个被选中的 checkbox 的 value 被拼接在一起，每个值之间以逗号隔开(,)。所以在 Action 中定义一个跟 checkbox 的 name 同名的属性来接收这些被选中的 checkbox 的 value 即可。以下是实现的代码：前台 HTML 代码：
003.Kafka基本概念 nweiren hadoop kafka
Kafka基本概念：Topic、Partition、Message、Producer、Broker、Consumer。 Topic：消息源（Message）的分类。 Partition： Topic物理上的分组，一
Linux环境下安装JDK roadrunners jdk linux
1、准备工作创建JDK的安装目录： mkdir -p /usr/java/ 下载JDK，找到适合自己系统的JDK版本进行下载： http://www.oracle.com/technetwork/java/javase/downloads/index.html 把JDK安装包下载到/usr/java/目录，然后进行解压： tar -zxvf jre-7
Linux忘记root密码的解决思路 tomcat_oracle linux
1：使用同版本的linux启动系统，chroot到忘记密码的根分区passwd改密码　　2：grub启动菜单中加入init=/bin/bash进入系统，不过这时挂载的是只读分区。根据系统的分区情况进一步判断. 　　3: grub启动菜单中加入 single以单用户进入系统. 　　4:用以上方法mount到根分区把/etc/passwd中的root密码去除　　例如: 　　ro
跨浏览器 HTML5 postMessage 方法以及 message 事件模拟实现 xueyou jsonp jquery 框架 UI html5
postMessage 是 HTML5 新方法，它可以实现跨域窗口之间通讯。到目前为止，只有 IE8+, Firefox 3, Opera 9, Chrome 3和 Safari 4 支持，而本篇文章主要讲述 postMessage 方法与 message 事件跨浏览器实现。postMessage 方法 JSONP 技术不一样，前者是前端擅长跨域文档数据即时通讯，后者擅长针对跨域服务端数据通讯，p