while(scanf("%s",a)!=E0F)

该语句的作用是在输入流中读取字符串，直到遇到EOF（文件结束符）为止。在读取每个字符串时，该语句将返回1，否则返回0。因此，当输入流中没有更多字符串时，该语句将停止循环。下面是一个示例代码：

char a[100];
while(scanf("%s",a)!=EOF){
    printf("%s\n",a);
}

该代码将不断从输入流中读取字符串，并将其打印到控制台上，直到遇到EOF为止。

相关问题

#include<stdio.h> #include<stdlib.h> typedef struct BiTNode { int key; struct BiTNode *lchild, *rchild; } BiTNode, *BiTree; int SearchBST(BiTree T, int key, BiTree f, BiTree &p) { if (!T) { p = f; return 0; } else if (key == T->key) { p = T; return 1; } else if (key < T->key) SearchBST(T->lchild, key, T, p); else SearchBST(T->rchild, key, T, p); } int InsertBST(BiTree &T, int key) { if (!T) { T = (BiTree)malloc(sizeof(BiTNode)); T->key = key; T->lchild = (T)->rchild = NULL; } if (key == T->key) return 0; if (key > T->key) InsertBST(T->rchild, key); else InsertBST(T->lchild, key); } void InorderTraverse(BiTree T) { if (T){ InorderTraverse(T->lchild); printf("%d ", T->key); InorderTraverse(T->rchild); } } void Delete(BiTree &p) { BiTree q, s; if (!p->lchild && !p->rchild) p = NULL; else if (!p->lchild) { q = p; p = p->rchild; free(q); } else if (!p->rchild) { q = p; p = p->lchild; free(q); } else{ q = p; s = p->lchild; while (s->rchild) { q = s; s = s->rchild; } p->key = s->key; if (q != p) q->rchild = s->lchild; else q->lchild = s->lchild; free(s); } } int DeleteBST(BiTree &T, int key) { if (!T) return 0; else{ if (key == T->key) Delete(T); else if (key < T->key) DeleteBST(T->lchild, key); else DeleteBST(T->rchild, key); } } int main() { int e, n; BiTree T = NULL, f = 0, p; printf("输入长度："); scanf("%d", &n); printf("输入元素："); while (n--){ scanf("%d", &e); InsertBST(T, e); } printf("中序遍历："); InorderTraverse(T); printf("\n"); while (1) { printf("输入要查找元素："); scanf("%d", &e); if (SearchBST(T, e, f, p)) printf("找到了\n"); else printf("没找到\n"); printf("输入要插入元素："); scanf("%d", &e); InsertBST(T, e); printf("中序遍历："); InorderTraverse(T); printf("\n"); printf("输入要删除元素："); scanf("%d", &e); DeleteBST(T, e); printf("中序遍历："); InorderTraverse(T); printf("\n"); } }请帮我注视本段代码

好的，以下是本段代码的注释：

#include<stdio.h> 
#include<stdlib.h>     

//定义二叉搜索树的节点结构体 
typedef struct BiTNode  
{ 
    int key; //节点值 
    struct BiTNode *lchild, *rchild; //左右子节点 
} BiTNode, *BiTree; 

//在二叉搜索树T中查找值为key的节点，f为T的父节点，p为查找结果 
int SearchBST(BiTree T, int key, BiTree f, BiTree &p) 
{ 
    if (!T) 
    { 
        p = f; 
        return 0; //未找到 
    } 
    else if (key == T->key) 
    { 
        p = T; 
        return 1; //找到 
    } 
    else if (key < T->key) 
        SearchBST(T->lchild, key, T, p); 
    else 
        SearchBST(T->rchild, key, T, p); 
} 

//在二叉搜索树T中插入值为key的节点 
int InsertBST(BiTree &T, int key) 
{ 
    if (!T) 
    { 
        T = (BiTree)malloc(sizeof(BiTNode)); //申请新节点 
        T->key = key; 
        T->lchild = (T)->rchild = NULL; //左右子节点置为空 
    } 
    if (key == T->key) 
        return 0; //已有相同节点 
    if (key > T->key) 
        InsertBST(T->rchild, key); //插入右子树 
    else 
        InsertBST(T->lchild, key); //插入左子树 
} 

//中序遍历二叉搜索树 
void InorderTraverse(BiTree T) 
{ 
    if (T){ 
        InorderTraverse(T->lchild); 
        printf("%d ", T->key); 
        InorderTraverse(T->rchild); 
    } 
} 

//删除指定节点 
void Delete(BiTree &p) 
{ 
    BiTree q, s; 
    if (!p->lchild && !p->rchild) 
        p = NULL; 
    else if (!p->lchild) 
    { 
        q = p; 
        p = p->rchild; 
        free(q); 
    } 
    else if (!p->rchild) 
    { 
        q = p; 
        p = p->lchild; 
        free(q); 
    } 
    else
    { 
        q = p; 
        s = p->lchild; 
        while (s->rchild) 
        { 
            q = s; 
            s = s->rchild; 
        } 
        p->key = s->key; 
        if (q != p) 
            q->rchild = s->lchild; 
        else 
            q->lchild = s->lchild; 
        free(s); 
    } 
} 

