chapter1 数组

   1.一维数组初始化：函数体外：初始化为0   函数体内：无初始化，初始化部分，则后面也会被初始化为0，不是默认类型则自动调用默认构造函数初始化

    2. 定义一维数组的引用：  int (&p)[6] = a;

    3.c风格字符串与字符数组的区别：字符串后默认加上'\0',所以长度较字符数组多1（所以用字符串常量来定义字符数组时注意长度的问题）

    4.字符串输出遇'\0'终止

    5.二维数组的几种赋值方式：省略内嵌花括号的区别，

    6.二维数组做函数参数，需要指明第二维的大小

    7.行优先存储与列优先存储

    8. 针对数组a[3][3]-->访问a[1][4] = a[2][1] = *(a+7);

    9.二维数组的动态声明：先动态声明一维int* [m]，再对一维的int *[i]  -->a[i]动态声明二维的int [n]

                                           int **a = new int* [m];

                                            for(int i = 0; i < m; ++i)    

                                                    a[i] = new int[n];-->对于m中的每行，有一个n 个数的一维数列 

       释放的时候先释放二维的delete []a[i]，再delete [] a

       访问：a[i][j]   *(*(a+i) + j)  不能a [i * n + j]-->原因：静态数组是连续的，而动态数组不是

   10.int a[3][4]-->a的类型int (*)[4]    -->*(a+i)或者a[i] 的类型是 int *

        *a是int * 类型    &a是int (*)[3][4]类型  **a 是int类型

        int a[3]  -->a的类型int*  

   11.数组的首地址是常量，不可变更

   12. 正数负数在内存中存储：存放补码，正数源码和补码一样，负数补码在源码基础上：符号不变，其他取反加1  

            输入16进制数和输入十进制数存储的不同，10进制需要转化成补码形式，而16进制直接相当于补码形式

                                                                    (16进制数)0x12345678---->(内存中)78 56 34 12  -->小端存储模式

(10进制）  0xffffffff+1--> -(2的31次方）<---(16进制数)0x80000000----->          00 00  00 08  

 注意的问题：16进制负数数作输入的时候，直接以小端模式按字节存入内存，而十进制负数来的时候要转换成补码格式

                      输入 -1-->0x80000001-->(补码)内存中0xffffffff    输出的时候 -->变回原码0x80000001-->-1

                      输入0xffffffff-->内存中0xffffffff,  输出：变成原码0x80000001--->-1

（16进制数）0x800000 00--->(内存小端存储)00000080--->输出：  16进制：0x80000000      十进制：-(2的31次方）

 (16进制数  ) 0x ff ff ff ff ff --->(内存)ff ff ff ff--->输出： 16进制：0xff ff ff ff         十进制  ：-1

 (10进制数） -1                   -->(内存)ff ff ff ff-->...

13.数组顺时针旋转90度

void rotate(int (*a)[3], int n)
{
    int i, j;
    int top;
    for(i = 0; i < n/2; ++i)
    {
        for(j = i; j < n - 1 - i; ++j)
        {
            top = a[i][j];
            a[i][j] = a[n-1-j][i];
            a[n-1-j][i] = a[n-1-i][n-1-j];
            a[n-1-i][n-1-j] = a[j][n-1-i];
            a[j][n-1-i] = top;
        }
    }
}

14.数组乘积，不能使用除法运算

src: a[4] = {2, 3, 4, 5}    result:b[4] = {60, 40, 30, 24}

int *cal(int *input, int n)
{
    int *arr = malloc(n *sizeof(int));
    int i;
    arr[0] = 1;
    for(i = 1; i < n; ++i)
        arr[i] = arr[i-1]*input[i-1];
   arr[0] = input[n-1];
    for(i = n-2; i > 0; --i)
    {
        arr[i] *= arr[0];
        arr[0] *= input[i];
    }
    return arr;
}

  15.找出n个数中的最大的2个数的最少需要比较的次数：n +logn   -2

                    参考 http://blog.csdn.net/keyeagle/article/details/6107198 

  16.   求出一个数组中这样的a[i]，左边的都比它小，右边的都比它大

                  思路：辅助数组：记录每个a[i]右边的最小值(包括它本身),比较两数组a[i] 和b[i] 相等的话且左边的最大值不比a[i]大表示满足条件

void func(int *arr, int n)
{
    int min = arr[n-1];
    int tmp[n];
    int i;
     tmp[n-1] = arr[n-1];
    for(i = n-2; i >= 0 ; --i)//从后向前生成右边最小数组
    {
        if(arr[i] <  min)
            min = arr[i];
        tmp[i] = min;
    }

    int max = tmp[0];
    for(i = 0; i < n; ++i)//从左到右找相等且左边最大值不大于a[i]
    {
        if(arr[i] <  max)
        {
            continue;
        }
        max = arr[i];
        if(max == tmp[i])
            printf("%-3d", arr[i]);
    }
}

   17.一个数组中一个数出现的次数超过数组长度的一半

void func(int *arr, int n)
{
    int signal_num;
    int count = 0, i;
    for(i = 0; i < n; ++i)
    {
        if(count == 0)
        {
            signal_num = arr[i];
            count++;
        }else{
            if(arr[i] != signal_num)
                count--;
            else
                count++;
        }
    }
    printf("%d\n", signal_num);
}