树

最新推荐文章于 2022-08-23 15:29:39 发布
最新推荐文章于 2022-08-23 15:29:39 发布
阅读量203 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Perce_Issac/article/details/83060241
版权 
#include<iostream>

using namespace std;

//函数定义在 main 之前不用声明


typedef int TelemType;//方便替换成其他类型的数据

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
}Node;  // typedef 表示可以用 Node 来代替结构名来定义结构体


//创建二叉树，先中间再左右，结点数据为0表示叶子结点
Node* createBinaryTree() {
	Node* p;
	TelemType ch;
	cin >> ch;
	if (ch == 0) {
		p = NULL;
	}
	else {
		p = new Node();
		p->data = ch;
		p->left = createBinaryTree();
		p->right = createBinaryTree();
	}

	return p;
}

//先序遍历
void preOrderTraverse(Node* root) {
	if (root) {
		cout << root->data;
		preOrderTraverse(root->left);
		preOrderTraverse(root->right);
	}
}

//中序遍历
void inOrderTraverse(Node* root) {
	if (root) {
		preOrderTraverse(root->left);
		cout << root->data;
		preOrderTraverse(root->right);
	}
}

//后序遍历
void lastOrderTraverse(Node* root) {
	if (root) {
		
		preOrderTraverse(root->left);
		preOrderTraverse(root->right);
		cout << root->data;
	}
}
//结点总数目
int Nodenum(Node* root) {
	if (root == NULL) {
		return 0;
	}
	else {
		return 1 + Nodenum(root->left) + Nodenum(root->right);
	}
}
//二叉树深度
int DepthofTree(Node* root) {
	if (root == NULL) {
		return 0;
	}
	else {
		return DepthofTree(root->left) >DepthofTree(root->right) ?  DepthofTree(root->left) + 1 : DepthofTree(root->right) + 1;
	}
}
//叶子结点数
int Leafnum(Node*root) {
	if (!root) {
		return 0;
	}
	else if((root->left==NULL&&root->right==NULL)){
		return 1;
	}else{
		return (Leafnum(root->left) + Leafnum(root->right));
	}
}


int main(){
	Node *root = NULL;
	root = createBinaryTree();
	printf("二叉树建立成功");
	cout << endl;

	cout << "二叉树总节点数为：" << Nodenum(root) << endl;

	cout << "二叉树深度为：" << DepthofTree(root) << endl;

	cout << "二叉树叶子节点数为：" << Leafnum(root) << endl;

	cout << "前序遍历结果:" << endl;
	preOrderTraverse(root);
	cout << endl;

	cout << "中序遍历结果:" << endl;
	inOrderTraverse(root);
	cout << endl;

	cout << "后序遍历结果:" << endl;
	lastOrderTraverse(root);
	cout << endl;

	return 0;
}
#include<iostream>
#include<stack>
using namespace std;


typedef char TelemType;

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
}Node;  


Node* createBinaryTree() {
	Node* p;
	TelemType ch;
	cin >> ch;
	if (ch == '0'){
		p = NULL;
	}
	else {
		p = new Node();
		p->left = createBinaryTree();
		p->data = ch;
		p->right = createBinaryTree();
	}
	return p;
}

void PreOrder(Node* root,int &num)
{
	if (root)
	{
		if (root->left) {
			PreOrder(root->left,num);
		}
		else if (!root->right)  num++;
		if (root->right&&root->right->left) PreOrder(root->right->left,num);
	}
}






int main() {
	int t;
	cin >> t;
	while (t--) {
		int num = 0;
		Node *root = createBinaryTree(NULL);
		PreOrder(root,num);
		cout << num << endl;
	}
	return 0;
}


#include<iostream>
#include<stack>
using namespace std;


typedef char TelemType;

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
	struct BinaryTreeBode *father;
}Node;  


Node* createBinaryTree(Node* q) {
	Node* p;
	TelemType ch;
	cin >> ch;
	if (ch == '0'){
		p = NULL;
	}
	else {
		p = new Node();
		p->left = createBinaryTree(p);
		p->data = ch;
		p->right = createBinaryTree(p);
		p->father = q;
	}
	return p;
}

void Leafnum(Node*root) {
	if (!root) {
	}
	else if ((root->left == NULL && root->right == NULL)) {
		
		cout << root->data << " ";

	}
	else {
		Leafnum(root->left);
		Leafnum(root->right);
	}
}
void Fathernum(Node*root) {
	if (!root) {
	}
	else if ((root->left == NULL && root->right == NULL)) {
		cout << root->father->data << " ";
	}
	else {
		Fathernum(root->left);
		Fathernum(root->right);
	}
}


int main() {
	int t;
	cin >> t;
	while (t--) {
		Node *root = createBinaryTree(NULL);
		Leafnum(root);
		cout << endl;
		Fathernum(root);
		cout << endl;
	}
	return 0;
}

二叉树的数组储存：

https://blog.csdn.net/zhangwang010/article/details/73415966//完全没有用，只是格式化输出而已

数组储存

#include<iostream>
#include<stack>
using namespace std;


typedef int TelemType;

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
}Node;




void preOrderTraverse(Node* root) {
	if (root) {
		cout << root->data;
		preOrderTraverse(root->left);
		preOrderTraverse(root->right);
	}
}


Node* createTree(int *g,int n,int max) {
	if (n > max) {
		return NULL;
	}
	Node* p = new Node();
	if (g[n] == 0) {
		p = NULL;
	}
	else {
		p->data = g[n];
		p->left = createTree(g, 2 * n,max);
		p->right = createTree(g, 2 * n+1,max);
	}
	return p;
}
int main() {
	int t;
	cin >> t;
	while (t--) {
		int n;
		cin >> n;
		int* group = new int[n+1];
		group[0] = -1;
		for (int i = 1; i <= n; i++) {
			cin >> group[i];
		}
		int max = n;
		Node *root = createTree(group,1,max);
		preOrderTraverse(root);
		cout << endl;
	}
	return 0;
}

没有考虑递归的终止条件，导致问题

 

 

#include<iostream>
#include<stack>
#include<queue>
using namespace std;



typedef char TelemType;

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
}Node;




Node* createBinaryTree() {
	Node* p;
	TelemType ch;
	cin >> ch;
	if (ch == '0') {
		p = NULL;
	}
	else {
		p = new Node();
		p->data = ch;
		p->left = createBinaryTree();
		p->right = createBinaryTree();
	}

	return p;
}


