基数排序的方式可以采用LSD（Least sgnificant digital）或MSD（Most sgnificant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。LSD从低位开始排到高位，每排一位都是把各个桶合并，再按下一位排序；MSD从高位开始排到低位，排完一位后不合并桶，相同的高位划分子桶继续分配，最后再合并。
LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的数组中。
class RadixSort
{ //基数排序
public:
int*
radixSort (int* A, int n)
{
// write code here
int** B = new int*[10];
for (int w = 0; w < 10; w++)
{
B[w] = new int[n + 1];
B[w][0] = 0;
} //B相当于桶，一共10个桶，代表0-9个数字
int value, index;
int flag = 0;
int count = 1;
while (flag == 0)
{
flag = 1;
for (int i = 0; i < n; i++)
{
value = A[i] / count % 10; //value是数据个位上的数
if (value != 0)
flag = 0;
B[value][0]++;
index = B[value][0];
B[value][index] = A[i];
}
if (flag == 1)
break;
int y = 0;
for (int m = 0; m <= 9; m++)
{
for (int ii = 1; ii <= B[m][0]; ii++)
{
A[y] = B[m][ii];
y = y + 1;
}
B[m][0] = 0; //记得每次都要B清零,只需要将每个桶的总数量清零就可以，不必将桶中所有的数据都清除
}
count = 10 * count;
}
for (int z = 0; z < 10; z++)
{
if (B[z] != NULL)
{
delete[] B[z];
}
}
if (B != NULL)
{
delete[] B;
}
return A;
}
};
对于上面的程序来说，其实也可以利用队列或者栈，不必借助于动态二维数组！！！！！
动态二维数组的使用:
假如指针p指向的是一个A类型的数据a，那么p+1指向的就是下一个A类型的数据b，也就是数据a和b之间的地址关系为：b的地址=a的地址+sizeof（A）！！！！！也就是说一个存储单位是一个字节！！！
http://blog.csdn.net/longshengguoji/article/details/11131365这篇博客中介绍了建立动态二维数组主要的两种方法。需要注意的是数组指针的声明定义为 int** p=new int*[10];
http://blog.163.com/wujiaxing009@126/blog/static/7198839920117252550574/中介绍了c++中建立动态二维数组的主要方式：
C++中用new动态创建二维数组的格式一般是这样：
TYPE (*p)[N] = new TYPE [][N];
其中，TYPE是某种类型，N是二维数组的列数。采用这种格式，列数必须指出，而行数无需指定。在这里，p的类型是TYPE*[N]，即是指向一个有N列元素数组的指针。
还有一种方法，可以不指定数组的列数：
int **p;
p = new int*[10]; //注意，int*[10]表示一个有10个元素的指针数组
for (int i = 0; i != 10; ++i)
{
p[i] = new int[5];
}
这里是将p作为一个指向指针的指针，它指向一个包含10个元素的指针数组，并且每个元素指向一个有5个元素的数组，这样就构建了一个10行5列的数组。
当数组使用完毕，释放空间的代码是：
for(int i = 0; i != 5; i++)
{
delete[] p[i];
}
delete[] p;
http://blog.csdn.net/morewindows/article/details/7664479中的建立动态二维数组的代码非常好，值得借鉴！！！
在C语言中，数组与其它变量在使用上有很大的不同．无论是字符型、整型、实型变量,还是结构体类型或者指针类型的变量，语句中出现变量名都代表对该变量所在内存单元的访问，变量名代表整个变量在内存中的存储单元，可以向该变量赋值,也可以从中取出数据使用．但是定义一个数组之后，数组名并不代表整个数组所占据的内存单元，而是代表数组首元素的地址．
二级指针：对于二级指针的讲解可以参考http://www.cnblogs.com/mq0036/p/3382732.html
http://blog.csdn.net/majianfei1023/article/details/46629065
http://baike.baidu.com/link?url=o9tTJqnEQv3xnB1rN251G02MMyP4CB4H6B8cYealMLdRjxN7yiw8AlVw8sDTiEuAyi9lCkUC_6fKq0xz2cRuU-J-x-GVAPUWYFvR3vmXIWjkhZygAqWgpNFHBe4mFp-u
数组指针和指针数组的区别
定义 int (*p)[n];
()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。
如要将二维数组赋给一指针，应这样赋值：
int a[3][4];
int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。
p=a; //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]
p++; //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]
所以数组指针也称指向一维数组的指针，亦称行指针。
指针数组
定义 int *p[n];
[]优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组，它有n个指针类型的数组元素。这里执行p+1时，则p指向下一个数组元素，这样赋值是错误的：p=a；因为p是个不可知的表示，只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值，a的首地址的值。
如要将二维数组赋给一指针数组:
int *p[3];
int a[3][4];
p++; //该语句表示p数组指向下一个数组元素。注：此数组每一个元素都是一个指针
for(i=0;i<3;i++)
p[i]=a[i]
这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]
所以要分别赋值。
这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。
还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。
比如要表示数组中i行j列一个元素：
*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]
优先级：()>[]>*
出处：http://www.cnblogs.com/hongcha717/archive/2010/10/24/1859780.html
一、指针数组和数组指针的内存布局
初学者总是分不出指针数组与数组指针的区别。其实很好理解：指针数组：首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身的大小决定，每一个元素都是一个指针，在32 位系统下任何类型的指针永远是占4 个字节。它是“储存指针的数组”的简称。
数组指针：首先它是一个指针，它指向一个数组。在32 位系统下任何类型的指针永远是占4 个字节，至于它指向的数组占多少字节，不知道，具体要看数组大小。它是“指向数组的指针”的简称。
下面到底哪个是数组指针，哪个是指针数组呢：
A)
int *p1[10];
B)
int (*p2)[10];
每次上课问这个问题，总有弄不清楚的。这里需要明白一个符号之间的优先级问题。
“[]”的优先级比“*”要高。p1 先与“[]”结合，构成一个数组的定义，数组名为p1，int *修饰的是数组的内容，即数组的每个元素。那现在我们清楚，这是一个数组，其包含10 个指向int 类型数据的指针，即指针数组。至于p2 就更好理解了，在这里“（）”的优先级比“[]”高，“*”号和p2 构成一个指针的定义，指针变量名为p2，int 修饰的是数组的内容，即数组的每个元素。数组在这里并没有名字，是个匿名数组。那现在我们清楚p2 是一个指针，它指向一个包含10 个int 类型数据的数组，即数组指针。我们可以借助下面的图加深理解：
二、int (*)[10] p2-----也许应该这么定义数组指针
这里有个有意思的话题值得探讨一下：平时我们定义指针不都是在数据类型后面加上指针变量名么？这个指针p2 的定义怎么不是按照这个语法来定义的呢？也许我们应该这样来定义p2：int (*)[10] p2;
int (*)[10]是指针类型，p2 是指针变量。这样看起来的确不错，不过就是样子有些别扭。其实数组指针的原型确实就是这样子的，只不过为了方便与好看把指针变量p2 前移了而已。你私下完全可以这么理解这点。虽然编译器不这么想。^_^
三、再论a 和&a 之间的区别
既然这样，那问题就来了。前面我们讲过a 和&a 之间的区别，现在再来看看下面的代码：int main()
{
char a[5]={'A','B','C','D'};
char (*p3)[5] = &a;
char (*p4)[5] = a;
return 0;
}
上面对p3 和p4 的使用，哪个正确呢？p3+1 的值会是什么？p4+1 的值又会是什么？毫无疑问，p3 和p4 都是数组指针，指向的是整个数组。&a 是整个数组的首地址，a是数组首元素的首地址，其值相同但意义不同。在C 语言里，赋值符号“=”号两边的数据类型必须是相同的，如果不同需要显示或隐式的类型转换。p3 这个定义的“=”号两边的数据类型完全一致，而p4 这个定义的“=”号两边的数据类型就不一致了。左边的类型是指向整个数组的指针，右边的数据类型是指向单个字符的指针。在Visual C++6.0 上给出如下警告：
warning C4047: 'initializing' : 'char (*)[5]' differs in levels of indirection from 'char *'。
还好，这里虽然给出了警告，但由于&a 和a 的值一样，而变量作为右值时编译器只是取变量的值，所以运行并没有什么问题。不过我仍然警告你别这么用。
既然现在清楚了p3 和p4 都是指向整个数组的，那p3+1 和p4+1 的值就很好理解了。
但是如果修改一下代码，把数组大小改小点，会有什么问题？p3+1 和p4+1 的值又是多少呢？
int main()
{
char a[5]={'A','B','C','D'};
char (*p3)[3] = &a;
char (*p4)[3] = a;
return 0;
}
甚至还可以把代码再修改，把数组大小改大点：
int main()
{
char a[5]={'A','B','C','D'};
char (*p3)[10] = &a;
char (*p4)[10] = a;
return 0;
}
这个时候又会有什么样的问题？p3+1 和p4+1 的值又是多少？
上述几个问题，希望读者能仔细考虑考虑，并且上机测试看看结果。
测试结果:
(1).char (*p2)[5]=a;必须使用强制转换,如:char (*p2)[5]=(char (*)[5])a;
(2).把数组大小改变,都会编译不通过,提示:
error C2440: 'initializing' : cannot convert from 'char (*)[5]' to 'char (*)[3]'
error C2440: 'initializing' : cannot convert from 'char (*)[5]' to 'char (*)[10]'
(3).把以上程序测试代码如下:
int main()
{
char a[5]={'a','b','c','d'};
char (*p1)[5]= &a;
char (*p2)[5]=(char (*)[5])a;
printf("a=%d\n",a);
printf("a=%c\n",a[0]);
printf("p1=%c\n",**p1);
printf("p2=%c\n",**p2);
printf("p1+1=%c\n",**(p1+1));
printf("p2+1=%c\n",**(p2+1));
return 0;
}
输出:
a=1638208
a=a
p1=a
p2=a
p1+1=?
p2+1=?
Press any key to continue
结论:
根据指针类型及所指对象,表示指针大小,每次加1,表示增加指针类型大小的字节.----后面还会有解释说明.
四、地址的强制转换
先看下面这个例子：struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
假设p 的值为0x100000。如下表表达式的值分别为多少？
p + 0x1 = 0x___ ?
(unsigned long)p + 0x1 = 0x___?
(unsigned int*)p + 0x1 = 0x___?
我相信会有很多人一开始没看明白这个问题是什么意思。其实我们再仔细看看，这个知识点似曾相识。一个指针变量与一个整数相加减，到底该怎么解析呢？
还记得前面我们的表达式“a+1”与“&a+1”之间的区别吗？其实这里也一样。指针变量与一个整数相加减并不是用指针变量里的地址直接加减这个整数。这个整数的单位不是byte 而是元素的个数。所以：p + 0x1 的值为0x100000+sizof（Test）*0x1。至于此结构体的大小为20byte，前面的章节已经详细讲解过。所以p +0x1 的值为：0x100014。
(unsigned long)p + 0x1 的值呢？这里涉及到强制转换，将指针变量p 保存的值强制转换成无符号的长整型数。任何数值一旦被强制转换，其类型就改变了。所以这个表达式其实就是一个无符号的长整型数加上另一个整数。所以其值为：0x100001。
(unsigned int*)p + 0x1 的值呢？这里的p 被强制转换成一个指向无符号整型的指针。所以其值为：0x100000+sizof（unsigned int）*0x1，等于0x100004。
上面这个问题似乎还没啥技术含量，下面就来个有技术含量的：在x86 系统下，其值为多少？
intmain()
{
int a[4]={1,2,3,4};
int *ptr1=(int *)(&a+1);//指向a数组后面的内存单元，&a+1表示向后移16个存储单元
int *ptr2=(int *)((int)a+1);//表示a的存储单元的地址增加一个字节，(int a)+1实际上就是两个int类型的数据相加，因为它们类型是相同的；但是如果这里的a是一个float类型（和1的类型不同）的话，那么就是a+1*（sizeof（float））
printf("%x,%x",ptr1[-1],*ptr2);//ptr1[-1]其实指向的是a数组的最后一个单元，*ptr2则表示a数组的地址后移一个字节之后的4个连续存储单元所存储的值
return 0;
}
这是我讲课时一个学生问我的题，他在网上看到的，据说难倒了n 个人。我看题之后告诉他，这些人肯定不懂汇编，一个懂汇编的人，这种题实在是小case。下面就来分析分析这个问题：
根据上面的讲解，&a+1 与a+1 的区别已经清楚。
ptr1：将&a+1 的值强制转换成int*类型，赋值给int* 类型的变量ptr，ptr1 肯定指到数组a 的下一个int 类型数据了。ptr1[-1]被解析成*(ptr1-1)，即ptr1 往后退4 个byte。所以其值为0x4。
ptr2：按照上面的讲解，(int)a+1 的值是元素a[0]的第二个字节的地址。然后把这个地址强制转换成int*类型的值赋给ptr2，也就是说*ptr2 的值应该为元素a[0]的第二个字节开始的连续4 个byte 的内容。
其内存布局如下图：
int checkSystem()
{
union check
{
int i;
char ch;
} c;
c.i = 1;
return (c.ch ==1);//如果当前系统为大端模式这个函数返回0；如果为小端模式，函数返回1。
}
如果当前系统为大端模式这个函数返回0；如果为小端模式，函数返回1。也就是说如果此函数的返回值为1 的话，*ptr2 的值为0x2000000。如果此函数的返回值为0 的话，*ptr2 的值为0x100。具体解释如下：
要解决大小端问题，首先要将数据表示成16进制的形式，在16进制中，每两位代表一个字节，也就是说，int类型的整数1表示为0x00000001，之所以是8位是因为int类型是4字节的，所以4*2=8；
地址从左到右是按照从低位地址到高位地址上升的；低位----->高位；
对于大端问题来说，是指数据的高字节，保存在内存的低地址中，而数据的低字节，保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放，所以i在内存中的表示为：
00 第一位00 第二位00第三位 01第四位；低位------->高位
对于小端问题来说，是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致，所以i在内存中的表示为：
01 00 00 00;；低位------->高位
需要注意的是，一个存储单位就是一个字节，而在一个存储单位中，数据是不需要颠倒顺序，只需要按照原型放进去就可以的；
由上面的解释可知，从大端存储中从左到右读出来的数据就是正常的数据，比如上面的00000001；而对于小段存储来说，需要从右向左读才能读出正确的数据，比如上面的。
224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
