PTA(中国人民解放军陆军工程大学数据结构，C语言）

7-1 数组循环左移

本题要求实现一个对数组进行循环左移的简单函数：一个数组a中存有n（>）个整数，在不允许使用另外数组的前提下，将每个整数循环向左移m（≥）个位置，即将a中的数据由（a​0​​a​1​​⋯a​n−1​​）变换为（a​m​​⋯a​n−1​​a​0​​a​1​​⋯a​m−1​​）（最前面的m个数循环移至最后面的m个位置）。如果还需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入格式:

输入第1行给出正整数n（≤）和整数m（≥）；第2行给出n个整数，其间以空格分隔。

输出格式:

在一行中输出循环左移m位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

输入样例：

8 3

1 2 3 4 5 6 7 8

输出样例：

4 5 6 7 8 1 2 3

#include <stdio.h>
#define N 100
int main()
{
    int i, n, k, arr[N] = {0}; 
    scanf("%d%d",&n,&k);
    /* 输入数组 */
    for(int i=0; i<n; ++i){
        scanf("%d,",&arr[i]);        
    }  
    /* 输出 */
    for(i=0; i<n-1; ++i){
        printf("%d ",arr[(i+k)%n]);
    } 
    printf("%d",arr[(i+k)%n]);
    return 0;
}

7-2 装箱问题

假设有N项物品，大小分别为s​1​​、s​2​​、…、s​i​​、…、s​N​​，其中s​i​​为满足1的整数。要把这些物品装入到容量为100的一批箱子（序号1-N）中。装箱方法是：对每项物品, 顺序扫描箱子，把该物品放入足以能够容下它的第一个箱子中。请写一个程序模拟这种装箱过程，并输出每个物品所在的箱子序号，以及放置全部物品所需的箱子数目。

输入格式：

输入第一行给出物品个数N（≤）；第二行给出N个正整数s​i​​（1，表示第i项物品的大小）。

输出格式：

按照输入顺序输出每个物品的大小及其所在的箱子序号，每个物品占1行，最后一行输出所需的箱子数目。

输入样例：

8

60 70 80 90 30 40 10 20

输出样例：

60 1

70 2

80 3

90 4

30 1

40 5

10 1

20 2

5

#include <stdio.h>
#define N 1000
struct node{
    int c;
    int cnt;
};
int main()
{
    struct node a[N];
    int n, capacity = 100, count = 1;
    scanf("%d", &n);
    for(int i=0; i<n; ++i){
        scanf("%d",&a[i].c);
        a[i].cnt = 0;
    }
    for(int i= 0; i<n; ++i)
    {
        if(a[i].cnt) continue;
        int sum = a[i].c;
        a[i].cnt = count;
        for(int j=i+1; j<n; ++j){
            if(!a[j].cnt && sum+a[j].c <= capacity){
                sum += a[j].c;
                a[j].cnt = count;
            }        
        }
        count++;
    }
    for(int i=0; i<n; ++i){
        printf("%d %d\n", a[i].c, a[i].cnt);
    }
    printf("%d\n", count-1);    
    return 0;
}

7-3 两个有序序列的中位数

已知有两个等长的非降序序列S1, S2, 设计函数求S1与S2并集的中位数。有序序列,的中位数指A​(N−1)/2​​的值,即第⌊个数（A​0​​为第1个数）。

输入格式:

输入分三行。第一行给出序列的公共长度N（0<N≤100000），随后每行输入一个序列的信息，即N个非降序排列的整数。数字用空格间隔。

输出格式:

在一行中输出两个输入序列的并集序列的中位数。

输入样例1:

5

1 3 5 7 9

2 3 4 5 6

输出样例1:

4

输入样例2:

6

-100 -10 1 1 1 1

-50 0 2 3 4 5

输出样例2:

1

/* 算法1
3个静态数组, 2个序列全部并入第3个序列 */
#include <stdio.h>
#define N 100000

int main()
{
    int a1[N], a2[N], c[2*N], cnt1=0, cnt2=0, cnt=0;
    int n;
    scanf("%d",&n);
    for(int i=0; i<n; ++i)
        scanf("%d",&a1[i]);
    for(int i=0; i<n; ++i)
        scanf("%d",&a2[i]);
    for(int i=0; cnt1<n && cnt2<n; ++i)
    {
        if(a1[cnt1]<=a2[cnt2]){
            c[cnt++] = a1[cnt1++];
        }
        else{
            c[cnt++] = a2[cnt2++];
        }
    }
    while(cnt1<n) c[cnt++] = a1[cnt1++];
    while(cnt2<n) c[cnt++] = a2[cnt2++];
    printf("%d\n", c[(2*n-1)/2]);    
    return 0;
}

/*算法2
三个动态数组, 2个序列并入第3个序列n个元素 
 */
#include <stdio.h>
#include <malloc.h>
int main()
{
    int* a1, *a2, *c;
    int cnt1=0, cnt2=0, cnt=0;
    int n;
    scanf("%d",&n);
    a1 = (int*)malloc(sizeof(int)*n);
    a2 = (int*)malloc(sizeof(int)*n);
    c = (int*)malloc(sizeof(int)*n);
    
    for(int i=0; i<n; ++i)
        scanf("%d",&a1[i]);
    for(int i=0; i<n; ++i)
        scanf("%d",&a2[i]);
    
    for(int i=0; i<n; ++i)
    {
        if(a1[cnt1]<=a2[cnt2]){
            c[cnt++] = a1[cnt1++];
        }
        else{
            c[cnt++] = a2[cnt2++];
        }
    }    
    
    printf("%d\n", c[n-1]);    
    return 0;
}

/*算法3
二个动态数组, 2个序列并入第3个序列n个元素 
 */
#include <stdio.h>
#include <malloc.h>
int main()
{
    int* a, *c;
    int cnt1=0, cnt2=0;
    int n;
    scanf("%d",&n);
    a = (int*)malloc(sizeof(int)*n*2);
    c = (int*)malloc(sizeof(int)*n);
    
    for(int i=0; i<n*2; ++i)
        scanf("%d",&a[i]);
    
    for(int i=0; i<n; ++i)
    {
        if(a[cnt1]<=a[n+cnt2]){
            c[i] = a[cnt1++];
        }
        else{
            c[i] = a[n+cnt2++];
        }
    }    
    
    printf("%d\n", c[n-1]);    
    return 0;
}

/* 算法4
2个动态数组, 不并, 通过下标计算中位数
 */
#include <stdio.h>
#include <malloc.h>
int main()
{
    int* a1, *a2;
    int cnt1=0, cnt2=0;    
    int n;
    scanf("%d",&n);
    a1 = (int*)malloc(sizeof(int)*n);
    a2 = (int*)malloc(sizeof(int)*n);
    
    for(int i=0; i<n; ++i)
        scanf("%d",&a1[i]);
    for(int i=0; i<n; ++i)
        scanf("%d",&a2[i]);
    
    while(cnt1+cnt2<(2*n-1)/2)
    {
        if(a1[cnt1]<=a2[cnt2]){
            cnt1++;
        }
        else{
            cnt2++;
        }
    }    
    printf("%d\n", a1[cnt1]>a2[cnt2]?a2[cnt2]:a1[cnt1]);    
    return 0;
}

7-4 求链式线性表的倒数第K项 

给定一系列正整数，请设计一个尽可能高效的算法，查找倒数第K个位置上的数字。

输入格式:

输入首先给出一个正整数K，随后是若干正整数，最后以一个负整数表示结尾（该负数不算在序列内，不要处理）。

输出格式:

输出倒数第K个位置上的数据。如果这个位置不存在，输出错误信息NULL。

输入样例:

4 1 2 3 4 5 6 7 8 9 0 -1 

输出样例:

7

#include <stdio.h>
#include <malloc.h>

struct Node {
    int number;
    struct Node* next;
};

int main()
{    
    int k;
    scanf("%d",&k);
    
    struct Node *p = NULL, *t = NULL; //p新结点, t当前结点
    int x;
    scanf("%d", &x);
    while(x >= 0)
    {        
        p = (struct Node*)malloc(sizeof(struct Node));
        p->number = x;
        p->next = NULL;    
       
        p->next = t, t = p;//头部插入\更新当前t            
        scanf("%d",&x);
    }
    
    while(--k && p)
    {
        p = p->next;
    }
    
    if(p == NULL)
        printf("NULL\n");
    else
        printf("%d\n", p->number);
    
    return 0;
}

7-5 两个有序链表序列的交集 

已知两个非降序链表序列S1与S2，设计函数构造出S1与S2的交集新链表S3。

输入格式:

输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−表示序列的结尾（−不属于这个序列）。数字用空格间隔。

输出格式:

在一行中输出两个输入序列的交集序列，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NULL。

输入样例:

1 2 5 -1
2 4 5 8 10 -1

输出样例:

2 5

#include <stdio.h>
#include <malloc.h>

struct Node {
    int number;
    struct Node* next;
};

struct Node* CreatLinkList()
{
    struct Node *h = NULL, *r = NULL, *p = NULL; 
    int x, flag = 1;
    while(scanf("%d", &x) && x >=0)
    {        
        p = (struct Node*)malloc(sizeof(struct Node));
        p->number = x;
        p->next = NULL;    
        if(flag) h = r = p;
        else r->next = p, r = p;//尾插
        flag = 0;
    }
    return h; 
}

int main()
{  
    int flag = 1;
    struct Node *s1, *s2;
    s1 = CreatLinkList(), s2 = CreatLinkList();
    
    while(s1 && s2)
    {
        if(s1->number > s2->number)
            s2 = s2->next;            
        else if(s1->number < s2->number)
            s1 = s1->next;
        else{                             
            if(!flag)
                printf(" ");
            printf("%d", s1->number);    
            s1 = s1->next;
            s2 = s2->next;
            flag = 0;
        }        
    }
    
    if(flag) printf("NULL\n");
    
    return 0;
}

7-6 符号配对

请编写程序检查C语言源程序中下列符号是否配对：/*与*/、(与)、[与]、{与}。

输入格式:

输入为一个C语言源程序。当读到某一行中只有一个句点.和一个回车的时候，标志着输入结束。程序中需要检查配对的符号不超过100个。

输出格式:

首先，如果所有符号配对正确，则在第一行中输出YES，否则输出NO。然后在第二行中指出第一个不配对的符号：如果缺少左符号，则输出?-右符号；如果缺少右符号，则输出左符号-?。

输入样例1：

void test()
{
    int i, A[10];
    for (i=0; i<10; i++) /*/
        A[i] = i;
}
.

输出样例1：

NO

/*-?

输入样例2：

void test()
{
    int i, A[10];
    for (i=0; i<10; i++) /**/
        A[i] = i;
}]
.