void preOrderTraverse(Node* root) {
	if (root) {
		cout << root->data<<" ";
		preOrderTraverse(root->left);
		preOrderTraverse(root->right);
	}
}

void LevelOrder(Node* t) {
	queue<Node*> tq;
	tq.push(t);
	while (!tq.empty()) {
		t = tq.front();
		cout << t->data;
		tq.pop();
		if (t->left != NULL) {
			tq.push(t->left);
		}
		if (t->right != NULL) {
			tq.push(t->right);
		}
	}
}



int main() {
	int t;
	cin >> t;
	while (t--) {
		Node*root = createBinaryTree();
		LevelOrder(root);
		cout << endl;
	}
	return 0;
}

对队列、栈、串等数据结构的理解还欠深入

https://blog.csdn.net/Aray1234/article/details/75332661?locationNum=10&fps=1

 

 

 

huffman树：

好奇怪，程序没有任何输出，应该是基础的东西没有搞对

#include<iostream>
#include<string>
//#include<string.h>
#include<algorithm>
using namespace std;

typedef struct{
	int weight;
	int parent,lchild,rchild;
}HTNode;

int s1,s2;
void select(HTNode*HT,int num){
	s1=HT[1].weight;
	s2=HT[2].weight;
	//s1,s2,parent==0
	for(int i=1;i<=num;i++){
		if(HT[i].parent!=0)
			continue;
		else{
			int h=HT[i].weight;
			if(h>=s1&&h>=s2)
				continue;
			else if(h<s1&&h<s2){
				if(s1<=s2){
					s2=h;
				}else{
					s1=h;
				}
			}else{
				if(s1<=s2){
					s2=h;
				}else{
					s1=h;
				}
			}
		}
	}
}
void HuffmanCoding(HTNode*HT,string HC,int *w,int n){
	if(n<=1) return;
	int m=2*n-1;
	HT=new HTNode[m+1];
	for(int i=1;i<=n;i++){
		HT[i].weight=w[i-1];
		cout<<w[i-1]<<endl;
		HT[i].lchild=0;
		HT[i].rchild=0;
		HT[i].parent=0;
	}
	for(int i=n+1;i<=m;i++){
		HT[i].weight=0;
		HT[i].lchild=0;
		HT[i].rchild=0;
		HT[i].parent=0;
	}
	for(int i=n+1;i<=m;i++){
		select(HT,i-1);//s1,s2,parent==0
		HT[i].weight=HT[s1].weight+HT[s2].weight;
		cout<<HT[i].weight<<endl;
		int p1=HT[s1].weight;
		int p2=HT[s2].weight;
		if(p1<p2){
			HT[i].lchild=p1;
			HT[i].rchild=p2;
		}else{
			HT[i].lchild=p2;
			HT[i].rchild=p1;
		}
		HT[s1].parent=i;
		HT[s2].parent=i;
	}
	string cd;
	for(int i=1;i<=n;i++){
		int start =0;
		for(int j=i,f=HT[i].parent;f!=0;j=f,f=HT[f].parent){
			if(HT[j].weight==HT[f].lchild) cd[start++]='0';
			else cd[start++]='1';
		}
		reverse(cd.begin(),cd.end());
		HC.append(cd);
	}
}

int main(){
	int w[8]={5,29,7,8,14,23,3,11};
	HTNode*HT;
	string HC;
	HuffmanCoding(HT,HC,w,8);
	cout<<HC;
	return 0;
}

终于搞定，自己写代码的时候还是有一些莫名其妙的不认真的情况，一些笔误导致编译虽然没错但是就是没有正确结果，这样太不好了

#include<iostream>
#include<string>
//#include<string.h>
#include<algorithm>
using namespace std;

typedef struct {
	int weight;
	int parent, lchild, rchild;
}HTNode;

int s1, s2;
void select(HTNode*HT, int num) {
	int w1,w2;
	int key=0;
	for(int i=1;i<=num;i++){
		if(key==2){
			break;
		}
		if(HT[i].parent == 0&&key==0){
			s1=i;
			w1 = HT[i].weight;
			key++;
			continue;//没加这个，导致每一次s1,s2都相同，要是后面没有的话就不能修正 
		}
		if(HT[i].parent == 0&&key==1){
			s2=i;
			w2 = HT[i].weight;
			key++;
		}
	} 
	//s1,s2,parent==0
	for (int i = 1; i <= num; i++) {
		if (HT[i].parent != 0||i==s1||i==s2)//确保每一次都能遍历到 
			continue;
		else {
			int h = HT[i].weight;
			if (h >= w1 && h >= w2)
				continue;//有问题，最后 
			else if (h<w1&&h<w2) {
				if (w1 <= w2) {
					s2 = i;
					w2=h;
				}
				else {
					s1 = i;
					w1=h;
				}
			}
			else {
				if (w1 <= w2) {
					s2 = i;
					w2=h;
				}
				else {
					w1 = h;
					s1=i;
				}
			}
		}
	}
}
void HuffmanCoding(HTNode*HT, string*HC, int *w, int n) {
	if (n <= 1) 
		return;
	int m = 2 * n - 1;
	HT = new HTNode[m + 1];
	for (int i = 1; i <= n; i++) {
		HT[i].weight = w[i - 1];
		//cout<<w[i-1]<<endl;调试的时候要设置跳过 
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		HT[i].weight = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		select(HT, i - 1);//s1,s2,parent==0
		HT[i].weight = HT[s1].weight + HT[s2].weight;
		if (s1<s2) {
			HT[i].lchild = s1;
			HT[i].rchild = s2;
		}
		else {
			HT[i].lchild = s2;
			HT[i].rchild = s1;}
		/*int p1 = HT[s1].weight;
		int p2 = HT[s2].weight;
		if (p1<p2) {
			HT[i].lchild = s1;
			HT[i].rchild = s2;
		}
		else {
			HT[i].lchild = s2;
			HT[i].rchild = s1;
		}*/
		HT[s1].parent = i;
		HT[s2].parent = i;
	}
	
	for (int i = 1; i <= n; i++) {
		string cd;
		int start = 0;
		for (int j = i, f = HT[i].parent; f != 0; j = f, f = HT[f].parent) {
			if (j == HT[f].lchild) cd += '0';//cd[start++] = '0';导致cd一直为空 
			else cd += '1';
		}
		reverse(cd.begin(), cd.end());
		cout<<cd<<endl;
		HC[i-1]=cd;//在外面定义cd，并加上cd=NULL会报错 
	}
}

