/*
Slyar
2009.10.29
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
 
#define N 255
#define M 2*N - 1
 
/* 运行成功标记 */
int ok = 0;
 
/* 保存原文件名 */
char file[20] = {};
 
/* 哈夫曼树节点类型 */
typedef struct
{
    int data; /* 字符值 */
    int weight; /* 权重 */
    int parent; /* 双亲结点 */
    int lchild; /* 左孩子结点 */
    int rchild; /* 右孩子结点 */
}Tree;
 
/* 哈夫曼编码类型 */
typedef struct
{
    /* 存放哈夫曼码 */
    char cd[N]; 
    int start;
}Code;
 
/* 生成节点及编码数组 */
Tree ht[M];
Code hcd[N];
 
/* 函数声明 */
int cmp(const void*, const void*);
int NumberOfChar();
void Reset();
void InputFile();
void Encode(int);
void Decode(int);
void OutputFile(int);
void PrintHuffmanCode(int);
void CreateHT(int);
void CreateHCode(int);
 
/* 主函数 */
int main()
{
    int x = 0;
    int n = 0;
    char ch;
    while(1)
    {
        system("cls");
        printf("1. 读入原文件\n");
        printf("2. 在屏幕上打印哈夫曼代码表\n");
        printf("3. 编码原文件\n");
        printf("4. 解码原文件\n");
        printf("5. 退出\n");
        printf("Input 1-5:");
 
        scanf("%d", &x);
 
        switch(x)
        {
            case 1:
                Reset();
                InputFile();
                if (ok)
                {
                    /* 排序使得有效字符在前面 */
                    qsort(ht, N, sizeof(Tree), cmp);
                    /* 记下有效字符的个数 */
                    n = NumberOfChar();
                    CreateHT(n);
                    CreateHCode(n);
                    OutputFile(n);
                    system("pause");
                }
                break;
            case 2:
                system("cls");
                if (ok)
                {
                    PrintHuffmanCode(n);
                }
                else
                {
                    printf("原文件尚未读入!\n");
                }
                system("pause");
                break;
            case 3:
                system("cls");
                if (ok)
                {
                    Encode(n);
                }
                else
                {
                    printf("原文件尚未读入!\n");
                }
                system("pause");
                break;
            case 4:
                system("cls");
                if (ok)
                {
                    Decode(n);
                }
                else
                {
                    printf("原文件尚未读入!\n");
                }
                system("pause");
                break;
            case 5:
                return 0;
            default:
                /* 防止输入错误序号，刷新缓冲区 */
                fflush(stdin);
        }
    }
    return 0;
}
 
/* 快速排序比较函数 */
int cmp(const void *a ,const void *b)
{
    return (*(Tree *)a).weight < (*(Tree *)b).weight ? 1 : -1;
}
 
/* 统计有效的字符数量 */
int NumberOfChar()
{
    int i, num = 0;
    for (i = 0; i < N; i++)
    {
        if (ht[i].weight > 0) num++;
    }
    return num;
}
 
/* 初始化哈夫曼树 */
void Reset()
{
    int i;
    for (i = 0; i < M; i++)
    {
        ht[i].weight = 0;
        ht[i].parent = -1;
        ht[i].lchild = -1;
        ht[i].rchild = -1;
    }
}
 
/* 读入文件内容 */
void InputFile()
{
    FILE *fp;
    char ch;
    system("cls");
    printf("请输入原文件名:");
    fflush(stdin);
    scanf("%s", file);
 
    /* 打开原文件 */
    if ((fp = fopen(file, "rt")) == NULL)
    {
        printf("找不到原文件 %s!\n", file);
        ok = 0;
        system("pause");
        return;
    }
 
    /* 读入字符并处理权重 */
    while (fscanf(fp, "%c", &ch) != EOF)
    {
        ht[ch].data = ch;
        ht[ch].weight++;
    }
 
    /* 关闭文件指针 */
    fclose(fp);
    printf("原文件 %s 读入成功!\n", file);
    ok = 1;
}
 
