这周进行了数据结构的第一阶段。

完成了二叉排序树的查找：

int SearchBST(BSTNode *bt,KeyType k)
{
 
    if(bt==NULL)
    {
        return 0;
    }
    else if(bt->key==k)
    {
        printf("%d ",bt->key);
        return 1;
    }
    else if(bt->key>k)
    { 
        printf("%d ",bt->key);
        return SearchBST(bt->lchild,k);
    }
    else if(bt->key<k)
    {
        printf("%d ",bt->key);
        return SearchBST(bt->rchild,k);
    }
}

还有prime算法的代码实现，之前在学校学习时，只会在草稿纸上画一画，只能理解，并不能实现，这次小学期，通过查询相关资料整了出来

import java.util.Scanner;

public class Main {

    //用来初始化数组的，比结点数大就行
    private static final int MAXN = 1000;
    //INF表示不存在边的长度，用一个很大的数表示它
    private static final int INF = 100000001;

    public static void main(String[] args) {

        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        //邻接矩阵
        int[][] w = new int[MAXN][MAXN];
        //存放父结点的集合
        int[] f = new int[MAXN];
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                int t = s.nextInt();
                w[i][j] = t;
                w[j][i] = t;
            }
        }

        int x = s.nextInt();

        for (int i = 0; i < x; i++) {
            int star = s.nextInt();
            int end = s.nextInt();
            w[star][end] = -1;
            w[end][star] = -1;
        }

        /*for (int i = 1;i <= n;i++){
            for (int j = 1; j <= n;j++){
                System.out.print(w[i][j]+" ");
            }
            System.out.println();
        }*/

        //生成最小生成树
        toPrim(w, f, n);
        int result = 0;
        for(int i = 2; i <= n; i++) {
            //result += w[i-1][f[i]-1];
            if(w[i][f[i]] == -1){
                result += w[i][f[i]] + 1;
                continue;
            }
            result += w[i][f[i]];
        }
        System.out.println(result);
    }

    private static void toPrim(int w[][], int f[], int n) {
        //用于存放结点的权值的集合
        int d[] = new int[MAXN];
        int k = 0;
        int m;

        //第一个结点与其它结点的权值加入集合中
        for(int j = 1; j <= n; j++) {
            d[j] = (j == 1 ? 0 : w[1][j]);
            //第一个结点没有父结点，初始化为1
            f[j] = 1;
        }
        //从第二个结点开始
        for(int i = 2; i <= n; i++) {
            m = INF;
            //遍历与当前结点相连接的各个结点的权值并找出具有最小权值的结点
            for(int j = 1; j <= n; j++) {
                if(d[j] <= m && d[j] != 0) {
                    m = d[j];
                    k = j;
                }
            }
            //将上面找到的结点加入到集合中
            d[k] = 0;
            //更新父d[]，将k结点与其它结点连接的最小权值放进d[j]中
            for(int j = 1; j <= n; j++) {
                if(d[j] > w[k][j] && d[j] != 0) {
                    d[j] = w[k][j];
                    f[j] = k;
                    //System.out.println(d[j]);
                }
            }
            //System.out.println(d.length);
        }
    }
}

通过完成这一阶段的任务，我深深体会到了算法的重要性，也体会到了算法的难学，数据结构上学期学完之后自己就没有在复习过，平常写系统的时候一般也不会用到算法，所以相当于半年没有碰算法，在做题目的时候，很多算法知识都忘记了，甚至不知道它的核心思想，更不要说写代码了。在做题目的过程中，我使用了C++和vs2022作为我的工具，vs2022对于一些代码的书写有规定，对于scanf需要写成s_scanf,这些让人很不适应。写完代码之后，我发现c++中数组和结构体的使用频率较高，所以要充分认识数组下标和其值得对应关系。

题目写完之后，我充分认识到了自己的不足，同时，自己对于算法的重视程度也不够，在即将到来的暑假我应该对算法进行复习，同时也为自己做好规划，充分使用算法网站，弥补自己的不足，提升自己的能力。