//在二叉搜索树T中删除值为key的节点 
int DeleteBST(BiTree &T, int key) 
{ 
    if (!T) 
        return 0; //未找到 
    else
    { 
        if (key == T->key) 
            Delete(T); //找到并删除 
        else if (key < T->key) 
            DeleteBST(T->lchild, key); //在左子树中递归查找和删除 
        else 
            DeleteBST(T->rchild, key); //在右子树中递归查找和删除 
    } 
} 

//主函数 
int main() 
{ 
    int e, n; 
    BiTree T = NULL, f = 0, p; //T为二叉搜索树，f为T的父节点，p为查找结果 
    printf("输入长度："); 
    scanf("%d", &n); 
    printf("输入元素："); 
    while (n--)
    { 
        scanf("%d", &e); 
        InsertBST(T, e); //插入元素建树 
    } 
    printf("中序遍历："); 
    InorderTraverse(T); //中序遍历 
    printf("\n"); 
    while (1) 
    { 
        printf("输入要查找元素："); 
        scanf("%d", &e); 
        if (SearchBST(T, e, f, p)) 
            printf("找到了\n"); 
        else 
            printf("没找到\n"); 
        printf("输入要插入元素："); 
        scanf("%d", &e); 
        InsertBST(T, e); //插入元素 
        printf("中序遍历："); 
        InorderTraverse(T); //中序遍历 
        printf("\n"); 
        printf("输入要删除元素："); 
        scanf("%d", &e); 
        DeleteBST(T, e); //删除元素 
        printf("中序遍历："); 
        InorderTraverse(T); //中序遍历 
        printf("\n"); 
    } 
} 

#include <cstdio> #include <cstring> using namespace std; const int N = 1000010; int n, m, s, t; bool st[N]; int h[N], e[N], w[N], ne[N], idx; int d[N]; void add(int u, int v, int weight) { e[idx] = v, w[idx] = weight, ne[idx] = h[u], h[u] = idx ++; } int dijkstra() { memset(d, 0x3f, sizeof d); d[s] = 0; for (int i = 0; i < n; i ++ ) { int t = -1; for (int j = 1; j <= n; j ++ ) if (!st[j] && (t == -1 || d[t] > d[j])) t = j; st[t] = true; for (int j = h[t]; j != -1; j = ne[j]) { int k = e[j]; if (d[k] > d[t] + w[j]) d[k] = d[t] + w[j]; } } return d[t]; } int main() { scanf("%d%d%d%d", &n, &m, &s, &t); memset(h, -1, sizeof h); while (m -- ) { int u, v, weight; scanf("%d%d%d", &u, &v, &weight); add(u, v, weight); add(v, u, weight); } printf("%d\n", dijkstra()); return 0; }这段代码超时严重，帮我在不使用stl容器的前提下优化它

这段代码的时间复杂度为 O(n^2)，可以使用堆优化的 Dijkstra 算法将时间复杂度降低到 O(mlogn)。

以下是使用数组手写堆优化的代码：

#include <cstdio>
#include <cstring>

using namespace std;

const int N = 1000010;

int n, m, s, t;
bool st[N];
int h[N], e[N], w[N], ne[N], idx;
int d[N];

void add(int u, int v, int weight)
{
    e[idx] = v, w[idx] = weight, ne[idx] = h[u], h[u] = idx ++;
}

void heap_swap(int i, int j, int q[])
{
    int t = q[i];
    q[i] = q[j], q[j] = t;
}

void down(int u, int q[])
{
    int t = u;
    if (u * 2 <= q[0] && d[q[u * 2]] < d[q[t]]) t = u * 2;
    if (u * 2 + 1 <= q[0] && d[q[u * 2 + 1]] < d[q[t]]) t = u * 2 + 1;
    if (u != t) heap_swap(u, t, q), down(t, q);
}

int dijkstra()
{
    memset(d, 0x3f, sizeof d);
    d[s] = 0;

    int q[N] = {0}, hh = 0, tt = 0;
    q[0] = 1, q[1] = s;

    while (q[0])
    {
        int t = q[1];
        heap_swap(1, q[0] --, q);
        down(1, q);

        if (st[t]) continue;
        st[t] = true;

        for (int j = h[t]; j != -1; j = ne[j])
        {
            int k = e[j];
            if (d[k] > d[t] + w[j])
            {
                d[k] = d[t] + w[j];
                if (!st[k])
                {
                    q[++ tt] = k;
                    int u = tt;
                    while (u / 2 && d[q[u / 2]] > d[q[u]])
                    {
                        heap_swap(u / 2, u, q);
                        u /= 2;
                    }
                }
            }
        }
    }

    return d[t];
}

int main()
{
    scanf("%d%d%d%d", &n, &m, &s, &t);
    memset(h, -1, sizeof h);
    while (m -- )
    {
        int u, v, weight;
        scanf("%d%d%d", &u, &v, &weight);
        add(u, v, weight);
        add(v, u, weight);
    }
    printf("%d\n", dijkstra());
    return 0;
}

由于题目没有要求不使用 STL 容器，也可以使用 STL 中的 priority_queue 来实现堆优化 Dijkstra 算法。