int main() {
	int w[8] = { 5,29,7,8,14,23,3,11 };
	HTNode*HT = new HTNode[9];//先分配空间再传进去 ，不然会卡崩 
	string HC[8];//HC是字符串数组 
	HuffmanCoding(HT, HC, w, 8);
	for(int i=0;i<8;i++){
		cout<<HC[i];
	}
	cout<<endl;
	cout<<"01101011101111110000111010" <<endl;
	return 0;
}

认为 select 函数还可以更加简单

#include<iostream>
#include<string>
#include<algorithm>
#include<string.h>
using namespace std;
const int Max = 10000;
typedef struct {
	int weight;
	int parent, lchild, rchild;
}HTNode;

typedef struct {
	int nn;
	char cc;
}Num;

int s1, s2;
void select(HTNode*HT, int num) {
	int w1, w2;
	w1 = Max;
	w2 = Max;
	for (int i = 1; i <= num; i++) {
		if (HT[i].parent != 0)
			continue;
		else {
			int h = HT[i].weight;
			if (h >= w1 && h >= w2)
				continue;
			else if (h<w1&&h<w2) {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					s1 = i;
					w1 = h;
				}
			}
			else {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					w1 = h;
					s1 = i;
				}
			}
		}
	}
}
void HuffmanCoding(HTNode*HT, string*HC, Num *w, int n) {
	if (n <= 1)
		return;
	int m = 2 * n - 1;
	HT = new HTNode[m + 1];
	for (int i = 1; i <= n; i++) {
		HT[i].weight = w[i - 1].nn;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		HT[i].weight = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		select(HT, i - 1);
		HT[i].weight = HT[s1].weight + HT[s2].weight;
		int p1 = HT[s1].weight;
		int p2 = HT[s2].weight;
		if (p1 <= p2) {
			HT[i].lchild = s1;
			HT[i].rchild = s2;
		}
		else {
			HT[i].lchild = s2;
			HT[i].rchild = s1;

		}
		HT[s1].parent = i;
		HT[s2].parent = i;
	}

	for (int i = 1; i <= n; i++) {
		string cd;
		int start = 0;
		for (int j = i, f = HT[i].parent; f != 0; j = f, f = HT[f].parent) {
			if (j == HT[f].lchild) cd += '0';
			else cd += '1';
		}
		reverse(cd.begin(), cd.end());
		HC[i - 1] = cd;
	}
}
void answer(string s, HTNode*HT, string*HC, Num*w, int n) {
	int b = 0;
	string mm;
	string ans;
	int m = 0;
	int max = n;
	int Smax = 0;
	for (int i = 0; i < max; i++) {
		if (HC[i].length() > Smax) {
			Smax = HC[i].length();
		}
	}
	while (n) {
		mm += s[b];
		if (mm.length() > Smax) {
			cout << "error" << endl;
			return;
		}
		for (int i = 0; i<max; i++) {
			string zz = HC[i];
			if (zz.compare(mm)==0) {//1/*mm == HC[i]*/关键在这里
				ans+= w[i].cc;
				mm = "";//string mm;不能置零，只是重定义而已
				n--;//n是否是常量判断错误
				break;
			}
		}
		b++;
	}
	cout << ans << endl;

}



int main() {
	int t;
	cin >> t;
	while (t--) {
		int l;
		cin >> l;
		Num*w = new Num[l];
		for (int i = 0; i<l; i++) {
			cin >> w[i].nn;
		}
		for (int i = 0; i<l; i++) {
			cin >> w[i].cc;
		}
		HTNode*HT = new HTNode[l + 1];
		string*HC = new string[l];

		HuffmanCoding(HT, HC, w, l);
		int k;
		cin >> k;
		while (k--) {
			string s;
			cin >> s;
			answer(s, HT, HC, w, l);
		}
	}
	return 0;
}

判断输入错的的地方有问题，自认为没有老师给的思路好，但是凭借这个发现了很多string类型的自己之前没有注意的地方，也算是值得了

 

 

#include<iostream>
#include<string>
#include<algorithm>
#include<string.h>
using namespace std;
const int Max = 10000;
typedef struct {
	int weight;
	int parent, lchild, rchild;
}HTNode;

typedef struct {
	int nn;
	char cc;
}Num;

int s1, s2;
void select(HTNode*HT, int num) {
	int w1, w2;
	w1 = Max;
	w2 = Max;
	for (int i = 1; i <= num; i++) {
		if (HT[i].parent != 0)
			continue;
		else {
			int h = HT[i].weight;
			if (h >= w1 && h >= w2)
				continue;
			else if (h<w1&&h<w2) {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					s1 = i;
					w1 = h;
				}
			}
			else {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					w1 = h;
					s1 = i;
				}
			}
		}
	}
}
void HuffmanCoding(HTNode*HT, string*HC, Num *w, int n) {
	if (n <= 1)
		return;
	int m = 2 * n - 1;
	HT = new HTNode[m + 1];
	for (int i = 1; i <= n; i++) {
		HT[i].weight = w[i - 1].nn;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		HT[i].weight = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		select(HT, i - 1);
		HT[i].weight = HT[s1].weight + HT[s2].weight;
		int p1 = HT[s1].weight;
		int p2 = HT[s2].weight;
		if (p1 <= p2) {
			HT[i].lchild = s1;
			HT[i].rchild = s2;
		}
		else {
			HT[i].lchild = s2;
			HT[i].rchild = s1;

		}
		HT[s1].parent = i;
		HT[s2].parent = i;
	}

	for (int i = 1; i <= n; i++) {
		string cd;
		int start = 0;
		for (int j = i, f = HT[i].parent; f != 0; j = f, f = HT[f].parent) {
			if (j == HT[f].lchild) cd += '0';
			else cd += '1';
		}
		reverse(cd.begin(), cd.end());
		HC[i - 1] = cd;
	}
	for (int i = 1; i <= 2 * n - 1; i++) {
		cout << HT[i].weight << " " << HT[i].rchild << " " << HT[i].lchild << endl;
	}
}