/* 编码 */
void Encode(int n)
{
    int i, k;
    char ch;
    FILE *fp1, *fp2;
 
    /* 利用哈夫曼代码表进行编码 */
    if (access("Huffman_Code.txt",0) != 0)
    {
        printf("找不到代码表 Huffman_Code.txt !\n");
        return;
    }
 
    /* 打开要编码的原文件 */
    if ((fp1 = fopen(file, "rt")) == NULL)
    {
        printf("找不到原文件 %s !\n", file);
        return;
    }
 
    /* 生成编码文件 */
    if ((fp2 = fopen("Encode.txt", "wt+")) == NULL)
    {
        printf("编码文件 Encode.txt 创建失败!\n");
        return;
    }
 
    /* 一个字符一个字符替换 */
    while (fscanf(fp1, "%c", &ch) != EOF)
    {
        for (i = 0; i < n; i++)
        {
            if (ht[i].data == ch)
            {
                for (k = hcd[i].start; k <= n; k++)
                {
                    fprintf(fp2, "%c", hcd[i].cd[k]);
                }
            }
        }
    }
 
    /* 关闭文件指针 */
    fclose(fp1);
    fclose(fp2);
    printf("编码成功，结果在 Encode.txt 中!\n");
}
 
/* 解码 */
void Decode(int n)
{
    int i, k;
    char ch;
    FILE *fp1, *fp2;
 
    /* 打开要解码的文件 */
    if ((fp1 = fopen("Encode.txt", "rt")) == NULL)
    {
        printf("找不到编码文件 Encode.txt!\n");
        return;
    }
 
    /* 生成解码文件 */
    if ((fp2 = fopen("Decode.txt", "wt+")) == NULL)
    {
        printf("解码文件 Decode.txt 创建失败!\n");
        return;
    }
 
    /* 利用哈夫曼树解码 */
    i = 2 * n - 2;
    while (fscanf(fp1, "%c", &ch) != EOF)
    {
        if (ch == '0')
        {
            i = ht[i].lchild;
        }
        else
        {
            i = ht[i].rchild;
        }
        /* 找到叶子节点为止 */
        if (ht[i].lchild == -1)
        {
            fprintf(fp2, "%c", ht[i].data);
            /* 继续从根节点开始查找 */
            i = 2 * n - 2;
        }
    }
 
    /* 关闭文件指针 */
    fclose(fp1);
    fclose(fp2);
    printf("解码成功，结果在 Decode.txt 中!\n");
}
 
/* 输出哈弗曼编码到文件 */
void OutputFile(int n)
{
    FILE *fp;
    int i, k;
 
    /* 生成哈夫曼代码表文件 */
    if ((fp = fopen("Huffman_Code.txt", "wt+")) == NULL)
    {
        printf("代码表文件 Huffman_Code.txt 创建失败!\n");
        return;
    }
 
    /* 将内存里的东西写入文件 */
    for (i = 0; i < n; i++)
    {
        fprintf(fp, "%d ", ht[i].data);
        for (k = hcd[i].start; k <= n; k++)
        {
            fprintf(fp, "%c", hcd[i].cd[k]);
        }
        if (i < n - 1) fprintf(fp, "\n");
    }
 
    /* 关闭文件指针 */
    fclose(fp);
    printf("代码表文件 Huffman_Code.txt 生成成功!\n");
}
 
/* 打印哈夫曼编码到屏幕 */
void PrintHuffmanCode(int n)
{
    int i, k;
    printf("ASCII \t Char \t HuffmanCode\n");
    for (i = 0; i < n; i++)
    {
        printf("%d \t \"%c\" \t ", ht[i].data, ht[i].data);
        for (k = hcd[i].start; k <= n; k++)
        {
            printf("%c", hcd[i].cd[k]);
        }
        printf("\n");
    }
}
 
/* 构造哈夫曼树 */
void CreateHT(int n)
{
    int i, k ,lmin, rmin;
    int min1, min2;
 
    /* 一共有2n-1个节点 */
    for (i = n; i < 2 * n - 1; i++)
    {
        /*lmin和rmin为最小权重的两个节点置*/
        min1 = min2 = 0x7FFFFFFF;
        lmin = rmin = -1;
        for (k = 0; k <= i - 1; k++)
        {
            /*只在尚未构造二叉树的节点中查找*/
            if (ht[k].parent == -1)
            {
                if (ht[k].weight < min1)
                {
                    min2 = min1;
                    rmin = lmin;
                    min1 = ht[k].weight;
                    lmin = k;
                }
                else if (ht[k].weight < min2)
                {
                    min2 = ht[k].weight;
                    rmin = k;
                }
            }
        }
 
        /* 修改2个小权重节点的双亲 */
        ht[lmin].parent = i;
        ht[rmin].parent = i;
 
        /* 修改双亲的权重 */
        ht[i].weight = ht[lmin].weight + ht[rmin].weight;
 
        /* 修改双亲的孩子 */
        ht[i].lchild = lmin;
        ht[i].rchild = rmin;
    }
}
 