输出样例2：

NO

?-]

输入样例3：

void test()
{
    int i
    double A[10];
    for (i=0; i<10; i++) /**/
        A[i] = 0.1*i;
}
.

输出样例3：

YES

#include <stdio.h>
#define N 100

void printLeft(char ch) {//左字符打印
    if(ch == '<') printf("NO\n/*-?\n");
    else printf("NO\n%c-?\n", ch);
}

void printRight(char ch) {//右字符打印
    if(ch == '<') printf("NO\n?-*/\n");    
    else  printf("NO\n?-%c\n",ch);
}

int charMatch(char ch1,char ch2)//字符匹配
{    
    return ch1=='(' && ch2==')' 
            || ch1=='[' && ch2==']'
            ||ch1=='{' && ch2=='}'
            ||ch1 == ch2;    
}

int MatchOrPrint(char ch1, int* top, int flag, char ch2)
{
    if(*top != -1 && charMatch(ch1,ch2)){
        (*top)--;  //栈有字符且匹配出栈
    }     
    else //栈无字符或不匹配
    {                    
        flag = 0; //栈无字符或不匹配
        if(*top == -1) {//1.栈无字符(缺左打右)
            printRight(ch2);
        }
        else { //2.栈有字符(缺右打左)
            printLeft(ch1);
        }
    }
    return flag;
}