void answer(string s, HTNode*HT, string ans, Num*w, int n) {
	for (int i = 1; i <= 2 * n - 1; i++) {
		cout << HT[i].weight << " " << HT[i].rchild << " " << HT[i].lchild << endl;
	}
	cout << s << endl;

	int i, k, c;
	char ch;
	c = 2 * n - 1;
	k = 0;
	for (int i = 0; i<s.length(); i++) {
		ch = s[i];
		if (ch == '0') {
			c = HT[c].lchild;
		}
		else if (ch == '1') {
			int numm = HT[c].weight;
			c = HT[c].rchild;
		}
		else {
			cout << "error" << endl;
			return;
		}
		if (HT[c].lchild == 0 && HT[c].rchild == 0) {
			ans[k] = w[c].cc;
			k++;
			c = 2 * n - 1;
		}
		else if (i == s.length() - 1) {
			ch = '\0';//???
		}
	}
	if (ch == '\0') {
		cout << "error" << endl;
		return;
	}
	else {
		ans[k] = '\0';
	}
}


int main() {
	int t;
	cin >> t;
	while (t--) {
		int l;
		cin >> l;
		Num*w = new Num[l];
		for (int i = 0; i<l; i++) {
			cin >> w[i].nn;
		}
		for (int i = 0; i<l; i++) {
			cin >> w[i].cc;
		}
		HTNode*HT = new HTNode[l + 1];
		string*HC = new string[l];

		HuffmanCoding(HT, HC, w, l);

		for (int i = 1; i <= 2 * l - 1; i++) {
			cout << HT[i].weight << " " << HT[i].rchild << " " << HT[i].lchild << endl;
		}
		int k;
		cin >> k;
		while (k--) {
			string s;
			cin >> s;
			string ans;
			answer(s, HT, ans, w, l);
			cout << ans << endl;
		}
	}
	return 0;
}

为什么 HT数组没有传出来？在函数内赋值以后，难道它的值出函数以后就没了吗

 

 

 

#include<iostream>
#include<string>
#include<algorithm>
#include<string.h>
using namespace std;
const int Max = 10000;
typedef struct {
	int weight;
	int parent, lchild, rchild;
}HTNode;

typedef struct {
	int nn;
	char cc;
}Num;

int s1, s2;
void select(HTNode*HT, int num) {
	int w1, w2;
	w1 = Max;
	w2 = Max;
	for (int i = 1; i <= num; i++) {
		if (HT[i].parent != 0)
			continue;
		else {
			int h = HT[i].weight;
			if (h >= w1 && h >= w2)
				continue;
			else if (h<w1&&h<w2) {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					s1 = i;
					w1 = h;
				}
			}
			else {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					w1 = h;
					s1 = i;
				}
			}
		}
	}
}
HTNode* HuffmanCoding(HTNode*HT, string*HC, Num *w, int n) {
	if (n <= 1)
		return NULL;
	int m = 2 * n - 1;
	HT = new HTNode[m + 1];
	for (int i = 1; i <= n; i++) {
		HT[i].weight = w[i - 1].nn;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		HT[i].weight = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		select(HT, i - 1);
		HT[i].weight = HT[s1].weight + HT[s2].weight;
		int p1 = HT[s1].weight;
		int p2 = HT[s2].weight;
		if (p1 <= p2) {
			HT[i].lchild = s1;
			HT[i].rchild = s2;
		}
		else {
			HT[i].lchild = s2;
			HT[i].rchild = s1;

		}
		HT[s1].parent = i;
		HT[s2].parent = i;
	}

	for (int i = 1; i <= n; i++) {
		string cd;
		int start = 0;
		for (int j = i, f = HT[i].parent; f != 0; j = f, f = HT[f].parent) {
			if (j == HT[f].lchild) cd += '0';
			else cd += '1';
		}
		reverse(cd.begin(), cd.end());
		HC[i - 1] = cd;
	}
	for (int i = 1; i <= 2 * n - 1; i++) {
		cout << HT[i].weight << " " << HT[i].rchild << " " << HT[i].lchild << endl;
	}
	return HT;
}

void answer(string s, HTNode*HT, char*ans, Num*w, int n) {
	for (int i = 1; i <= 2 * n - 1; i++) {
		cout << HT[i].weight << " " << HT[i].rchild << " " << HT[i].lchild << endl;
	}
	int i, k, c;
	char ch;
	c = 2 * n - 1;
	k = 0;
	for (int i = 0; i<s.length(); i++) {
		ch = s[i];
		if (ch == '0') {
			c = HT[c].lchild;
		}
		else if (ch == '1') {
			int numm = HT[c].weight;
			c = HT[c].rchild;
		}
		else {
			cout << "error" << endl;
			return;
		}
		if (HT[c].lchild == 0 && HT[c].rchild == 0) {
			ans[k] = w[c].cc;
			cout << w[c].cc << endl;
			cout << ans[k] << endl;
			k++;
			c = 2 * n - 1;
		}
		else if (i == s.length() - 1) {
			ch = '\0';//???
		}
	}
	if (ch == '\0') {
		cout << "error" << endl;
		return;
	}
	else {
		ans[k] = '\0';
	}
}


int main() {
	int t;
	cin >> t;
	while (t--) {
		int l;
		cin >> l;
		Num*w = new Num[l];
		for (int i = 0; i<l; i++) {
			cin >> w[i].nn;
		}
		for (int i = 0; i<l; i++) {
			cin >> w[i].cc;
		}
		HTNode*HT = new HTNode[l + 1];
		string*HC = new string[l];
		HTNode* Ht = HuffmanCoding(HT, HC, w, l);
		int k;
		cin >> k;
		while (k--) {
			string s;
			cin >> s;
			char*ans = new char[l + 1];
			answer(s, Ht, ans, w, l);
			for (int i = 0; i<l; i++) {
				cout << ans[i];
			}
		}
	}
	return 0;
}

乱七八糟，自己在崩溃的边缘徘徊

 

 

#include<iostream>
#include<string>
#include<algorithm>
#include<string.h>
using namespace std;
const int Max = 10000;
typedef struct {
	int weight;
	int parent, lchild, rchild;
}HTNode;

typedef struct {
	int nn;
	char cc;
}Num;

