《C语言—从入门到项目实践》Issue分析及总结

在学习《C语言—从入门到项目实践》总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

《C语言—从入门到项目实践》（超值版）——聚慕课教育研发中心 编著

Issue分析及总结

第四章 数制与数据类型

问题描述：4.7.3中定义复杂的声明别名中（2）（3）不理解？

未解决！

第11章 指针——重点

注意事项：

1）刚定义的指针变量并未指向某个具体的位置（称为悬空指针）。使用悬空指针容易破坏系统，导致系统瘫痪。

2）指针变量只能存放指针（地址），不要将一个非零数（或任何其他非地址类型的数据）赋给一个指针变量。

备注：0除外，如int *p=0;——>表示指针指向空指针，C语言中用NULL表示空指针，表示没有指向任何对象。

3）引用一个数组元素有两种方法：下标法，即采用array[i]形式直接访问数组元素；指针法，即采用*(array+i)或*(pointer+i)形式间接访问数组元素。其中，array是数组名，pointer是指向数组的指针变量。

4）字符数组可以用数组名来一次性的输出它的全部元素（printf("%s",string);），其他类型的数组都不行（只能逐个元素输出）。

1.问题描述：指针的类型与指针所指向的类型的区别？

答：指针的类型是指针本身的类型，指针所指向的类型是：把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩余部分。如：int *ptr——>指针的类型是：int *；指针所指向的类型是int。

2.问题描述：数组指针和指针数组的区别？

答：如果指针p指向二维数组的某一行，则p+1就指向类该二维数组的下一行。这样的指针称为数组指针。如：int array[2][3]={1,2,3,4,5,6};int (*p) [3];——>表明指针p指向一个含有3个元素的一维整型数组，p的值就是该一维数组的首地址。

所以数组指针也称指向一维数组的指针，亦称行指针。

11-9.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
    int array[2][3] = { 1,2,3,4,5,6 };      /*定义一个二维数组*/
    int i, j;
    int(*p)[3];       /*定义一个数组指针*/
    p = array;      /*p指向array下标为0那一行的首地址*/
    for (i = 0; i<2; i++)
    {
        for (j = 0; j<3; j++)
            printf("array[%d][%d]=%d
", i, j, p[i][j]);
    }
    return 0;
}

问题：p[i][j]输出是怎么回事？？？这是下标输出，还可以使用*(p[i]+j)或*(*(p+i)+j)或*(p+i)[j]，即*(p+i)就等价于p[i]。*(p+i)是指针法，p[i]是下标法。
不能使用p[i]或*p[i]或*(p+i)，因为这些都只能找到行，找不到列，所以当i等于0，（p[i]或*p[i]或*(p+i)）都输出0，当i等于1，（p[i]或*p[i]或*(p+i)）都输出1

一维数组指针

 11-16.c

