[code] refactoring 63~74

Author: inkydragon

000-inc/inc.h

@@ -11,6 +11,7 @@
 #ifdef CLS_AND_GETCH
 #ifndef _INC_CONIO
 #include <conio.h> // _getch
+#define getch _getch
 #endif
 #endif // end #ifdef CLS_AND_GETCH
 

063-汉诺塔问题/63.c

@@ -1,39 +1,41 @@
-/*//////////////////////////////////////////////////////////////*/
-/*                          汉诺塔问题                          */
-/*//////////////////////////////////////////////////////////////*/
+//////////////////////////////////////////////////////////////////
+//                          汉诺塔问题                           //
+//////////////////////////////////////////////////////////////////
 #include <stdio.h>
+#include <stdlib.h> // exit
 
-/* hanoil 子程序，实现将n个盘子从a移动到c */
-void hanoil(int n, char a, char b, char c)
-{
-    if (n == 1) /* 递归调用的出口，n=1 */
-        printf("  >>  Move Plate No.%d from Stick %c to Stick %c.\n", n, a, c);
-    else
-    {
-        hanoil(n - 1, a, c, b); /* 递归调用 */
-        printf("  >>  Move Plate No.%d from Stick %c to Stick %c.\n", n, a, c);
+
+long step = 0;
+void print_step(int n, char a, char c) {
+    printf("%4d >>  Move Plate No.%d from Stick %c to Stick %c.\n", ++step, n, a, c);
+}
+
+// hanoil 子程序，实现将n个盘子从a移动到c
+void hanoil(int n, char a, char b, char c) {
+    if (n == 1) { // 递归调用的出口，n=1
+        print_step(n, a, c);
+    } else {
+        hanoil(n - 1, a, c, b); // 递归调用
+        print_step(n, a, c);
         hanoil(n - 1, b, a, c);
     }
 }
 
-/****************************** 主程序******************************/
-
-void main()
-{
+int main() {
     int n;
     char a = 'A';
     char b = 'B';
     char c = 'C';
-    clrscr();
-    printf("This is a hanoil program.\nPlease input number of the plates:\n");
+
+    printf("This is a hanoil program.\nPlease input number of the plates: ");
     scanf("%d", &n);
-    if (n <= 0)
-    {
+    if (n <= 0) {
         puts("n must no less than 1!");
         exit(1);
     }
     puts("The steps of moving plates are:");
+    step = 0;
     hanoil(n, a, b, c);
-    puts("\n Press any key to quit...");
-    getch();
+
+    return 0;
 }

064-哈夫曼编码/64.c

@@ -3,86 +3,75 @@
 #define MAXSYMBS 30
 #define MAXNODE 59
 
-typedef struct
-{
+typedef struct {
     int weight;
     int flag;
     int parent;
     int lchild;
     int rchild;
-} huffnode;
+} HuffNode;
 
-typedef struct
-{
+typedef struct {
     int bits[MAXSYMBS];
     int start;
-} huffcode;
+} HuffCode;
 
-main()
-{
-    huffnode huff_node[MAXNODE];
-    huffcode huff_code[MAXSYMBS], cd;
+
+int main() {
+    HuffNode huff_node[MAXNODE];
+    HuffCode huff_code[MAXSYMBS], cd;
     int i, j, m1, m2, x1, x2, n, c, p;
-    /*    char symbs[MAXSYMBS],symb; */
-    /*数组huff_node初始化*/
-    clrscr();
-    printf("please input the leaf num of tree:\n");
+
+    printf("please input the leaf num of tree: ");
     scanf("%d", &n);
-    for (i = 0; i < 2 * n - 1; i++)
-    {
+    for (i = 0; i < 2 * n - 1; i++) {
+        // 数组 huff_node 初始化
         huff_node[i].weight = 0;
         huff_node[i].parent = 0;
-        huff_node[i].flag = 0;
+        huff_node[i].flag   = 0;
         huff_node[i].lchild = -1;
         huff_node[i].rchild = -1;
     }
 
     printf("please input the weight of every leaf\n");
-    for (i = 0; i < n; i++)
-        scanf("%d", &huff_node[i].weight);
-    /*构造哈夫曼树*/
-    for (i = 0; i < n - 1; i++)
-    {
+    for (i = 0; i < n; i++) scanf("%d", &huff_node[i].weight);
+
+    // 构造哈夫曼树
+    for (i = 0; i < n - 1; i++) {
         m1 = m2 = MAX;
         x1 = x2 = 0;
-        for (j = 0; j < n + i; j++)
-        {
-            if (huff_node[j].weight < m1 && huff_node[j].flag == 0)
-            {
+        for (j = 0; j < n + i; j++) {
+            if (huff_node[j].weight < m1 && huff_node[j].flag == 0) {
                 m2 = m1;
                 x2 = x1;
                 m1 = huff_node[j].weight;
                 x1 = j;
-            }
-            else if (huff_node[j].weight < m2 && huff_node[j].flag == 0)
-            {
+            } else if (huff_node[j].weight < m2 && huff_node[j].flag == 0) {
                 m2 = huff_node[j].weight;
                 x2 = j;
             }
         }
 
-        huff_node[x1].parent = n + i; /*将找出的两棵子树合并为一棵子树*/
+        huff_node[x1].parent = n + i; // 将找出的两棵子树合并为一棵子树
         huff_node[x2].parent = n + i;
         huff_node[x1].flag = 1;
         huff_node[x2].flag = 1;
         huff_node[n + i].weight = huff_node[x1].weight + huff_node[x2].weight;
         huff_node[n + i].lchild = x1;
         huff_node[n + i].rchild = x2;
     }
-    /*求字符的哈夫曼编码*/
 
-    for (i = 0; i < n; i++)
-    {
+    // 求字符的哈夫曼编码
+    for (i = 0; i < n; i++) {
         cd.start = n;
         c = i;
         p = huff_node[c].parent;
-        while (p != 0)
-        {
-            if (huff_node[p].lchild == c)
-
+        while (p != 0) {
+            if (huff_node[p].lchild == c) {
                 cd.bits[cd.start] = 0;
-            else
+            } else {
                 cd.bits[cd.start] = 1;
+            }
             cd.start = cd.start - 1;
             c = p;
             p = huff_node[p].parent;
@@ -92,14 +81,14 @@ main()
             huff_code[i].bits[j] = cd.bits[j];
         huff_code[i].start = cd.start;
     }
-    /*输出字符的哈夫曼编码*/
+
+    // 输出字符的哈夫曼编码
     puts("The Hafman code are:");
-    for (i = 0; i < n; i++)
-    {
-        for (j = huff_code[i].start; j <= n; j++)
+    for (i = 0; i < n; i++) {
+        for (j = huff_code[i].start; j <= n; j++) {
             printf("%10d", huff_code[i].bits[j]);
+        }
         printf("\n");
     }
-    puts("Press any key to quit...");
-    getch();
+    return 0;
 }

065-图的深度优先遍历/65.c

@@ -1,109 +1,90 @@
-/*/////////////////////////////////////////////////////////////*/
-/*                           图的深度优先遍历                  */
-/*/////////////////////////////////////////////////////////////*/
+/////////////////////////////////////////////////////////////////
+//                           图的深度优先遍历                   //
+/////////////////////////////////////////////////////////////////
 #include <stdlib.h>
 #include <stdio.h>
 
-struct node /* 图顶点结构定义     */
-{
-    int vertex;            /* 顶点数据信息       */
-    struct node *nextnode; /* 指下一顶点的指标   */
+struct node { // 图顶点结构定义
+    int vertex;            // 顶点数据信息
+    struct node *nextnode; // 指下一顶点的指标
 };
-typedef struct node *graph; /* 图形的结构新型态   */
-struct node head[9];        /* 图形顶点数组       */
-int visited[9];             /* 遍历标记数组       */
+typedef struct node *Graph; // 图形的结构新型态
+struct node head[9];        // 图形顶点数组
+int visited[9];             // 遍历标记数组
 
-/********************根据已有的信息建立邻接表********************/
-void creategraph(int node[20][2], int num) /*num指的是图的边数*/
-{
-    graph newnode; /*指向新节点的指针定义*/
-    graph ptr;
-    int from; /* 边的起点          */
-    int to;   /* 边的终点          */
+//*******************根据已有的信息建立邻接表*******************
+void creategraph(int node[20][2], int num) { //num指的是图的边数
+    Graph newnode; // 指向新节点的指针定义
+    Graph ptr;
+    int from; // 边的起点
+    int to;   // 边的终点
     int i;
 
-    for (i = 0; i < num; i++) /* 读取边线信息，插入邻接表*/
-    {
-        from = node[i][0]; /*    边线的起点            */
-        to = node[i][1];   /*   边线的终点             */
+    for (i = 0; i < num; i++) { // 读取边线信息，插入邻接表
+        from = node[i][0]; // 边线的起点
+        to = node[i][1];   // 边线的终点
 
-        /* 建立新顶点 */
-        newnode = (graph)malloc(sizeof(struct node));
-        newnode->vertex = to;         /* 建立顶点内容       */
-        newnode->nextnode = NULL;     /* 设定指标初值       */
-        ptr = &(head[from]);          /* 顶点位置           */
-        while (ptr->nextnode != NULL) /* 遍历至链表尾   */
-            ptr = ptr->nextnode;      /* 下一个顶点         */
-        ptr->nextnode = newnode;      /* 插入节点        */
+        // 建立新顶点
+        newnode = (Graph)malloc(sizeof(struct node));
+        newnode->vertex = to;         // 建立顶点内容
+        newnode->nextnode = NULL;     // 设定指标初值
+        ptr = &(head[from]);          // 顶点位置
+        while (ptr->nextnode != NULL) // 遍历至链表尾
+            ptr = ptr->nextnode;      // 下一个顶点
+        ptr->nextnode = newnode;      // 插入节点
     }
 }
 
-/**********************  图的深度优先搜寻法********************/
+//*********************  图的深度优先搜寻法*******************
+void dfs(int current) {
+    Graph ptr;
 
-void dfs(int current)
-{
-    graph ptr;
-
-    visited[current] = 1;            /* 记录已遍历过       */
-    printf("vertex[%d]\n", current); /* 输出遍历顶点值     */
-    ptr = head[current].nextnode;    /* 顶点位置           */
-    while (ptr != NULL)              /* 遍历至链表尾       */
-    {
-        if (visited[ptr->vertex] == 0) /* 如过没遍历过 */
-            dfs(ptr->vertex);          /* 递回遍历呼叫 */
-        ptr = ptr->nextnode;           /* 下一个顶点   */
+    visited[current] = 1;            // 记录已遍历过
+    printf("vertex[%d]\n", current); // 输出遍历顶点值
+    ptr = head[current].nextnode;    // 顶点位置
+    while (ptr != NULL) { // 遍历至链表尾
+        if (visited[ptr->vertex] == 0) // 如过没遍历过
+            dfs(ptr->vertex);          // 递回遍历呼叫
+        ptr = ptr->nextnode;           // 下一个顶点
     }
 }
 
-/****************************** 主程序******************************/
-
-void main()
-{
-    graph ptr;
-    int node[20][2] = {{1, 2}, {2, 1}, /* 边线数组     */
-                       {1, 3},
-                       {3, 1},
-                       {1, 4},
-                       {4, 1},
-                       {2, 5},
-                       {5, 2},
-                       {2, 6},
-                       {6, 2},
-                       {3, 7},
-                       {7, 3},
-                       {4, 7},
-                       {4, 4},
-                       {5, 8},
-                       {8, 5},
-                       {6, 7},
-                       {7, 6},
-                       {7, 8},
-                       {8, 7}};
+int main() {
+    Graph ptr;
+    int node[20][2] = { // 边线数组
+        {1, 2}, {2, 1}, 
+        {1, 3}, {3, 1},
+        {1, 4}, {4, 1},
+        {2, 5}, {5, 2},
+        {2, 6}, {6, 2},
+        {3, 7}, {7, 3},
+        {4, 7}, {4, 4},
+        {5, 8}, {8, 5},
+        {6, 7}, {7, 6},
+        {7, 8}, {8, 7}
+    };
     int i;
-    clrscr();
-    for (i = 1; i <= 8; i++) /*   顶点数组初始化  */
-    {
-        head[i].vertex = i;      /*    设定顶点值      */
-        head[i].nextnode = NULL; /*       指针为空     */
-        visited[i] = 0;          /* 设定遍历初始标志   */
+
+    for (i = 1; i <= 8; i++) { // 顶点数组初始化
+        head[i].vertex = i;      // 设定顶点值
+        head[i].nextnode = NULL; // 指针为空
+        visited[i] = 0;          // 设定遍历初始标志
     }
 
-    creategraph(node, 20); /*    建立邻接表      */
+    creategraph(node, 20); //    建立邻接表
     printf("Content of the gragh's ADlist is:\n");
-    for (i = 1; i <= 8; i++)
-    {
-        printf("vertex%d ->", head[i].vertex); /* 顶点值    */
-        ptr = head[i].nextnode;                /* 顶点位置   */
-        while (ptr != NULL)                    /* 遍历至链表尾       */
+    for (i = 1; i <= 8; i++) {
+        printf("vertex%d ->", head[i].vertex); // 顶点值
+        ptr = head[i].nextnode;                // 顶点位置
+        while (ptr != NULL)                    // 遍历至链表尾
         {
-            printf(" %d ", ptr->vertex); /* 印出顶点内容   */
-            ptr = ptr->nextnode;         /* 下一个顶点     */
+            printf(" %d ", ptr->vertex); // 印出顶点内容
+            ptr = ptr->nextnode;         // 下一个顶点
         }
-        printf("\n"); /*   换行             */
+        printf("\n");
     }
     printf("\nThe end of the dfs are:\n");
-    dfs(1);       /* 打印输出遍历过程   */
-    printf("\n"); /* 换行               */
-    puts(" Press any key to quit...");
-    getch();
+    dfs(1);       // 打印输出遍历过程
+    printf("\n"); // 换行
+    return 0;
 }