int s1, s2;
void select(HTNode*HT, int num) {
	int w1, w2;
	w1 = Max;
	w2 = Max;
	for (int i = 1; i <= num; i++) {
		if (HT[i].parent != 0)
			continue;
		else {
			int h = HT[i].weight;
			if (h >= w1 && h >= w2)
				continue;
			else if (h<w1&&h<w2) {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					s1 = i;
					w1 = h;
				}
			}
			else {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					w1 = h;
					s1 = i;
				}
			}
		}
	}
}
void HuffmanCoding(HTNode*HT, string*HC, Num *w, int n) {
	if (n <= 1)
		return;
	int m = 2 * n - 1;
	HT = new HTNode[m + 1];
	for (int i = 1; i <= n; i++) {
		HT[i].weight = w[i - 1].nn;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		HT[i].weight = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		select(HT, i - 1);
		HT[i].weight = HT[s1].weight + HT[s2].weight;
		int p1 = HT[s1].weight;
		int p2 = HT[s2].weight;
		if (p1 <= p2) {
			HT[i].lchild = s1;
			HT[i].rchild = s2;
		}
		else {
			HT[i].lchild = s2;
			HT[i].rchild = s1;

		}
		HT[s1].parent = i;
		HT[s2].parent = i;
	}

	for (int i = 1; i <= n; i++) {
		string cd;
		int start = 0;
		for (int j = i, f = HT[i].parent; f != 0; j = f, f = HT[f].parent) {
			if (j == HT[f].lchild) cd += '0';
			else cd += '1';
		}
		reverse(cd.begin(), cd.end());
		HC[i - 1] = cd;
	}
}
void answer(string s, HTNode*HT, string*HC, Num*w, int n) {
	int b = 0;
	string mm;
	string ans;
	int m = 0;
	int max = n;
	int Smax = 0;
	for (int i = 0; i < max; i++) {
		if (HC[i].length() > Smax) {
			Smax = HC[i].length();
		}
	}
	while (1) {
		if (b == s.length()) {
			cout << "error" << endl;
			return;
		}
		mm += s[b];
		if (mm.length() > Smax) {
			cout << "error" << endl;
			return;
		}
		for (int i = 0; i<max; i++) {
			string zz = HC[i];
			if (zz.compare(mm) == 0) {//1/*mm == HC[i]*/关键在这里
				ans += w[i].cc;
				mm = "";//string mm;不能置零，只是重定义而已
				//n--;//n是否是常量判断错误
				break;
			}
		}
		b++;
	}
	cout << ans << endl;

}



int main() {
	int t;
	cin >> t;
	while (t--) {
		int l;
		cin >> l;
		Num*w = new Num[l];
		for (int i = 0; i<l; i++) {
			cin >> w[i].nn;
		}
		for (int i = 0; i<l; i++) {
			cin >> w[i].cc;
		}
		HTNode*HT = new HTNode[l + 1];
		string*HC = new string[l];

		HuffmanCoding(HT, HC, w, l);
		int k;
		cin >> k;
		while (k--) {
			string s;
			cin >> s;
			answer(s, HT, HC, w, l);
		}
	}
	return 0;
}

解密的长度不确定

 

 

 

#include<iostream>
#include<string>
#include<algorithm>
#include<string.h>
using namespace std;
const int Max = 10000;
typedef struct {
	int weight;
	int parent, lchild, rchild;
}HTNode;

typedef struct {
	int nn;
	char cc;
}Num;

int s1, s2;
void select(HTNode*HT, int num) {
	int w1, w2;
	w1 = Max;
	w2 = Max;
	for (int i = 1; i <= num; i++) {
		if (HT[i].parent != 0)
			continue;
		else {
			int h = HT[i].weight;
			if (h >= w1 && h >= w2)
				continue;
			else if (h<w1&&h<w2) {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					s1 = i;
					w1 = h;
				}
			}
			else {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					w1 = h;
					s1 = i;
				}
			}
		}
	}
}
HTNode* HuffmanCoding(HTNode*HT, string*HC, Num *w, int n) {
	if (n <= 1)
		return NULL;
	int m = 2 * n - 1;
	HT = new HTNode[m + 1];
	for (int i = 1; i <= n; i++) {
		HT[i].weight = w[i - 1].nn;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		HT[i].weight = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		select(HT, i - 1);
		HT[i].weight = HT[s1].weight + HT[s2].weight;
		int p1 = HT[s1].weight;
		int p2 = HT[s2].weight;
		if (p1 <= p2) {
			HT[i].lchild = s1;
			HT[i].rchild = s2;
		}
		else {
			HT[i].lchild = s2;
			HT[i].rchild = s1;

		}
		HT[s1].parent = i;
		HT[s2].parent = i;
	}

	for (int i = 1; i <= n; i++) {
		string cd;
		int start = 0;
		for (int j = i, f = HT[i].parent; f != 0; j = f, f = HT[f].parent) {
			if (j == HT[f].lchild) cd += '0';
			else cd += '1';
		}
		reverse(cd.begin(), cd.end());
		HC[i - 1] = cd;
	}
	return HT;
}
void answer(string s, HTNode*HT, string*HC, Num*w, int n) {
	string ans = "";
	char cm;
	int m = 2 * n - 1;
	for (int i = 0; i < s.length(); i++) {
		cm = s[i];
		if (cm == '0') {
			m = HT[m].lchild;
		}else if (cm == '1') {
			m = HT[m].rchild;
		}
		else {
			cout << "error" << endl;
			return;
		}
		if (HT[m].lchild == 0 && HT[m].rchild == 0) {
			ans += w[m-1].cc;
			m = 2 * n - 1;
		}
		else {
			cm = '\0';
		}
	}
	if (cm == '\0') {
		cout << "error" << endl;
		return;
	}
	else {
		cout << ans << endl;
	}
}



int main() {
	int t;
	cin >> t;
	while (t--) {
		int l;
		cin >> l;
		Num*w = new Num[l];
		for (int i = 0; i<l; i++) {
			cin >> w[i].nn;
		}
		for (int i = 0; i<l; i++) {
			cin >> w[i].cc;
		}
		HTNode*HT = new HTNode[l + 1];
		string*HC = new string[l];

		HTNode*Ht=HuffmanCoding(HT, HC, w, l);
		int k;
		cin >> k;
		while (k--) {
			string s;
			cin >> s;
			answer(s, Ht, HC, w, l);
		}
	}
	return 0;
}

奇奇怪怪就好了？并不是， w数组从0开始定义，你以为是从 1开始。

 

 

 

#include<iostream>
#include<string>
#include<algorithm>
#include<string.h>
using namespace std;
const int Max = 10000;

typedef char TelemType;

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
}Node;


typedef struct {
	int weight;
	int parent, lchild, rchild;
}HTNode;