int main() 
{
    char str[10*N];//字符串
    char stack[N]; //栈
    int i, top = -1, flag = 1;//flag匹配标志

    while(gets(str) && str[0] != '.')//按行读入
    {        
        for( i = 0; str[i]; i++) //逐行处理 
        {   
            if(str[i] == '(' || str[i] == '[' || str[i] == '{') 
            {
                stack[++top] = str[i]; //左符号入栈
            }
            else if(str[i] == '/' && str[i + 1] == '*') 
            {
                stack[++top] = '<'; //左符号入栈
                i++;
            }            
            else if(str[i] == '*' && str[i + 1] == '/') 
            {                  
                flag = MatchOrPrint(stack[top], &top, flag, '<');
                i++; // 处理右*/避免'/'再次处理, for循环再次++
            }
            else if(str[i] == ')'||str[i] == ']'||str[i] == '}')
            {   //处理右 ')', ']', '}'
                flag = MatchOrPrint(stack[top], &top, flag, str[i]);
            }
            if(flag == 0) break;//栈无字符或不匹配
        }
        if(flag == 0) break; //栈无字符或不匹配
    }
    
    if(flag && top == -1) printf("YES\n");//栈空且左右匹配
    else if(flag) { //即使左右匹配栈不空(缺右打左)
        printLeft(stack[top]);
    } 
    return 0;
}

7-7 整型关键字的散列映射

给定一系列整型关键字和素数P，用除留余数法定义的散列函数将关键字映射到长度为P的散列表中。用线性探测法解决冲突。

输入格式:

输入第一行首先给出两个正整数N（≤）和P（≥的最小素数），分别为待插入的关键字总数、以及散列表的长度。第二行给出N个整型关键字。数字间以空格分隔。

输出格式:

在一行内输出每个整型关键字在散列表中的位置。数字间以空格分隔，但行末尾不得有多余空格。

输入样例:

4 5

24 15 61 88

输出样例:

4 0 1 3

#include <stdio.h>
#include <malloc.h>
int main() 
{
    int n, p;
    scanf( "%d%d", &n, &p );
    int* table = (int*)calloc(p, sizeof(int)); //散列表    
    int x;
    for( int i = 0; i < n; i++ ) 
    {
        scanf( "%d", &x );     
        int index = x % p;
        while( table[index] ){    
            if(table[index] == x)//重复数字
                break;
           index = (index+1)%p;            
        }
        table[index] = x;//在散列表的index位置记录x      
        if( i == 0 ) printf( "%d", index );
        else printf( " %d", index );
    } 
    return 0;
}

7-8 树的遍历

给定一棵二叉树的后序遍历和中序遍历，请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其后序遍历序列。第三行给出其中序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

7

2 3 1 5 7 6 4

1 2 3 4 5 6 7

输出样例：

4 1 6 3 5 7 2

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <malloc.h>
#define ERROR -1
#define N 31

/* 二叉树结点 */
typedef struct TreeNode *BinTree;
struct TreeNode{
    int Data;
    BinTree Left;
    BinTree Right;
};

/* 创建树结点 */
BinTree NewNode( int V )
{ 
    BinTree T = (BinTree)malloc(sizeof(struct TreeNode));
    T->Data = V;
    T->Left = T->Right = NULL;
    return T;
}

