diff --git "a/2224020102/\345\244\247\345\255\246\347\232\204\346\225\260\346\215\256\347\273\237\350\256\241.cpp" "b/2224020102/\345\244\247\345\255\246\347\232\204\346\225\260\346\215\256\347\273\237\350\256\241.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..221251e3465a1d0c3155e24767d80d726eb4a933
--- /dev/null
+++ "b/2224020102/\345\244\247\345\255\246\347\232\204\346\225\260\346\215\256\347\273\237\350\256\241.cpp"
@@ -0,0 +1,203 @@
+#include<stdio.h>
+#include<malloc.h>
+#include<string.h>
+#define MaxSons 3
+typedef char ElemType;
+typedef struct node
+{
+    ElemType data[15];     
+    struct node *sons[MaxSons];   
+}TSonNode;      
+typedef struct
+{
+    char N[15];
+    char n[15];
+}array;
+
+void ReadFile(array R[],FILE *fp,int &n)
+{
+     while((fscanf(fp,"%s",R[n].N))!=EOF&&(fscanf(fp,"%s",R[n].n))!=EOF)
+        n++;
+}
+
+TSonNode *CreateTree(char str[],array R[],int n)
+{
+    TSonNode *t;
+    int k,i=0,j=0;
+    t=(TSonNode *)malloc(sizeof(TSonNode));
+    strcpy(t->data,str);
+    for(k=0;k<MaxSons;k++)
+      t->sons[k]=NULL;
+    while(i<n)
+    {
+       if(strcmp(R[i].N,str)==0)
+       {
+           t->sons[j]=CreateTree(R[i].n,R,n);
+           j++;
+       }
+       i++;
+    }
+    return t;
+}
+
+void DispTree(TSonNode *t)
+{
+     int i=0;
+     if(t==NULL)
+        printf("此树为空树!\n");
+     else
+     {
+        printf("%s",t->data);
+        if(t->sons[i]!=NULL)    
+        {
+           printf("(");
+           for(i=0;i<MaxSons;i++)
+           {
+               DispTree(t->sons[i]);
+               if(t->sons[i+1]!=NULL)
+                  printf(",");
+               else
+                  break;
+           }
+           printf(")");
+        }
+     }
+}
+
+void DestroyTree(TSonNode *t)
+{
+    if(t==NULL)
+        printf("此树为空树!\n");
+    else
+    {
+        for(int i=0;i<MaxSons;i++)
+        {
+            if(t->sons[i]!=NULL)
+                DestroyTree(t->sons[i]);
+            else
+                break;
+        }
+        free(t);
+    }
+}
+
+TSonNode *FindNode(TSonNode *t,char str[])
+{
+    TSonNode *p;
+    if(t==NULL)
+        return NULL;
+    else
+    {
+        if(strcmp(t->data,str)==0)
+           return t;
+        else
+        {
+            for(int i=0;i<MaxSons;i++)
+            {
+                if(t->sons[i]!=NULL)
+                {
+                    p=FindNode(t->sons[i],str);
+                    if(p!=NULL)
+                      return p;
+                }
+            }
+            return NULL;
+        }
+    }
+}
+
+int ChildCount(TSonNode *p)
+{
+    int count=0;
+    for(int i=0;i<MaxSons;i++)
+    {
+        if(p->sons[i]!=NULL)
+            count++;
+        else
+            break;
+    }
+    return count;
+}
+
+int LeafCount(TSonNode *p)
+{
+    int count=0;
+    if(p==NULL)
+        return 0;
+    else
+    {
+        if(p->sons[0]==NULL)
+          count++;
+        else
+        {
+            for(int i=0;i<MaxSons;i++)
+            {
+                if(p->sons[i]!=NULL)
+                    count=count+LeafCount(p->sons[i]);
+                else
+                    break;
+            }
+        }
+    }
+    return count;
+}
+
+int LeafSumOfvalue(TSonNode *p)
+{
+    int sum=0;
+    if(p==NULL)
+        return 0;
+    else
+    {
+        if(p->sons[0]==NULL)
+           return atoi(p->data);
+        else
+        {
+            for(int i=0;i<MaxSons;i++)
+            {
+                if(p->sons[i]!=NULL)
+                   sum+=LeafSumOfvalue(p->sons[i]);
+                else
+                    break;
+            }
+        }
+    }
+    return sum;
+}
+
+#include<stdio.h>
+#include<stdlib.h>
+#include"tree.h"
+#define MaxSize 66
+int main()
+{
+    int n=0;
+    TSonNode *t;
+    array R[MaxSize];
+    FILE *fp;
+    if((fp=fopen("table.txt","r"))==NULL)      
+    {
+        printf("error!cannot open the file!");
+        exit(1);
+    }
+    printf("读取文件内容存入数组R中\n");
+    ReadFile(R,fp,n);
+    printf("输出数组R:\n");
+    for(int i=0;i<n;i++)
+        printf("%s %s\n",R[i].N,R[i].n);  
+    printf("\n由数组R创建树T,");
+    t=CreateTree(R[0].N,R,n);   
+    printf("由括号表示输出树T:\n");
+    DispTree(t);
+    char str[10];
+    printf("\n请输入学院名:");
+    scanf("%s",str);
+    printf("\n%s的专业数:%d\n",str,ChildCount(FindNode(t,str)));
+    printf("%s的班级数:%d\n",str,LeafCount(FindNode(t,str)));
+    printf("\n请输入学院名:");
+    scanf("%s",str);
+    printf("\n%s的学生数:%d\n",str,LeafSumOfvalue(FindNode(t,str)));
+    printf("销毁树!\n");
+    DestroyTree(t);
+    return 0;
+}
diff --git "a/2224020102/\345\256\236\347\216\260\344\272\214\345\217\211\346\240\221\347\232\204\345\220\204\347\247\215\345\237\272\346\234\254\350\277\220\347\256\227\347\232\204\347\256\227\346\263\225.cpp" "b/2224020102/\345\256\236\347\216\260\344\272\214\345\217\211\346\240\221\347\232\204\345\220\204\347\247\215\345\237\272\346\234\254\350\277\220\347\256\227\347\232\204\347\256\227\346\263\225.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..b3a97e17a0d61e5fbd0c10b604ecdcb27d30f7a8
--- /dev/null
+++ "b/2224020102/\345\256\236\347\216\260\344\272\214\345\217\211\346\240\221\347\232\204\345\220\204\347\247\215\345\237\272\346\234\254\350\277\220\347\256\227\347\232\204\347\256\227\346\263\225.cpp"
@@ -0,0 +1,93 @@
+#include <iostream>
+#include <malloc.h>
+using namespace std;
+#define MaxSize 50
+
+typedef struct node  
+{  
+	char data;
+    struct node *lchild;  
+    struct node *rchild;  
+}BTNode; 
+void CreateBTree(BTNode *&b,const char *str)
+{
+	BTNode *St[MaxSize],*p;
+	int top=-1,k,j=0;
+	char ch;
+	b=NULL;
+	ch=str[j];
+	while(ch!='\0')
+	{
+		switch(ch)
+		{
+			case '(':top++;St[top]=p;k=1;break;
+			case ')':top--;break;
+			case ',':k=2;break;
+			default:p=(BTNode *)malloc(sizeof(BTNode));
+			p->data=ch;
+			p->lchild=p->rchild=NULL;
+			if(b==NULL)
+				b=p;
+			else
+			{
+				switch(k)
+				{
+					case 1:St[top]->lchild=p;break;
+					case 2:St[top]->rchild=p;break;
+				}
+			}
+		}
+		j++;
+		ch=str[j];
+	}
+ } 
+ void DispBTree(BTNode *b)
+ {
+ 	if(b!=NULL)
+ 	{
+ 		printf("%c",b->data);
+ 		if(b->lchild!=NULL||b->rchild!=NULL)
+ 		{
+ 			printf("(");
+ 			DispBTree(b->lchild);
+ 			if(b->rchild!=NULL)
+ 				printf(",");
+ 			DispBTree(b->rchild);
+ 				printf(")");
+		 }
+	 }
+  } 
+ void DestroyBTree(BTNode *&b)
+ {
+ 	if(b!=NULL)
+ 	{
+ 		DestroyBTree(b->lchild);
+ 		DestroyBTree(b->rchild);
+ 		free(b);
+	 }
+  } 
+int SSonNodes(BTNode *b)
+{
+	int num1,num2,n;
+	if(b==NULL)
+		return 0;
+	else if((b->lchild==NULL&&b->rchild!=NULL)||(b->lchild!=NULL&&b->rchild==NULL))
+		n=1;
+	else
+		n=0;/
+	num1=SSonNodes(b->lchild);
+	num2=SSonNodes(b->rchild);
+	return (num1+num2+n); 
+ } 
+ int main()
+ {
+ 	BTNode *b;
+	CreateBTree(b,"A(B(D(,G)),C(E,F))");
+	cout<<"二叉树为："<<endl;
+	DispBTree(b);
+	cout<<endl;
+	cout<<"单分支结点个数为：";
+	cout<<SSonNodes(b);
+	DestroyBTree(b);
+	return 0;	
+  } 
diff --git "a/2224020102/\346\236\204\351\200\240\345\223\210\345\244\253\346\233\274\346\240\221\345\222\214\347\224\237\346\210\220\345\223\210\345\244\253\346\233\274\344\273\243\347\240\201.cpp" "b/2224020102/\346\236\204\351\200\240\345\223\210\345\244\253\346\233\274\346\240\221\345\222\214\347\224\237\346\210\220\345\223\210\345\244\253\346\233\274\344\273\243\347\240\201.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..e6bf2771c306d3fd8bab196cd16ca7498b649166
--- /dev/null
+++ "b/2224020102/\346\236\204\351\200\240\345\223\210\345\244\253\346\233\274\346\240\221\345\222\214\347\224\237\346\210\220\345\223\210\345\244\253\346\233\274\344\273\243\347\240\201.cpp"
@@ -0,0 +1,94 @@
+package 哈夫曼树;
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+
+public class HFMtree{
+
+	private HTreeNode root;
+	private HTreeNode[] nodes;
+
+	public class HTreeNode implements Comparable<HTreeNode>{
+		
+		String s;
+		int weight;
+		private HTreeNode left;
+		private HTreeNode right;
+	
+		
+		public HTreeNode(int weight){
+			this.weight = weight;
+		}
+		
+		public HTreeNode(int weight, HTreeNode left, HTreeNode right){
+			this.weight = weight;
+			this.left = left;
+			this.right = right;
+		}
+		
+		
+		public int compareTo(HTreeNode o){
+			return new Integer(this.weight).compareTo(new Integer(o.weight));
+		}
+		
+		
+	}
+
+
+	public void createHFMTree(int[] weights){ 
+		
+		Queue<HTreeNode> nodeQueue = new PriorityQueue<HTreeNode>();
+		nodes = new HTreeNode[weights.length];
+
+		for(int i=0; i<weights.length; i++){
+			nodes[i] = new HTreeNode(weights[i]);
+			nodeQueue.add(nodes[i]);
+			
+		}
+		
+		while(nodeQueue.size() > 1){
+			
+			HTreeNode left = nodeQueue.poll();
+			HTreeNode right = nodeQueue.poll();
+			
+			HTreeNode parent = new HTreeNode(left.weight + right.weight, left, right);
+			nodeQueue.add(parent);
+			
+		}
+		root = nodeQueue.poll();
+	
+	}
+	public void output(HTreeNode head){
+		if(head != null){
+			System.out.println(head.weight);
+			output(head.left);
+			output(head.right);
+		}
+	}
+	public void encode(HTreeNode node, String s){
+		if(node != null){
+			node.s = s;
+			encode(node.left, node.s+"0");
+			encode(node.right, node.s+"1");
+		}
+	}
+	public void printTreeCode(String[] sa, int[] weights){
+		for(int i=0; i<weights.length; i++){
+			System.out.println(sa[i] +":" + nodes[i].s);
+		}
+	} 
+	public static void main(String[] args) {
+		
+		int[] weights = new int[]{7, 8, 2, 1, 1};
+		String[] sa = new String[]{"a","b","c","d","e",};
+		
+		HFMtree huffmanTree = new HFMtree();
+	    huffmanTree.createHFMTree(weights);
+	    huffmanTree.output(huffmanTree.root);
+	    huffmanTree.encode(huffmanTree.root, "0");
+	    huffmanTree.printTreeCode(sa, weights);
+	}
+}
+
+
diff --git "a/2224020102/\346\261\202\344\272\214\345\217\211\346\240\221\344\270\255\344\273\216\346\240\271\347\273\223\347\202\271\345\210\260\346\240\221\345\217\266\347\273\223\347\202\271\347\232\204\350\267\257\345\276\204.cpp" "b/2224020102/\346\261\202\344\272\214\345\217\211\346\240\221\344\270\255\344\273\216\346\240\271\347\273\223\347\202\271\345\210\260\346\240\221\345\217\266\347\273\223\347\202\271\347\232\204\350\267\257\345\276\204.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..0c984aa3f29f7d86615f38dfb62d359c053f6b94
--- /dev/null
+++ "b/2224020102/\346\261\202\344\272\214\345\217\211\346\240\221\344\270\255\344\273\216\346\240\271\347\273\223\347\202\271\345\210\260\346\240\221\345\217\266\347\273\223\347\202\271\347\232\204\350\267\257\345\276\204.cpp"
@@ -0,0 +1,27 @@
+class solution {
+    private ArrayList<ArrayList<Integer>> pathList;
+    private LinkedList<Integer> path;
+
+    public void test(TreeNode root) {
+        pathList = new ArrayList<>();
+        path = new LinkedList<>();
+        recurision(root);
+    }
+
+    public void recurision(TreeNode node) {
+        path.add(node.val);
+        if (node.left == null && node.right == null) {
+            pathList.add(new ArrayList<>(path));
+            return;
+        }
+        if (node.left != null) {
+            recurision(node.left);
+            path.removeLast(); 
+        }
+
+        if (node.right != null) {
+            recurision(node.right);
+            path.removeLast(); 
+        }
+    }
+}
\ No newline at end of file