int s1, s2;
void select(HTNode*HT, int num) {
	int w1, w2;
	w1 = Max;
	w2 = Max;
	for (int i = 1; i <= num; i++) {
		if (HT[i].parent != 0)
			continue;
		else {
			int h = HT[i].weight;
			if (h >= w1 && h >= w2)
				continue;
			else if (h<w1&&h<w2) {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					s1 = i;
					w1 = h;
				}
			}
			else {
				if (w1 <= w2) {
					s2 = i;
					w2 = h;
				}
				else {
					w1 = h;
					s1 = i;
				}
			}
		}
	}
}
HTNode* HuffmanCoding(HTNode*HT, string*HC, int *w, int n) {
	if (n <= 1)
		return NULL;
	int m = 2 * n - 1;
	HT = new HTNode[m + 1];
	for (int i = 1; i <= n; i++) {
		HT[i].weight = w[i - 1];
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		HT[i].weight = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
		HT[i].parent = 0;
	}
	for (int i = n + 1; i <= m; i++) {
		select(HT, i - 1);
		HT[i].weight = HT[s1].weight + HT[s2].weight;
		int p1 = HT[s1].weight;
		int p2 = HT[s2].weight;
		if (p1 <= p2) {
			HT[i].lchild = s1;
			HT[i].rchild = s2;
		}
		else {
			HT[i].lchild = s2;
			HT[i].rchild = s1;

		}
		HT[s1].parent = i;
		HT[s2].parent = i;
	}

	for (int i = 1; i <= n; i++) {
		string cd;
		int start = 0;
		for (int j = i, f = HT[i].parent; f != 0; j = f, f = HT[f].parent) {
			if (j == HT[f].lchild) cd += '0';
			else cd += '1';
		}
		reverse(cd.begin(), cd.end());
		//	cout <<w[i-1]<<"-"<<cd << endl;
		HC[i - 1] = cd;
	}
}

Node* createBinaryTree() {
	Node* p;
	TelemType ch;
	cin >> ch;
	if (ch == '0') {
		p = NULL;
	}
	else {
		p = new Node();
		p->data = ch;
		p->left = createBinaryTree();
		p->right = createBinaryTree();
	}
	return p;
}

void preOrderTraverse(Node* root) {
	if (root) {
		cout << root->data;
		preOrderTraverse(root->left);
		preOrderTraverse(root->right);
	}
}
/*
void sum(HTNode*HT, int*w, int n) {
	string ans = "";
	char cm;
	int m = 2 * n - 1;
	for (int i = 0; i < s.length(); i++) {
		cm = s[i];
		if (cm == '0') {
			m = HT[m].lchild;
		}
		else if (cm == '1') {
			m = HT[m].rchild;
		}
		else {
			cout << "error" << endl;
			return;
		}
		if (HT[m].lchild == 0 && HT[m].rchild == 0) {
			ans += w[m - 1].cc;
			m = 2 * n - 1;
		}
		else {
			cm = '\0';
		}
	}
	if (cm == '\0') {
		cout << "error" << endl;
		return;
	}
	else {
		cout << ans << endl;
	}
}*/
int Leafnum(Node*root) {//同为先序查找叶子
	if (!root) {
		return 0;
	}
	else if ((root->left == NULL && root->right == NULL)) {
		return 1;
	}
	else {
		return (Leafnum(root->left) + Leafnum(root->right));
	}
}
int Leafsum(Node*root,int*p, int*q,int*wf) {//同为先序查找叶子
	if (!root) {
		return 0;
	}
	else if ((root->left == NULL && root->right == NULL)) {
		wf[*q] = *p;
		*p = 0;
		cout<<root->data<<" ";
		return 1;
	}
	else {
		*p++;
		return (Leafsum(root->left,p,q,wf) + Leafsum(root->right, p, q, wf));
	}
}



int main() {
	int t;
	cin >> t;
	while (t--) {
		Node *root = createBinaryTree();
		preOrderTraverse(root);
		cout << endl;
		int n;
		cin >> n;
		int*w = new int[n];
		for (int i = 0; i < n; i++) {
			cin >> w[i];
		}
		HTNode*HT = new HTNode[n + 1];
		string*HC = new string[n];
		HTNode*Ht=HuffmanCoding(HT, HC, w, n);
		int lfm=Leafnum(root);
		int*wf = new int[lfm];
		memset(wf, 0, lfm);
		int pl = 0,ql = 0;
		int*p = &pl;
		int*q = &ql;
		Leafsum(root, p,q,wf);
		int sum = 0;
		for (int i = 0; i < lfm; i++) {
			sum += wf[i] * w[i];
		}
		cout << sum << endl;
	}
	return 0;
}

递归传递指针计数，算了吧还是

 

 

 

#include<iostream>
#include<string>
#include<algorithm>

using namespace std;


typedef char TelemType;

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
}Node;



Node* createBinaryTree() {
	Node* p;
	TelemType ch;
	cin >> ch;
	if (ch == '0') {
		p = NULL;
	}
	else {
		p = new Node();
		p->data = ch;
		p->left = createBinaryTree();
		p->right = createBinaryTree();
	}
	return p;
}

void preOrderTraverse(Node* root) {
	if (root) {
		cout << root->data;
		preOrderTraverse(root->left);
		preOrderTraverse(root->right);
	}
}

int Leafnum(Node*root,string* aa) {
	if (!root) {
		return 0;
	}
	else if ((root->left == NULL && root->right == NULL)) {
		*aa += root->data;
		return 1;
	}
	else {
		return (Leafnum(root->left,aa) + Leafnum(root->right,aa));
	}
}


void printLeavesDepth(Node*t, int*wf ,const string aa,size_t depth = 0 ){
	if (t == NULL) return;
	if (t->left == NULL && t->right == NULL)
	{	
		for (int i = 0; i < aa.length(); i++) {
			if (t->data == aa[i]) {
				wf[i] = depth;
			}
		}
	}
	else
	{
		printLeavesDepth(t->left,wf,aa, depth + 1);
		printLeavesDepth(t->right,wf,aa, depth + 1);
	}
}


int main() {
	int t;
	cin >> t;
	while (t--) {
		Node *root = createBinaryTree();
		preOrderTraverse(root);
		cout << endl;
		int n;
		cin >> n;
		int*w = new int[n];
		for (int i = 0; i < n; i++) {
			cin >> w[i];
		}
		string aa;
		string*dd = &aa;
		int lfm = Leafnum(root,dd);
		int*wf = new int[lfm];
		printLeavesDepth(root, wf,aa,0);
		int sum = 0;
		for (int i = 0; i < lfm; i++) {
			sum += wf[i] * w[i];
		}
		cout << sum << endl;
	}
	return 0;
}

样例过了，但是答案错误，我感觉是理解题意的问题

 

第三题比较水，但是还是挺有意思的

#include<iostream>
#include<string>
#include<algorithm>