/* 建树 */
BinTree  BuildTree(int a[],int b[],int i,int j,int s,int e) 
{   /* i,j树的后序序列的起止, s,e树的中序序列的起止 */
    int k; 
    BinTree p;
    if( i > j )    return NULL;//递归终止
    
    p = NewNode(a[j]); //后序的根a[j]创建结点
    
    k = s;  /* 寻找树根位置 */
    while( ( k <= e ) && ( b[k] != a[j] ) )    k++; 
    
    if( k > e )    exit(ERROR); 
    
    p->Left  = BuildTree(a, b, i, i+(k-s)-1, s, k-1); /* 左子树 */   
    p->Right = BuildTree(a, b, i+(k-s), j-1, k+1, e); /* 右子树 */    
    return p;
}

/* 顺序循环队列*/
typedef struct QNode *Queue; /* 队列指针 */
struct QNode {
    BinTree* Data;     /* 存储元素的数组 */
    int Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};

 /* 建队列 */
Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (BinTree*)malloc(MaxSize * sizeof(BinTree));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

/* 队满 */
bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

/* 队空 */
bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}

/* 入队 */
bool AddQ( Queue Q, BinTree X )
{
    if ( IsFull(Q) ) {
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return true;
    }
}

/* 出队 */
BinTree DeleteQ( Queue Q )
{    
    if ( IsEmpty(Q) )
        return NULL;
    Q->Front =(Q->Front+1)%Q->MaxSize;
    return  Q->Data[Q->Front];   
}

/* 层序遍历 */
void LevelorderTraversal ( BinTree BT )
{ 
    Queue Q; 
    BinTree T;
 
    if ( !BT ) return; /* 若是空树则直接返回 */
     
    Q = CreateQueue(N); /* 创建空队列Q */
    AddQ( Q, BT ); /* 树根入队 */
    
    int flag = 0;  /* 控制输出空格 */
    
    while ( !IsEmpty(Q) ) 
    {
        T = DeleteQ( Q );
        if(flag) printf(" ");
        flag = 1;
        printf("%d", T->Data); /* 访问取出队列的结点 */
        if ( T->Left )   AddQ( Q, T->Left );  /* 左子树入队 */
        if ( T->Right )  AddQ( Q, T->Right ); /* 右子树入队 */
    }
}
int main()
{    
    int a[N] = {0}, b[N] = {0};
    int n;
    scanf("%d", &n);
    /* 输入树的后序遍历\中序遍历序列 */
    for(int i=0; i<n; ++i)
    {
        scanf("%d", &a[i]);
    }
    for(int i=0; i<n; ++i)
    {
        scanf("%d", &b[i]);
    }
    /* 恢复树 */
    BinTree root = BuildTree(a, b , 0, n-1 , 0,  n-1); 
    /* 层序遍历输出 */
    LevelorderTraversal(root);
    
    return 0; 
}

7-9 根据后序和中序遍历输出先序遍历

本题要求根据给定的一棵二叉树的后序遍历和中序遍历结果，输出该树的先序遍历结果。

输入格式:

第一行给出正整数N(≤30)，是树中结点的个数。随后两行，每行给出N个整数，分别对应后序遍历和中序遍历结果，数字间以空格分隔。题目保证输入正确对应一棵二叉树。

输出格式:

在一行中输出Preorder:以及该树的先序遍历结果。数字间有1个空格，行末不得有多余空格。

输入样例:

7

2 3 1 5 7 6 4

1 2 3 4 5 6 7

输出样例:

Preorder: 4 1 3 2 6 5 7

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <malloc.h>
#define ERROR -1
#define N 31

/* 二叉树结点 */
typedef struct TreeNode *BinTree;
struct TreeNode{
    int Data;
    BinTree Left;
    BinTree Right;
};

typedef BinTree Stack; /* 栈类型 */

/* 创建树结点 */
BinTree NewNode( int V )
{ 
    BinTree T = (BinTree)malloc(sizeof(struct TreeNode));
    T->Data = V;
    T->Left = T->Right = NULL;
    return T;
}

/* 建树 */
BinTree  BuildTree(int a[],int b[],int i,int j,int s,int e) 
{   /* i,j树的后序序列的起止, s,e树的中序序列的起止 */
    int k; 
    BinTree p;
    if( i > j )    return NULL;//递归终止
    
    p = NewNode(a[j]); //后序的根a[j]创建结点
    
    k = s;  /* 寻找树根位置 */
    while( ( k <= e ) && ( b[k] != a[j] ) )    k++; 
    
    if( k > e )    exit(ERROR); 
    
    p->Left  = BuildTree(a, b, i, i+(k-s)-1, s, k-1); /* 左子树 */   
    p->Right = BuildTree(a, b, i+(k-s), j-1, k+1, e); /* 右子树 */    
    return p;
}

/* 非递归先序遍历 */
void PreorderTraversal( BinTree BT )
{ 
    BinTree T = BT;
    Stack S[N]; /* 建栈 */
    int top = -1;
    while( T || top != -1 )/* 树不空或栈不空 */
    {
        while(T)/*一直向左并将沿途结点压入堆栈*/
        { 
            S[++top] = T;  /* 结点压栈(第一次遇到结点) */
            printf(" %d", T->Data); /*（访问）打印结点*/
            T = T->Left;/* 一直向左 */
        }
        if(top != -1) /* 栈不空 */
        {
            T = S[top--];  /*结点弹出堆栈(第二次遇到结点)*/            
            T = T->Right;/*转向右子树*/
        }
    }
}