/* 得到哈夫曼编码 */
void CreateHCode(int n)
{
    int i, f, c;
    Code hc;
 
    /* 根据哈夫曼树求哈夫曼编码 */
    for (i = 0; i < n; i++)
    {
        hc.start = n;
        c = i;
        f = ht[i].parent;
 
        /* 循序直到树根结点 */
        while (f != -1)
        {
            /* 处理左孩子结点 */
            if (ht[f].lchild == c)
            {
                hc.cd[hc.start--] = '0';
            }
            /* 处理右孩子结点 */
            else
            {
                hc.cd[hc.start--] = '1';
            }
            c = f;
            f = ht[f].parent;
        }
 
        /* start指向哈夫曼编码最开始字符 */
        hc.start++;
        hcd[i] = hc;
    }
}

/*
求二叉树任意两节点最短路径长度
Slyar
http://www.slyar.com
2009.5.22
*/
#include <stdio.h>
#include <malloc.h>
 
/* 二叉树节点定义 */
typedef struct node
{
	int data;
	int lchild;
	int rchild;
}bitree;
 
/* 定义全局变量 */
int n, dis, sign;
bitree *t;
 
/* 函数声明 */
int Search(int);
int ShortestPath(int, int);
int GetPathLength(int, int);
 
/* 主函数 */
int main()
{
	int i, m, a, b, c;
	int start, end;
	int length;
 
	/* 定义文件指针 */
	FILE *fp1, *fp2;
 
	/* 以只读方式打开输入文件 input.txt */
	if((fp1 = fopen("input.txt","r")) == NULL)
	{
		printf("Cannot open this file.\n");
		exit(0);
	}
 
	fscanf(fp1, "%d", &n);
 
	/* 动态分配空间 */
	t = (bitree*) calloc(n + 1, sizeof(bitree));
 
	/* 读入二叉树 */
	for (i = 1; i <= n; i++)
	{
		fscanf(fp1, "%d%d%d", &a, &b, &c);
		t[i].data = a;
		t[i].lchild = b;
		t[i].rchild = c;
	}
 
	fscanf(fp1, "%d", &m);
 
	/* 以写入方式打开输出文件 output.txt */
	if((fp2 = fopen("output.txt","w")) == NULL)
	{
		printf("Cannot open this file.\n");
		exit(0);
	}
 
	while (m--)
	{
		fscanf(fp1, "%d %d", &start, &end);
 
		/* 求解最短路径 */
		length = ShortestPath(start, end);
 
		fprintf(fp2, "%d %d %d\n", start, end, length);
	}
 
	/* 关闭输入文件 */
	fclose(fp1);
 
	/* 关闭输出文件 */
	fclose(fp2);
 
	/* 注销分配的空间 */
	free(t);
 
	return 0;
}
 
/* 计算最短路径,找最近的共同祖先结点 */
int ShortestPath(int start, int end)
{
	int i;
	int dis1, dis2;
 
	/* 共同祖先节点肯定在序号较小结点的上方 */
	for (i = (start < end ? start:end); i > 0; i--)
	{
		/* 求start节点的祖先结点路径长度 */
		sign = 0;
		dis = 0;
		dis1 = GetPathLength(i, start);
 
		/* 求end节点的祖先结点路径长度 */
		sign = 0;
		dis = 0;
		dis2 = GetPathLength(i, end);
 
		/* 如果有共同祖先结点则最短路径为两路径之和 */
		if (dis1 != 0 && dis2 != 0)
		{
			/* 小于0说明起始结点就是要找的，路径长度应为0 */
			if (dis1 < 0) dis1 = 0;
			if (dis2 < 0) dis2 = 0;
			return dis1 + dis2;
		}
	}
 
}
 