using namespace std;
typedef char TelemType;

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
}Node;



Node* createBinaryTree() {
	Node* p;
	TelemType ch;
	cin >> ch;
	if (ch == '0') {
		p = NULL;
	}
	else {
		p = new Node();
		p->data = ch;
		p->left = createBinaryTree();
		p->right = createBinaryTree();
	}
	return p;
}


int Leafnum(Node*root,string* aa) {
	if (!root) {
		return 0;
	}
	else if ((root->left == NULL && root->right == NULL)) {
		*aa += root->data;
		return 1;
	}
	else {
		return (Leafnum(root->left,aa) + Leafnum(root->right,aa));
	}
}


void LeavesDepth(Node*t, int*wf ,const string aa,size_t depth = 0 ){
	if (t == NULL) return;
	if (t->left == NULL && t->right == NULL)
	{	
		for (int i = 0; i < aa.length(); i++) {
			if (t->data == aa[i]) {
				wf[i] = depth;
			}
		}
	}
	else
	{
		LeavesDepth(t->left,wf,aa, depth + 1);
		LeavesDepth(t->right,wf,aa, depth + 1);
	}
}


int main() {
	int t;
	cin >> t;
	while (t--) {
		Node *root = createBinaryTree();
		int n;
		cin >> n;
		int*w = new int[n];
		for (int i = 0; i < n; i++) {
			cin >> w[i];
		}
		string aa;
		string*dd = &aa;
		int lfm = Leafnum(root,dd);
		int*wf = new int[lfm];
		LeavesDepth(root, wf,aa,0);
		int sum = 0;
		for (int i = 0; i < lfm; i++) {
			sum += wf[i] * w[i];
		}
		cout << sum << endl;
	}
	return 0;
}

第四题按照第三题的思路很快就能做出来

#include<iostream>
#include<string>
#include<algorithm>

using namespace std;
typedef char TelemType;

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
}Node;



Node* createBinaryTree() {
	Node* p;
	TelemType ch;
	cin >> ch;
	if (ch == '0') {
		p = NULL;
	}
	else {
		p = new Node();
		p->data = ch;
		p->left = createBinaryTree();
		p->right = createBinaryTree();
	}
	return p;
}


int Leafnum(Node*root,string* aa) {
	if (!root) {
		return 0;
	}
	else if ((root->left == NULL && root->right == NULL)) {
		*aa += root->data;
		return 1;
	}
	else {
		return (Leafnum(root->left,aa) + Leafnum(root->right,aa));
	}
}


void LeavesDepth(Node*t, int*wf ,const string aa,size_t depth = 0 ){
	if (t == NULL) return;
	if (t->left == NULL && t->right == NULL)
	{	
		for (int i = 0; i < aa.length(); i++) {
			if (t->data == aa[i]) {
				wf[i] = depth;
			}
		}
	}
	else
	{
		LeavesDepth(t->left,wf,aa, depth + 1);
		LeavesDepth(t->right,wf,aa, depth + 1);
	}
}


int main() {
	int t;
	cin >> t;
	while (t--) {
		Node *root = createBinaryTree();
		string aa;
		string*dd = &aa;
		int lfm = Leafnum(root,dd);
		int*wf = new int[lfm];
		LeavesDepth(root, wf,aa,0);
		int max = 0;
		for (int i = 0; i < lfm; i++) {
			if (max < wf[i]) {
				max = wf[i];
			}
		}
		cout << max+1 << endl;
	}
	return 0;
}

第五题也还行，对递归和引用的掌握又深了一点

#include<iostream>
#include<string>
#include<algorithm>

using namespace std;
typedef char TelemType;

typedef struct BinaryTreeBode {
	TelemType data;
	struct BinaryTreeBode *left;
	struct BinaryTreeBode *right;
	int num;
}Node;


Node* createBinaryTree() {
	Node* p;
	TelemType ch;
	cin >> ch;
	if (ch == '0') {
		p = NULL;
	}
	else {
		p = new Node();
		p->data = ch;
		p->left = createBinaryTree();
		p->right = createBinaryTree();
	}
	return p;
}


int Nodenum(Node*root,int*h,int &q) {//求结点数
	if (!root) {
		return 0;
	}
	else if ((root->left == NULL && root->right == NULL)) {
		return 1;
	}
	else {
		return (Nodenum(root->left,h,q) + Nodenum(root->right,h,q)+root->num);
	}
}


bool sumload(Node *t, int num,int&sum)
{
	if (t == NULL)
		return false;

	if (t->num == num || sumload(t->left, num,sum) || sumload(t->right, num,sum))
	{
		sum+= t->num;   //路径上的结点标识打印出来
		return true;
	}
	return false;
}

void preOrderTraverse(Node* root,int*w,int&p) {//为什么用指针会地址混乱？
	if (root) {
		root->num = w[p];
		p++;
		preOrderTraverse(root->left,w,p);
		preOrderTraverse(root->right,w,p);
	}
}

int main() {
	int t;
	cin >> t;
	while (t--) {
		Node *root = createBinaryTree();
		//int lfm = Nodenum(root);
		//cout << lfm;
		int n;
		cin >> n;
		int*w = new int[n];//结构体不等于数组、指针，传入函数要返回。string怎么样？
		for (int i = 0; i < n; i++) {
			cin >> w[i];
		}
		int p = 0;
		preOrderTraverse(root, w, p);
		int*nsum = new int[n];
		for (int i = 0; i < n; i++) {
			int s = 0;
			sumload(root, w[i], s);
			nsum[i] = s;
		}
		int max = 0;
		for (int i = 0; i < n; i++) {
			if (max < nsum[i]) {
				max = nsum[i];
			 }
		}
		cout << max << endl;
	}
	return 0;
}

 