int main()
{    
    int a[N] = {0}, b[N] = {0};
    int n;
    scanf("%d", &n);
    /* 输入树的后序遍历\中序遍历序列 */
    for(int i=0; i<n; ++i)
    {
        scanf("%d", &a[i]);
    }
    for(int i=0; i<n; ++i)
    {
        scanf("%d", &b[i]);
    }
    /* 恢复树 */
    BinTree root = BuildTree(a, b , 0, n-1 , 0,  n-1); 
    /* 先序遍历输出 */
    printf("Preorder:");
    PreorderTraversal(root);
    
    return 0; 
}

7-10 是否完全二叉搜索树

将一系列给定数字顺序插入一个初始为空的二叉搜索树（定义为左子树键值大，右子树键值小），你需要判断最后的树是否一棵完全二叉树，并且给出其层序遍历的结果。

输入格式：

输入第一行给出一个不超过20的正整数N；第二行给出N个互不相同的正整数，其间以空格分隔。

输出格式：

将输入的N个正整数顺序插入一个初始为空的二叉搜索树。在第一行中输出结果树的层序遍历结果，数字间以1个空格分隔，行的首尾不得有多余空格。第二行输出YES，如果该树是完全二叉树；否则输出NO。

输入样例1：

9

38 45 42 24 58 30 67 12 51

输出样例1：

38 45 24 58 42 30 12 67 51

YES

输入样例2：

8

38 24 12 45 58 67 42 51

输出样例2：

38 45 24 58 42 12 67 51

NO

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

/* 树结点 */
typedef struct TreeNode *BinTree;
typedef struct TreeNode TreeNode;
struct TreeNode{
    int Data, ID;
    BinTree Left;
    BinTree Right;
};

/* 顺序循环队列*/
#define MAXSIZE  21 //最大队列长度 N 
typedef struct QNode *Queue; 
struct QNode {
    BinTree* Data;    /* 存储元素的数组 */
    int Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;      /* 队列最大容量 */
};

BinTree Insert( BinTree BST, int X );     /* 插入 */
void LevelorderTraversal ( BinTree BT );  /* 层次遍历 */
Queue CreateQueue( );                /*  建队 */
bool IsFull( Queue Q );              /* 队满 */
bool IsEmpty( Queue Q );             /* 队空 */
bool AddQ( Queue Q, BinTree X );     /* 入队 */
BinTree DeleteQ( Queue Q );             /* 出队 */

int main()
{
    int N, i, X;   
    scanf("%d", &N);
    
    BinTree BST = NULL;
    for ( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Insert(BST, X);
    }
    LevelorderTraversal(BST);
    return 0;
}

BinTree Insert( BinTree BST, int X )
{
    if(!BST)
    {  
        BST = (BinTree)malloc(sizeof(TreeNode));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }
    else
    {
        if(X > BST->Data)
            BST->Left = Insert(BST->Left,X);
        else if(BST->Data > X)
            BST->Right = Insert(BST->Right,X);
    }
    return BST; 
}

void LevelorderTraversal ( BinTree BT )
{ 
    Queue Q; 
    BinTree T;
    
    bool flag = true, ans = true;
    int order = 0; /* 顺序 */
    
    if ( !BT ) return; /* 若是空树则直接返回 */
    
    Q = CreateQueue(); /* 创建空队列Q */ 
    
    
    AddQ( Q, BT ); /* 树根入队 */
    BT->ID = 1;
    
    while ( !IsEmpty(Q) ) 
    {
        T = DeleteQ( Q ); /* 出队 */
        order++;
        
        if(T->ID != order)
            ans = false; /* 顺序不同 */
        if(flag)  /* 输出格式 */
        {
            printf("%d", T->Data);
            flag = false;
        }
        else printf(" %d", T->Data);
              
        if ( T->Left ){
            T->Left->ID = 2 * T->ID;  /* 左儿子顺序 */
            AddQ( Q, T->Left );       /* 左儿子入队 */
        }   
        if ( T->Right ){
            T->Right->ID = 2 * T->ID + 1;/* 右儿子顺序 */
            AddQ( Q, T->Right );         /* 右儿子入队 */
        }  
    }
    
    if(ans)  /* 顺序相同 */
        printf("\nYES");
    else
        printf("\nNO"); 
}

 /* 建队列 */
Queue CreateQueue( )//返回队列指针
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (BinTree*)malloc(MAXSIZE * sizeof(BinTree));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MAXSIZE;
    return Q;
}

/* 队满 */
bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

/* 队空 */
bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}

/* 入队 */
bool AddQ( Queue Q, BinTree X )
{
    if ( IsFull(Q) ) {
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return true;
    }
}

/* 出队 */
BinTree DeleteQ( Queue Q )
{    
    if ( IsEmpty(Q) )
        return NULL;
    Q->Front =(Q->Front+1)%Q->MaxSize;
    return  Q->Data[Q->Front];   
}

7-11 修理牧场