/* 求以start为根的二叉树中编号为key的结点路径长度 */
int GetPathLength(int start, int key)
{
	/* 遇到叶子结点停止递归 */
	if (start != 0)
	{
		/* 找到key就返回。如果起始结点就是要找的，返回-1 */
		if (t[start].data == key)
		{
			sign = 1;
			return -1;
		}
		/* 没找到则递归搜索左子树 */
		if (!sign) GetPathLength(t[start].lchild, key);
 
		/* 没找到则递归搜索右子树 */
		if (!sign) GetPathLength(t[start].rchild, key);
 
		/* 找到key后返回，每次路径长度+1 */
		if (sign) dis++;
	}
	return dis;
}

/*
Slyar
http://www.slyar.com
2009.5.16
*/
#include <stdio.h>
#include <stdlib.h>
 
#define MAXSIZE 200
 
/* 定义二叉树节点类型 */
typedef struct node
{
    char data;
    struct node *lchild, *rchild;
}BTNode;
 
/* 函数声明 */
BTNode* CreatBitTree();
void PreOrder(BTNode*);
void InOrder(BTNode*);
void PostOrder(BTNode*);
 
/* 主函数 */
int main()
{
    BTNode *root = NULL;
    root = CreatBitTree();
    PreOrder(root);
    InOrder(root);
    PostOrder(root);
    system("pause");
    return 0;
}
 
/* 递归前序建立二叉树 */
BTNode* CreatBitTree()
{
    char ch;
    BTNode *b;
    scanf("%c", &ch);
    /* 遇到空节点停止递归 */
    if (ch == '#')
    {
        b = NULL;
    }
    else
    {
        b = (BTNode*) malloc(sizeof(BTNode));
        /* 建立根节点 */
        b->data = ch;
        /* 递归先序建立左子树 */
        b->lchild = CreatBitTree();
        /* 递归先序建立右子树 */
        b->rchild = CreatBitTree();
    }
    return b;
}
 
/* 非递归前序遍历二叉树 */
void PreOrder(BTNode* b)
{
    BTNode *stack[MAXSIZE], *p;
    int top = -1;
    if (b != NULL)
    {
        /* 根节点入栈 */
        top++;
        stack[top] = b;
        /* 栈不空时循环 */
        while (top > -1)
        {
            /* 出栈并访问该节点 */
            p = stack[top];
            top--;
            printf("%c ", p->data);
            /* 右孩子入栈 */
            if (p->rchild != NULL)
            {
                top++;
                stack[top] = p->rchild;
            }
            /* 左孩子入栈 */
            if (p->lchild != NULL)
            {
                top++;
                stack[top] = p->lchild;
            }
        }
        printf("\n");
    }
}
 
/* 非递归中序遍历二叉树 */
void InOrder(BTNode* b)
{
    BTNode *stack[MAXSIZE], *p;
    int top = -1;
    if (b != NULL)
    {
        p = b;
        while (top > -1 || p != NULL)
        {
            /* 扫描p的所有左节点并入栈 */
            while (p != NULL)
            {
                top++;
                stack[top] = p;
                p = p->lchild;
            }
            if (top > -1)
            {
                /* 出栈并访问该节点 */
                p = stack[top];
                top--;
                printf("%c ", p->data);
                /* 扫描p的右孩子 */
                p = p->rchild;
            }
        }
        printf("\n");
    }
}
 
/* 非递归后序遍历二叉树 */
void PostOrder(BTNode* b)
{
    BTNode *stack[MAXSIZE], *p;
    int sign, top = -1;
    if (b != NULL)
    {
        do
        {
            /* b所有左节点入栈 */
            while (b != NULL)
            {
                top++;
                stack[top] = b;
                b = b->lchild;
            }
            /* p指向栈顶前一个已访问节点 */
            p = NULL;
            /* 置b为已访问 */
            sign = 1;
            while (top != -1 && sign)
            {
                /* 取出栈顶节点 */
                b = stack[top];
                /* 右孩子不存在或右孩子已访问则访问b */
                if (b->rchild == p)
                {
                    printf("%c ", b->data);
                    top--;
                    /* p指向被访问的节点 */
                    p = b;
                }
                else
                {
                    /* b指向右孩子节点 */
                    b = b->rchild;
                    /* 置未访问标记 */
                    sign = 0;
                }
            }
        }while (top != -1);
        printf("\n");
    }
}