Phoenix0z
关注
专栏目录
java树只能有一个root_Java数据结构与算法分析 | 树
weixin_32288959的博客
02-27 220
GitHub源码分享1. 前言我们前面讲到了数组和链表两种数据结构，其各自有自己的优缺点，我们来回顾一下。数组(Array) 优点：通过下标访问速度非常快。 缺点：需要检索具体某个值时，或者插入值时(会整体移动)效率较低链表(Linked List) 优点：在插入某个值时，效率比数组高 缺点：检索某个值时效率仍然较低我们本篇讲到的树，便能提高数据的存储和读取效率。2. 树(Tree)树是一种非线性...
EXTJS 树拖拽和表格拖拽 plugins
拌面鲈鱼的博客
01-22 1218
Extjs中的树拖拽和表格拖拽
树菜单拖拽功能带拖拽特效
11-11
做窗体经常遇到将树菜单中的数据拖拽到另一控件中。该代码实现了这一功能，并且带有拖拽效果。代码简单容易理解
树型结构拖拽
晨曦的博客
08-31 1486
开发功能时恰好需要一个既可以从列表里拖拽到树,又可以树托到列表的功能,后来发现我的需求和我开发的不太一样,因为是二次开发再增加开发不太好搞,所以暂时不要了,但功能开发的还完备. 我这里是使用VueDragTreeOrg插件二次开发 要求: //main.js文件增加 //使用插件 "vuedraggable": "^2.16.0", npm insatll 安装 或yarn 安装 还有什么 stuly等什么报错 是因为版本不对 参考: "stylus": "^0.54.8", "sty..
可随意拖动(移动)节点的tree 控件树
02-04
在自定义的树中。可以实现节点的自由拖动，包含所有的源码和使用方法，适用于一些权限管理的项目。可将拖动后的节点顺序保存在数据库中.上传的为一个网站，只需在不低于Vs2005版本的开发环境上运行即可演示效果,.有意志请加QQ：190817570 以便作更多的技术交流
Python——画一棵漂亮的樱花树（不同种樱花+玫瑰+圣诞树喔）
热门推荐
碎片
10-22 56万+
最近翻到一篇知乎，上面有不少用Python（大多是turtle库）绘制的树图，感觉很漂亮，我整理了一下，挑了一些我觉得不错的代码分享给大家（这些我都测试过，确实可以生成） one 樱花树 动态生成樱花 效果图（这个是动态的）： 实现代码 import turtle as T import random import time # 画樱花的躯干(60,t) def Tree(branch, ...
HTML圣诞树代码(动态音效)
qq_63108921的博客
12-19 18万+
<!DOCTYPE html> <html lang="en" > <head> <meta charset="UTF-8"> <title>圣诞树</title> <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/normalize/5.0.0/normalize.min.css"> <...
bootstrap树形下拉框 下拉框树形菜单
11-15
Bootstrap Tree形下拉框是一种将传统的下拉菜单与树形结构结合的UI组件，它使得在有限的空间内展示层级关系的数据变得更加便捷。这种组件通常用于需要用户从一个多级分类中选择一个选项的情况，例如在组织架构、地区...
C4.5决策树算法的Python代码和数据样本
12-21
资源中包含完整的C4.5决策树算法Python代码和测试数据，其中有4个文件：C45.py是算法的实现代码，treePlotter.py是绘制决策树代码，PlayData.txt是样本数据，C45test.py用来构建、绘制并测试决策树，您可以运行该...
Ztree+treeTable实现 Java实现 树形菜单 树形表格
08-07
在Java开发中，构建用户界面时，树形菜单和树形表格是常见且重要的组件，它们可以帮助用户以层次结构的方式浏览和操作数据。本篇将详细介绍如何利用Ztree和treeTable来实现这样的功能。 Ztree是一款基于JavaScript...
基于Vue.js的可拖拽树组件
05-07
一个基于Vue.js的可拖拽可分析树级组件。兼容Chrome,Firefox,IE Edge
vue+element实现树形上下拖拽，快速提升你的前端技能
希望看完文章的你能够带着答案离开
08-23 5280
vue+element实现树形上下拖拽，快速提升你的前端技能
基于vue+element 实现两个树形tree之间的跨树拖拽
kareCat的博客
04-19 5272
<el-tree :data="data" node-key="id" default-expand-all @node-drag-start="handleDragStart" @node-drag-enter="handleDragEnter" @node-drag-leave="handleDragLeave" @node-drag-over="handleDragOver" @node-drag-end="handleDragEnd" @node-drop=
树递归技巧
hushe20202020的博客
08-16 590
递归
【el-tree】树形结构拖拽
灵活的小胖子
09-15 5224
之前做项目有遇到过使用el-tree的，但是树形结构拖拽还是第一次遇到，开始觉得会好难（心里暗示），因为考虑到好多种情况，做完之后其实还好，在此记录一下~ 首先，树形结构的拖拽--- <el-tree v-model="filterText"//过滤 class="tree" :data="projectNameOptions" node-key="id" :props="chapterProps" default-expa
树形操作1-树形拖拽选择
weixin_30662849的博客
01-09 992
树形操作数据，做个整理总结。本篇是关于树节点拖拽选择，重新生成一棵新树，并支持删除节点。demo 是基于 jquery 及 easy-ui 库实现的。 前言： demo 预览 实现功能点： 树形展示、筛选 左侧节点支持拖拽到右侧，并且重组为树形展示 右侧已选树形节点支持删除，并统计选择的子节点个数 支持默认有子节点数据 截图： 具体实现-loading: 利用 css3 实现。主要...
利用vue-draggable完成多级树形拖拽
weixin_34175509的博客
01-12 9610
长话短说：业务流程。一串json,一级数据能互相拖动，一级数据下的二级数据只能在当前一级数据的二级数据拖动，以此类推 目前demo写的是3级树形,可以拓展成N级 demo：https://powhd.github.io/treeD...源码：https://github.com/powhd/tree...觉得有帮助的话 请留下你的Star...
二叉树存储结构中 *root==NULL 跟 root==NULL的区别
qq_41668789的博客
03-11 2373
*root == NULL 跟 root == NULL的区别 左边概念意义的二叉树在使用二叉链表存储之后形成了箭头右边的图。 对每个结点，第一部分是数据域，数据域后面紧跟两个指针域，用以存放左子树根结点的地址和右子树根结点的地址。如果某棵子树是空树，那么显然也就不存在根结点，其地址就会是NULL，表示不存在这个结点。因此图中C的左子树、DEF的左子树和...
树型控件拖拽排序
weixin_34212189的博客
06-21 972
上次分享了“一个可以拖拽的异步按需加载树”，但没有实现拖拽后更新数据库，今天抽空把他实现了，这里分享下思路及关键代码。 拖拽方法入口： function onDrop(event, treeId, treeNodes, targetNode, moveType, isCopy) { if (targetNode != null) { ...
C语言绘制圣诞树的程序实现
"如何用C语言画一个‘圣诞树’" 在C语言中，绘制图形通常是通过控制字符输出来实现的，对于“圣诞树”的绘制也不例外。这个程序利用了位操作和几何形状的递归思想来生成不同的圣诞树形状。下面我们将详细解释这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值