农夫要修理牧场的一段栅栏，他测量了栅栏，发现需要N块木头，每块木头长度为整数L_i个长度单位，于是他购买了一条很长的、能锯成N块的木头，即该木头的长度是L_i的总和。但是农夫自己没有锯子，请人锯木的酬金跟这段木头的长度成正比。为简单起见，不妨就设酬金等于所锯木头的长度。例如，要将长度为20的木头锯成长度为8、7和5的三段，第一次锯木头花费20，将木头锯成12和8；第二次锯木头花费12，将长度为12的木头锯成7和5，总花费为32。如果第一次将木头锯成15和5，则第二次锯木头花费15，总花费为35（大于32）。

请编写程序帮助农夫计算将木头锯成N块的最少花费。

输入格式:

输入首先给出正整数N（≤10⁴），表示要将木头锯成N块。第二行给出N个正整数（≤50），表示每段木块的长度。

输出格式:

输出一个整数，即将木头锯成N块的最少花费。

输入样例:

8

4 5 1 2 1 3 1 1

输出样例:

49

/* 
    建一个最小堆, 堆插入树结点, 形成树结点森林;
    每次从堆中取2个最小树结点, 建中间树结点并插入堆;
    (最后堆中森林形成一棵Huffman树)
    打印Huffman树的WPL; 
*/

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

/* 二叉树结点 */
typedef struct TreeNode* Tree;
struct TreeNode {
    int Weight;
    Tree Left, Right;
};

/* 堆(优先队列) */
#define MAXSIZE 10001 
typedef struct HeapNode* Heap;
struct HeapNode {   
    struct TreeNode Data[MAXSIZE];/* 完全二叉树顺序存储 */
    int Size;
};
 
 /* 建树结点 */
Tree NewTreeNode() {
    Tree T;
    T = (Tree)malloc(sizeof(struct TreeNode));
    T->Weight = 0;
    T->Left = T->Right = NULL;    
    return T;
}

 /* 建空堆 */
Heap CreatHeap() {
    Heap H;
    H = (Heap)malloc(sizeof(struct HeapNode));
    H->Size = 0;            /* 空堆 */
    H->Data[0].Weight = -1; /* 哨兵 */
    return H;
}
 
 /* 堆插入 */
void Insert(Heap H, struct TreeNode T) {
    int i = ++H->Size;  /* ++堆, 从堆的最后开始寻找插入结点位置 */
    for( ; T.Weight < H->Data[i/2].Weight; i /= 2)
        H->Data[i] = H->Data[i/2]; /* 父结点下滤 */
    H->Data[i] = T; /* 插入结点 */
}

 /* 堆删除 */
Tree Delete(Heap H) 
{    /* 提取堆最后一个树结点, 从堆的第一个结点开始比较,上滤, 堆-- */
    int parent, child;
    struct TreeNode Temp = H->Data[H->Size--]; /* 提取堆最后一个树结点 */
    Tree T = NewTreeNode(); /* 创建树结点 */
    *T = H->Data[1];        /* 从堆中提取第一个树结点 */
    for(parent = 1; 2*parent <= H->Size; parent = child) 
    {
        child = 2 * parent; /* 从父结点找左孩子 */
        if(child != H->Size && H->Data[child].Weight > H->Data[child+1].Weight) 
            child++;        /* 有右孩子且比左孩子小, 选右孩子 */
        if(Temp.Weight < H->Data[child].Weight) 
            break;  /* 原堆最后一个树结点找到位置 */
        H->Data[parent] = H->Data[child]; /* 孩子结点上滤, 孩子结点覆盖父结点 */
    }
    H->Data[parent] = Temp; /* 原堆最后一个树结点归位 */
    return T; /* 返回原堆第一个树结点 */
}

/* 建Huffman树 */
Tree Huffman(Heap H) 
{   
    Tree T = NewTreeNode(); /* 临时树结点 */
    while(H->Size != 1) 
    {    /* 每次取堆中2个最小值建中间树结点 */
        T->Left = Delete(H);  
        T->Right = Delete(H);
        T->Weight = T->Left->Weight + T->Right->Weight;
        
        Insert(H, *T); /* 复制创建的中间树结点(传参)插入堆 */
    }
    free(T); /* 释放临时结点 */
    T = Delete(H); /* 取出堆中的树 */
    return T;
}
 
int WPL(Tree T, int Depth) { /* 整棵树的WPL */
    if(!T->Left && !T->Right) {  return Depth*T->Weight; }
    else return WPL(T->Left, Depth+1) + WPL(T->Right, Depth+1);
}
 
int main() 
{
    int N, Weight;
   
    Heap H = CreatHeap(); /* 建空堆 */
    Tree T = NewTreeNode();  /* 建临时树结点 */
    
    scanf("%d", &N);  /* 树结点个数 */
    for(int i = 0; i < N; i++) 
    {      
        scanf("%d", &Weight);        
        T->Weight = Weight;
        H->Data[H->Size].Left = H->Data[H->Size].Right = NULL;       
        Insert(H, *T); /* 复制创建的树结点(传参), 插入堆, 形成树森林 */
    }
    
    free(T); /* 释放临时结点 */
    
    T = Huffman(H);   /* 建Huffman树  */
    
    printf("%d\n", WPL(T, 0)); /* 输出Huffman树的WPL */
    
    return 0;
}