#include <stdio.h>
main()
{
  int array[10], *pointer=array, i; 
  printf("Input 10 numbers: ");
  for(i=0; i<10; i++)
         scanf("%d", pointer+i);           /*使用指针变量来输入数组元素的值*/
        printf("array[10]: ");
   for(i=0; i<10; i++)
         printf("%d  ", *(pointer+i));    /*使用指向数组的指针变量输出数组*/
        printf("
");
}

int array[10], *pointer=array;——>pointer+i和array+i都是数组元素array[i]的地址，或者说它们都指向array数组的第i个元素。*(pointer+i)和*(array+i)就是pointer+i或array+i所指向的数组元素，即array[i]。

多维数组指针——以二维为例

 11-17.c

#include <stdio.h>
int main(void)
{
   int array[2][3]={1,2,3,4,5,6};
   int i,j,*p;
   p=&array[0][0];//等价于p=array
   printf("使用下标访问数组元素
");
   for(i=0;i<2;i++)
   {
   for(j=0;j<3;j++)
      printf("array[%d][%d]=%d
",i,j,array[i][j]);
   }
   printf("使用数组名访问数组元素
");
   for(i=0;i<2;i++)
   {
   for(j=0;j<3;j++)
   printf("array[%d][%d]=%d
",i,j,*(*(array+i)+j));
   }
   printf("使用指针名访问数组元素
");
   for(i=0;i<2;i++)
   {
   for(j=0;j<3;j++)
   printf("array[%d][%d]=%d
",i,j,*(p+3*i+j));
   }
   return 0;
}

注意此处二维数组指针当采用指针名访问数组元素（*(p+3*i+j))）和之前的数组指针（*(*(p+i)+j)）的不同，因为之前定义的差别！！！

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
main()
{
    static int day_tab[2][13] = {
        { 0,31,28,31,30,31,30,31,31,30,31,30,31 },      //没有闰年的月份天数
        { 0,31,29,31,30,31,30,31,31,30,31,30,31 } };    //闰年的月份天数
    int y, m, d;
    scanf("%d%d%d", &y, &m, &d);
    printf("%d
", day_of_year(day_tab, y, m, d));     /*实参为二维数组名*/
}
day_of_year(day_tab, year, month, day)
    int *day_tab;          /*形式参数为指针*/
    int year, month, day;
    {
        int i, j;
        i = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
        for (j = 1; j<month; j++)             /* day_tab+i*13+j：对二维数组中元素进行地址变换 */
            day += *(day_tab + i * 13 + j);
        return(day);
    }

说明：此代码会发出一个警告：c(10): warning C4013: “day_of_year”未定义；假设外部返回 int

还可参看：数组指针和指针数组的区别——https://www.cnblogs.com/mq0036/p/3382732.html

3.问题描述：*(p1-1)的值与变量b的值相同，是巧合吗？

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
    int a = 1, b = 10;
    int *p1, *p2;
    p1 = &a;                                             /*指针赋值*/
    p2 = &b;
    printf("p1地址是%d,p1存储的值是%d
", p1, *p1);       /*输出*/
    printf("p2地址是%d,p2存储的值是%d
", p2, *p2);       /*输出*/
    printf("p1-1地址存储的值是%d
", *(p1 - 1));    /*地址-1后存储的值*/
    printf("p1地址中的值-1后的值是%d
", *p1 - 1);    /*值-1后的值*/
    printf("*(p1-1)的值和*p1-1的值不同
");
    return 0;
}

答：不是巧合。原因是a和b是局部变量，局部变量存储在栈中，而栈是向低地址扩展的存储空间（如果是堆就相反了），又因为int类型占用4个字节，所以a的地址比b的地址大4个字节，p1-1表示a的地址减少4个字节后的地址，也就是p2所指向的变量b，所以是10。

第17章 动态数据结构——重点

1.问题描述：17.2中的链表的建立

代码注释及说明：

#define _CRT_SECURE_NO_WARNINGS
#include "stdio.h"
#include "malloc.h"
#define NULL 0                          /*令NULL为0，用它表示空地址*/
/*LEN代表struct stu结构体类型数据的长度*/
#define LEN sizeof (struct stu) 
struct stu
{
    long int num;
    float score;
    struct stu *next;
};
int n;
struct stu *creat()                      /*此函数带回一个指向链表头的指针*/
{
    struct stu *head, *p1, *p2;
    n = 0;                                    /*n为结点的个数*/
    p1 = p2 = (struct stu *)malloc(LEN);        /*开辟一个新单元，p1指向p2，共同指向这个新单元*/
    scanf("%ld,%f", &p1->num, &p1->score);//如：输入：1，1.5——>p1指向该节点，p2也指向该节点
    head = NULL;//头指针为空
    while (p1->num != 0)
    {
        n = n + 1;//链表节点个数的递增
        if (n == 1)head = p1;//如果是第一个节点，令头指针head指向p1
        else p2->next = p1;//如果不是第一个节点，令p2的next指针指向p1
        p2 = p1;//p2指针向后移动，p2指向p1(刚输入的节点)
        p1 = (struct stu *)malloc(LEN);//p1指向刚开辟的一个新单元
        scanf("%ld,%f", &p1->num, &p1->score);//如：输入：1，1.5——>p1指向该节点
    }
    p2->next = NULL;//输入完毕，令p2的next域指向空（链表的结尾）
    return(head);                            /*返回链表的头地址*/
}
void main()
{
    creat();//此处可以调用create函数创建的链表
}

思路：p1指向新插入的节点，p2的next域指向链表新插入的节点p1——>实现链接上节点p1，p2通过指向p1实现不断后移。

2.问题描述：17.10中的迷宫问题求解的思路，怎么找到出口，路过的下标为什么会少一个？

思路：1）通过探测一个位置的右，下，左，上的位置（标志位）是否为0，而判定下一步是否可以移动到这个点；2）对走过的点，将其标志位设置为0，并将此点入栈；3）如果此点四周都无法走通，出栈，判断刚出栈的点是否可以走通，依次下去；4）如果可以走到出口位置，表示存在这样的路径，如果走不到（即最后栈为空），表明不存在这样的路径。

因为涉及到对已经走过的点的出栈，所以（3行6列）出栈后后续路径可以走通了，输出了路径，最后不存在（3，6）

第18章 C语言经典排序法——重点

1.问题描述：此章的程序用（.c）后缀命名后运行总是报错，如不存在iostream.h等，struct SqList &L报错存在正文时不允许未命名的原型函数

说明：此章的代码不支持C，需要用（.cpp）命名。

2.问题描述：18-3.c中对数组进行快速排序，运行报错？

代码注释及说明：

#include <stdio.h>
int partions(int arr[],int low,int high)// 划分函数
{
    int prvotkey= arr[low];  //提取出低区的关键字
    arr[0]= arr[low];
    while (low<high)  //对低区和高区的数组下标进行比较
    {
        while (low<high&& arr[high]>=prvotkey)
            --high;   //高区的关键字就向前移动
        arr[low]= arr[high];   //高区的数组元素也向前移动
            while (low<high&& arr[low]<=prvotkey) 
                ++low;   //低区的关键字向后移动
            arr[high]= arr[low];   //低区的数组元素向后移动
    }
    arr[low]= arr[0];
    return low;
}
void qsort(int arr[],int low,int high)
{
    int prvotloc;    //枢轴
    if(low<high)
    {
        prvotloc=partions(arr,low,high);    /*将第一次排序的结果作为枢轴*/
        qsort(arr,low,prvotloc-1);     /*递归调用排序，由low 到prvotloc-1*/
        qsort(arr,prvotloc+1,high);    /*递归调用排序，由 prvotloc+1到 high*/
    }
}
void quicksort(int arr[],int n)
{
    qsort(arr,1,n);                  /*第一个作为枢轴 ，从第一个排到第n个*/
}
void main()
{
    int a[11]={0,2,32,43,23,45,36,57,14,27,39};
    int b,c;
    for (b=1;b<11;b++)
        printf("%3d",a[b]);
    printf("
");
    quicksort(a,11);
    for (c=1;c<11;c++)
        printf("%3d",a[c]);
    printf("
  ");
}

原因：数组越界，代码未更改！

3.问题描述：18-8.c中对数组进行快速排序，运行报错？

代码注释及说明：

//#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
typedef int InfoType;             /* 定义其他数据项的类型*/
#define MAXSIZE 20                 /* 一个用做示例的小顺序表的最大长度*/
typedef int KeyType;             /* 定义关键字类型为整型*/
struct RedType                 /* 记录类型*/
{
    KeyType key;                     /* 关键字项*/
    InfoType otherinfo;             /* 其他数据项，具体类型在主程中定义*/
};
struct SqList                     /* 顺序表类型*/
{
    RedType r[MAXSIZE + 1];             /* r[0]闲置或用做哨兵单元*/
    int length;                     /* 顺序表长度*/
};
int SelectMinKey(SqList L, int i)
{ /* 返回在L.r[i..L.length]中key最小的记录的序号*/
    KeyType min;
    int j, k;
    k = i;                             /* 设第i个为最小*/
    min = L.r[i].key;
    for (j = i + 1; j <= L.length; j++)
        if (L.r[j].key<min)             /* 找到更小的*/
        {
            k = j;
            min = L.r[j].key;
        }
    return k;
}
void SelectSort(SqList &L)
{ /* 对顺序表L作简单选择排序*/
    int i, j;
    RedType t;
    for (i = 1; i<L.length; ++i)
    { /*  选择第i小的记录，并交换到位*/
        j = SelectMinKey(L, i);             /* 在L.r[i..L.length]中选择key最小的记录*/
        if (i != j)
        { /* 与第i个记录交换*/
            t = L.r[i];
            L.r[i] = L.r[j];
            L.r[j] = t;
        }
    }
}
void print(SqList L)
{
    int i;
    for (i = 1; i <= L.length; i++)
        printf("(%d,%d)", L.r[i].key, L.r[i].otherinfo);
    printf("
");
}
#define N 8
void main()
{
    RedType d[N] = { { 49,1 },{ 38,2 },{ 65,3 },{ 97,4 },{ 76,5 },{ 13,6 },{ 27,7 },{ 49,8 } };
    SqList l;
    int i;
    for (i = 0; i<N; i++)
        l.r[i + 1] = d[i];
    l.length = N;
    printf("排序前:
");
    print(l);
    SelectSort(l);
    printf("排序后:
");
    print(l);
}

说明：L在经过一次排序后是   L    {r=0x005bfa80 {{key=-858993460 otherinfo=-858993460 }, {key=13 otherinfo=6 }, {key=38 otherinfo=2 }, ...} ...}    SqList &；因为存储时下标为0的节点没有存储内容，所以都是随机值。

4.问题描述：18-9.c中对数组进行树形选择排序，运行报错？

代码注释及说明：

#include<string.h>
#include<ctype.h>
#include<malloc.h>        /*malloc()等*/
#include<limits.h>        /*INT_MAX等*/
#include<stdio.h>         /*EOF(=^Z或F6)，NULL*/
#include<stdlib.h>        /*atoi()*/
#include<io.h>          /*eof()*/
#include<math.h>        /*floor()，ceil()，abs()*/
#include<process.h>        /*exit()*/
//#include<iostream.h>      /*cout，cin*/
/* 函数结果状态代码*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
typedef int Status;     /*Status是函数的类型，其值是函数结果状态代码，如OK*/
typedef int Boolean;     /*Boolean是布尔类型，其值是TRUE或FALSE*/
typedef int InfoType;     /*定义其他数据项的类型*/
#define MAXSIZE 20         /*一个用做示例的小顺序表的最大长度*/
typedef int KeyType;     /*定义关键字类型为整型*/
struct RedType         /*记录类型*/
{
    KeyType key;             /*关键字项*/
    InfoType otherinfo;     /*其他数据项，具体类型在主程序中定义*/
};

struct SqList             /*顺序表类型*/
{
    struct RedType r[MAXSIZE + 1];     /*r[0]闲置或用做哨兵单元*/
    int length;             /*顺序表长度*/
};

void TreeSort(SqList &L)
{ /*树形选择排序*/
    int i, j, j1, k, k1, l, n = L.length;
    RedType *t;
    l = (int)ceil(log(n) / log(2)) + 1;             /*完全二叉树的层数*/
    k = (int)pow(2, l) - 1;                         /*l层完全二叉树的结点总数*/
    k1 = (int)pow(2, l - 1) - 1;                     /*l-1层完全二叉树的结点总数*/
    t = (RedType*)malloc(k*sizeof(RedType));     /*二叉树采用顺序存储结构*/
    for (i = 1; i <= n; i++)                         /*将L.r赋给叶子结点*/
        t[k1 + i - 1] = L.r[i];
    for (i = k1 + n; i<k; i++)                     /*给多余的叶子的关键字赋无穷大*/
        t[i].key = INT_MAX;
    j1 = k1;
    j = k;
    while (j1)
    { /*给非叶子结点赋值*/
        for (i = j1; i<j; i += 2)
            t[i].key<t[i + 1].key ? (t[(i + 1) / 2 - 1] = t[i]) : (t[(i + 1) / 2 - 1] = t[i + 1]);
        j = j1;
        j1 = (j1 - 1) / 2;
    }
    for (i = 0; i<n; i++)
    {
        L.r[i + 1] = t[0];         /*将当前最小值赋给L.r[i]*/
        j1 = 0;
        for (j = 1; j<l; j++)         /*沿树根找结点t[0]在叶子中的序号j1*/
            t[2 * j1 + 1].key == t[j1].key ? (j1 = 2 * j1 + 1) : (j1 = 2 * j1 + 2);
        t[j1].key = INT_MAX;
        while (j1)
        {
            j1 = (j1 + 1) / 2 - 1;         /*序号为j1的结点的双亲结点序号*/
            t[2 * j1 + 1].key <= t[2 * j1 + 2].key ? (t[j1] = t[2 * j1 + 1]) : (t[j1] = t[2 * j1 + 2]);
        }
    }
    free(t);
}

void print(struct SqList L)
{
    int i;
    for (i = 1; i <= L.length; i++)
        printf("(%d,%d)", L.r[i].key, L.r[i].otherinfo);
    printf("
");
}

#define N 8
void main()
{
    struct RedType d[N] = { { 49,1 },{ 38,2 },{ 65,3 },{ 97,4 },{ 76,5 },{ 13,6 },{ 27,7 },{ 49,8 } };
    struct SqList l;
    int i;
    for (i = 0; i<N; i++)
        l.r[i + 1] = d[i];
    l.length = N;
    printf("排序前:
");
    print(l);
    TreeSort(l);
    printf("排序后:
");
    print(l);
}

说明：需要将//#include<iostream.h>      /*cout，cin*/注释掉，如果不注释，会报错：error C1083: 无法打开包括文件: “iostream.h”: No such file or directory

 18-2.c也有这个问题，也需要注释掉。

4.问题描述：18-12.c中对链式进行基数排序，运行报错：error C4996: 'itoa': The POSIX name for this item is deprecated？

代码注释及说明：

#define _CRT_NONSTDC_NO_DEPRECATE
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<ctype.h>
#include<malloc.h>                 //malloc()等
#include<limits.h>                 //INT_MAX等
#include<stdio.h>                 //EOF(=^Z或F6)，NULL
#include<stdlib.h>                 //atoi()
#include<io.h>                     //eof()
#include<math.h>                 //floor()，ceil()，abs()
#include<process.h>             //exit()
//#include<iostream.h>             //cout，cin
/* 函数结果状态代码*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
typedef int Status;         /*Status是函数的类型，其值是函数结果状态代码，如OK等*/
typedef int Boolean;         /*Boolean是布尔类型，其值是TRUE或FALSE*/
#define MAX_NUM_OF_KEY 8     /*关键字项数的最大值*/
#define RADIX 10             /*关键字基数，此时是十进制整数的基数*/
#define MAX_SPACE 1000

typedef int InfoType;         /*定义其他数据项的类型*/
typedef int KeyType;         /*定义RedType类型的关键字为整型*/
struct RedType             /*记录类型(同c10-1.h)*/
{
    KeyType key;                 /*关键字项*/
    InfoType otherinfo;         /*其他数据项*/
};
typedef char KeysType;     /*定义关键字类型为字符型*/

struct SLCell                 /*静态链表的结点类型*/
{
    KeysType keys[MAX_NUM_OF_KEY];     /* 关键字*/
    InfoType otheritems;         /*其他数据项*/
    int next;
};


struct SLList                 /*静态链表类型*/
{
    SLCell r[MAX_SPACE];         /*静态链表的可利用空间，r[0]为头结点*/
    int keynum;                 /*记录的当前关键字个数*/
    int recnum;                 /*静态链表的当前长度*/
};

typedef int ArrType[RADIX];
void InitList(SLList &L, RedType D[], int n)
{ /*初始化静态链表L（把数组D中的数据存于L中）*/
    char c[MAX_NUM_OF_KEY], c1[MAX_NUM_OF_KEY];
    int i, j, max = D[0].key;         /*max为关键字的最大值*/
    for (i = 1; i<n; i++)
        if (max<D[i].key)
            max = D[i].key;
    L.keynum = int(ceil(log10(max)));
    L.recnum = n;
    for (i = 1; i <= n; i++)
    {
        L.r[i].otheritems = D[i - 1].otherinfo;
        itoa(D[i - 1].key, c, 10);     /* 将十进制整型转化为字符型，存入c*/
        for (j = strlen(c); j<L.keynum; j++)     /*若c的长度小于max的位数，在c前补'0'*/
        {
            strcpy(c1, "0");
            strcat(c1, c);
            strcpy(c, c1);
        }
        for (j = 0; j<L.keynum; j++)
            L.r[i].keys[j] = c[L.keynum - 1 - j];
    }
}

int ord(char c)
{ /*返回k的映射(个位整数)*/
    return c - '0';
}

void Distribute(SLCell r[], int i, ArrType f, ArrType e)
{ /*静态键表L的r域中记录已按(keys[0]，…，keys[i-1])有序。本算法按*/
  /*第i个关键字keys[i]建立RADIX个子表，使同一子表中记录的keys[i]相同*/
  /*f[0..RADIX-1]和e[0..RADIX-1]分别指向各子表中第一个和最后一个记录*/
    int j, p;
    for (j = 0; j<RADIX; ++j)
        f[j] = 0; /*各子表初始化为空表*/
    for (p = r[0].next; p; p = r[p].next)
    {
        j = ord(r[p].keys[i]);         /*ord将记录中第i个关键字映射到[0..RADIX-1]*/
        if (!f[j])
            f[j] = p;
        else
            r[e[j]].next = p;
        e[j] = p;                     /*将p所指的结点插入第j个子表中*/
    }
}

int succ(int i)
{ /* 求后继函数*/
    return ++i;
}

void Collect(SLCell r[], ArrType f, ArrType e)
{ /*本算法按keys[i]自小至大地将f[0..RADIX-1]所指各子表依次链接成*/
  /*一个链表，e[0..RADIX-1]为各子表的尾指针*/
    int j, t;
    for (j = 0; !f[j]; j = succ(j));    /*找第一个非空子表，succ为求后继函数*/
    r[0].next = f[j];
    t = e[j];                     /*r[0].next指向第一个非空子表中第一个结点*/
    while (j<RADIX - 1)
    {
        for (j = succ(j); j<RADIX - 1 && !f[j]; j = succ(j)); /*找下一个非空子表*/
        if (f[j])
        { /*链接两个非空子表*/
            r[t].next = f[j];
            t = e[j];
        }
    }
    r[t].next = 0;                /*t指向最后一个非空子表中的最后一个结点*/
}

void printl(SLList L)
{ /*按链表输出静态链表*/
    int i = L.r[0].next, j;
    while (i)
    {
        for (j = L.keynum - 1; j >= 0; j--)
            printf("%c", L.r[i].keys[j]);
        printf(" ");
        i = L.r[i].next;
    }
}

void RadixSort(SLList &L)
{ /*L是采用静态链表表示的顺序表。对L作基数排序，使得L成为按关键字*/
  /*自小到大的有序静态链表，L.r[0]为头结点*/
    int i;
    ArrType f, e;
    for (i = 0; i<L.recnum; ++i)
        L.r[i].next = i + 1;
    L.r[L.recnum].next = 0;             /*将L改造为静态链表*/
    for (i = 0; i<L.keynum; ++i)
    { /*按最低位优先依次对各关键字进行分配和收集*/
        Distribute(L.r, i, f, e);         /*第i趟分配*/
        Collect(L.r, f, e);             /*第i趟收集*/
        printf("第%d趟收集后:
", i + 1);
        printl(L);
        printf("
");
    }
}

void print(SLList L)
{ /*按数组序号输出静态链表*/
    int i, j;
    printf("keynum=%d recnum=%d
", L.keynum, L.recnum);
    for (i = 1; i <= L.recnum; i++)
    {
        printf("keys=");
        for (j = L.keynum - 1; j >= 0; j--)
            printf("%c", L.r[i].keys[j]);
        printf(" otheritems=%d next=%d
", L.r[i].otheritems, L.r[i].next);
    }
}

void Sort(SLList L, int adr[])     /*改此句(类型)*/
{ /*求得adr[1..L.length]，adr[i]为静态链表L的第i个最小记录的序号*/
    int i = 1, p = L.r[0].next;
    while (p)
    {
        adr[i++] = p;
        p = L.r[p].next;
    }
}

void Rearrange(SLList &L, int adr[])    /*改此句(类型)*/
{ /*adr给出静态链表L的有序次序，即L.r[adr[i]]是第i小的记录*/
  /*本算法按adr重排L.r，使其有序(L的类型有变)*/
    int i, j, k;
    for (i = 1; i<L.recnum; ++i)         /*改此句(类型)*/
        if (adr[i] != i)
        {
            j = i;
            L.r[0] = L.r[i];                 /*暂存记录L.r[i]*/
            while (adr[j] != i)
            { /*调整L.r[adr[j]]的记录到位直到adr[j]=i为止*/
                k = adr[j];
                L.r[j] = L.r[k];
                adr[j] = j;
                j = k;                             /*记录按序到位*/
            }
            L.r[j] = L.r[0];
            adr[j] = j;
        }
}

#define N 10
void main()
{
    RedType d[N] = { { 278,1 },{ 109,2 },{ 63,3 },{ 930,4 },{ 589,5 },
    { 184,6 },{ 505,7 },{ 269,8 },{ 8,9 },{ 83,10 } };
    SLList l;
    int *adr;
    InitList(l, d, N);
    printf("排序前(next域还没赋值):
");
    print(l);
    RadixSort(l);
    printf("排序后(静态链表):
");
    print(l);
    adr = (int*)malloc((l.recnum)*sizeof(int));
    Sort(l, adr);
    Rearrange(l, adr);
    printf("排序后(重排记录):
");
    print(l);
}

原因：新版本的vs对旧有的函数itoa进行了安全检查，所以使用新版本的vs会提示错误，而旧版本的没问题。

解决办法：
1）使用新函数 _itoa
2）如果非要使用旧函数也是可以的，加上宏定义即可
#define _CRT_NONSTDC_NO_DEPRECATE
#define _CRT_SECURE_NO_WARNINGS

在学习《C语言—从入门到项目实践》总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。