7-12 地下迷宫探索

地道战是在抗日战争时期，在华北平原上抗日军民利用地道打击日本侵略者的作战方式。地道网是房连房、街连街、村连村的地下工事，如下图所示。

 

我们在回顾前辈们艰苦卓绝的战争生活的同时，真心钦佩他们的聪明才智。在现在和平发展的年代，对多数人来说，探索地下通道或许只是一种娱乐或者益智的游戏。本实验案例以探索地下通道迷宫作为内容。

假设有一个地下通道迷宫，它的通道都是直的，而通道所有交叉点（包括通道的端点）上都有一盏灯和一个开关。请问你如何从某个起点开始在迷宫中点亮所有的灯并回到起点？

 

输入格式:

输入第一行给出三个正整数，分别表示地下迷宫的节点数N（1<N≤1000，表示通道所有交叉点和端点）、边数M（≤3000，表示通道数）和探索起始节点编号S（节点从1到N编号）。随后的M行对应M条边（通道），每行给出一对正整数，分别是该条边直接连通的两个节点的编号。

输出格式:

若可以点亮所有节点的灯，则输出从S开始并以S结束的包含所有节点的序列，序列中相邻的节点一定有边（通道）；否则虽然不能点亮所有节点的灯，但还是输出点亮部分灯的节点序列，最后输出0，此时表示迷宫不是连通图。

由于深度优先遍历的节点序列是不唯一的，为了使得输出具有唯一的结果，我们约定以节点小编号优先的次序访问（点灯）。在点亮所有可以点亮的灯后，以原路返回的方式回到起点。

输入样例1:

6 8 1
1 2
2 3
3 4
4 5
5 6
6 4
3 6
1 5

输出样例1:

1 2 3 4 5 6 5 4 3 2 1

输入样例2:

6 6 6
1 2
1 3
2 3
5 4
6 5
6 4

输出样例2:

6 4 5 4 6 0

#include <stdio.h>

#define MAXN 1010  /* 最大结点数 */
int AdjMatrix[MAXN][MAXN] = {0}; /* 邻接矩阵 */
int visited[MAXN] = {0}; /* 访问标记 */
int flag = 0;
int count = 1; /* 入口1 */
int n;  /* 结点数 */
 
void DFS(int s)
{
    if(flag)
        printf(" ");
    flag++;
    printf("%d", s);  /* 访问 */
    visited[s] = 1;
    for(int i = 1;i<=n;i++) /* 结点序号从1开始到n */
        if(!visited[i]&&AdjMatrix[s][i]) /* 结点没访问且有边 */
        {
            count++;         /* 访问结点计数 */
            DFS(i);             /* 递归调用 */
            printf(" %d",s); /* 返回 */
        }
}
 
int main()
{
    int m,s;  
    scanf("%d%d%d", &n, &m, &s); /* 结点数 边数 入口 */
    for(int i = 0;i<m;i++)
    {
        int a,b;        /* 边的两个结点编号 */
        scanf("%d%d", &a, &b); 
        AdjMatrix[a][b] = AdjMatrix[b][a] = 1;
    }
    DFS(s);     /* 深度搜索 */
    if(count<n) /* 迷宫不连通 */
        printf(" 0");
    return 0;
}

7-13 畅通工程之局部最小花费问题

某地区经过对城镇交通状况的调查，得到现有城镇间快速道路的统计数据，并提出“畅通工程”的目标：使整个地区任何两个城镇间都可以实现快速交通（但不一定有直接的快速道路相连，只要互相间接通过快速路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建快速路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全地区畅通需要的最低成本。

输入格式:

输入的第一行给出村庄数目N (1≤N≤100)；随后的N(N−1)/2行对应村庄间道路的成本及修建状态：每行给出4个正整数，分别是两个村庄的编号（从1编号到N），此两村庄间道路的成本，以及修建状态 — 1表示已建，0表示未建。

输出格式:

输出全省畅通需要的最低成本。

输入样例:

4
1 2 1 1
1 3 4 0
1 4 1 1
2 3 3 0
2 4 2 1
3 4 5 0

输出样例:

3

#include <stdio.h>

#define inf 65535
#define MAXN 200
int map[MAXN][MAXN],w[MAXN],visit[MAXN];
int N;

void init() 
{
    for(int i = 1; i<=N; i++) {
        for(int j = 1; j<=N; j++) {
            map[i][j] = inf;
        }
    }
    int start,end,cost,state,k = N*(N-1)/2;
    for(int i = 0; i<k; i++) 
    { /* 两个村庄start,end,村庄之间路的花费cost,是否已修建state */
        scanf("%d%d%d%d",&start,&end,&cost,&state);
        if(state == 0) {
            map[start][end] = cost;
            map[end][start] = cost;
        } else {
            map[start][end] = 0;
            map[end][start] = 0;
        }
    }
}

void prim() 
{    /* 从1顶点出开始生成最小生成树 */
    for(int i = 1; i<=N; i++){
        visit[i] = 0;
        if(i != 1)
            w[i] = map[1][i];
    }
    visit[1] = 1;
    int pos = 0,MIN = inf;
    for(int i = 0; i<N; i++) 
    {
        MIN = inf,pos = 0;
        for(int j = 1; j<=N; j++) 
        {/* 从没有访问过的顶点中找到下一个距离最短的边 */
            if(!visit[j] && MIN>w[j]) {
                MIN = w[j];
                pos = j;
            }
        }
        visit[pos] = 1;
        for(int j = 1; j<=N; j++) 
        {  /* 用这个最小的顶点的邻接边的权值更新w[]的值 */
            if(!visit[j] && map[pos][j]<w[j]) {
                w[j] = map[pos][j];
            }
        }
    }
}

int main() 
{
    scanf("%d",&N);
    init();
    prim();

    int sum = 0;
    /* 最低成本 */
    for(int i = 1; i<=N; i++) {
        sum += w[i];
    }
    printf("%d\n",sum);
    return 0;
}

7-14 奥运排行榜

每年奥运会各大媒体都会公布一个排行榜，但是细心的读者发现，不同国家的排行榜略有不同。比如中国金牌总数列第一的时候，中国媒体就公布“金牌榜”；而美国的奖牌总数第一，于是美国媒体就公布“奖牌榜”。如果人口少的国家公布一个“国民人均奖牌榜”，说不定非洲的国家会成为榜魁…… 现在就请你写一个程序，对每个前来咨询的国家按照对其最有利的方式计算它的排名。

输入格式:

输入的第一行给出两个正整数N和M（≤224，因为世界上共有224个国家和地区），分别是参与排名的国家和地区的总个数、以及前来咨询的国家的个数。为简单起见，我们把国家从0 ~ N−1编号。之后有N行输入，第i行给出编号为i−1的国家的金牌数、奖牌数、国民人口数（单位为百万），数字均为[0,1000]区间内的整数，用空格分隔。最后面一行给出M个前来咨询的国家的编号，用空格分隔。

输出格式:

在一行里顺序输出前来咨询的国家的排名:计算方式编号。其排名按照对该国家最有利的方式计算；计算方式编号为：金牌榜=1，奖牌榜=2，国民人均金牌榜=3，国民人均奖牌榜=4。输出间以空格分隔，输出结尾不能有多余空格。

若某国在不同排名方式下有相同名次，则输出编号最小的计算方式。

输入样例:

4 4
51 100 1000
36 110 300
6 14 32
5 18 40
0 1 2 3

输出样例:

1:1 1:2 1:3 1:4

#include <stdio.h>

#define MAXN 225  /* 224个国家 */
struct country
{
    int gold;  /* 金牌 */
    int medal; /* 奖牌 */
    int pop;   /* 人口数population */
} cts[MAXN];   /* 城市数 */

int main()
{
    int m,n;
    scanf("%d %d",&n,&m);   /* 参与总数n,咨询总数m */
    for(int i = 0; i < n; i++) /* 参与 */
    {
        scanf("%d %d %d",&cts[i].gold,&cts[i].medal,&cts[i].pop);
    }
    for(int i = 0; i < m; i++)  /* m个国家咨询 */
    {
        int num;
        scanf("%d",&num); /* 咨询国家编号num */
        int rank[4] = {0};        /* 4种计算名次方法 */
        
        for(int i = 0; i < n; i++) /* 计算名次 */
        {
            if(cts[i].gold > cts[num].gold)
                rank[0]++;
            if(cts[i].medal > cts[num].medal)
                rank[1]++;
            if(cts[i].gold*cts[num].pop > cts[num].gold*cts[i].pop)
                rank[2]++;
            if(cts[i].medal*cts[num].pop > cts[num].medal*cts[i].pop)
                rank[3]++;
        }
      
        int sum = rank[0];
        int index = 0; 
        for(int i = 1;i < 4;i++)
        {
            if(rank[i] < sum)
            {
                sum = rank[i];
                index = i;
            }
        }
        if(i) printf(" ");            
        printf("%d:%d",sum+1,index+1); /* 某国的排名  */            
    }
    printf("\n");
}

7-15 寻找大富翁

胡润研究院的调查显示，截至2017年底，中国个人资产超过1亿元的高净值人群达15万人。假设给出N个人的个人资产值，请快速找出资产排前M位的大富翁。

输入格式:

输入首先给出两个正整数N（≤10⁶）和M（≤10），其中N为总人数，M为需要找出的大富翁数；接下来一行给出N个人的个人资产值，以百万元为单位，为不超过长整型范围的整数。数字间以空格分隔。

输出格式:

在一行内按非递增顺序输出资产排前M位的大富翁的个人资产值。数字间以空格分隔，但结尾不得有多余空格。

输入样例:

8 3
8 12 7 3 20 9 5 18

输出样例:

20 18 12

#include <stdio.h>

#define N 1000000
int key[N] = {0};

int main()
{
    int n,m,x,count=0,flag=0;
    scanf("%d%d",&n,&m); 
    for(int i=0; i<n; ++i){
        scanf("%d",&x);
        key[x]++;
    }
    for(int j=N-1; j>=0 && count<m; --j){
        if(key[j]){
            if(flag) printf(" ");
            printf("%d",j);
            flag = 1;
            count++;
            if(key[j]>1){
                key[j]--;
                j++;
            }
        }        
    }
}