周报1

数组的储存形式

数组在内存中是作为一个整体分配内存的，数组元素的内存地址是连续的，其差值为数组储存的数据类型的字节长度。如果储存的是int型，那么数组元素的地址都相差4；如果是char型，那么数组元素的地址都相差1。比较特殊的是，数组变量的值是该数组第0个元素的地址，即数组的首地址。
示例代码：

    #include <stdio.h>
    #define SIZE 4

    int main(void)
    {
        int i = 0 ;
        int array_int[SIZE] = {1,2,3,4,};
        double array_ch[SIZE] = {1.1,2.2,3.3,4.4｝;

        printf ("array_int = %p\n",array_int);
        for (i = 0 ; i < SIZE ; ++i )
        {
            printf("&array_int[%d] = %p\n",i,&array_int[i]);
        }

        for(i = 0 ; i < SIZE ; ++i )
        {
            printf("&array_ch[%d] = %p\n",i,&array_ch[i]);
        }
        return 0;
     }

注意事项：
以下是访问越界数组元素的代码：

   01#include <stdio.h>
   02#define SIZE 3                                 /*数组容量*/
   03
   04int main(void){
   05   int i = 0 ;
   06    /*在数组前后定义两个int变量*/
   07   int left = 12 ;                                                /*数组前面的变量*/
   08   int data[SIZE] = {1,2,3};                                      /*定义并初始化数组*/
   09   int right = 17;                                                /*数组后面的变量*/
   10
   11    /*打印数组元素，包括越界元素地址*/
   12    for(i = -1 ; i < SIZE ; ++i )                                  /*i从-1递增到3/
   13      printf("&data[%2d] = %x\n",i,&data[i]);
   14    /*打印left,right的值*/
   15    printf("\n&left = %p\n&right = %p\n\n",&left,&right）；
   16    /*打印越界数组元素和附近变量的值*/
   17    printf("data[-1] = %-8d,data[3] = %-8d\n",data[-1],data[3]);   /*输出data[-1],data[3]*/
   18    printf("left = %-8d,right = %-8d\n\n",left,right);             /*输出left和right的值*/
   19
   20    /*改变越界数组元素的值*/
   21    data[-1] = 2;
   22    data[3] = 4;
   23    /*再次打印越界数组元素和附近变量的值*/
   24    printf("data[-1] = %-8d,data[3] = %-8d\n",data[-1],data[3]);   /*输出data[-1],data[3]*/
   25    printf("left = %-8d,right = %-8d\n\n",left,right);             /*输出left和right的值*/
   26
   27    return 0;
   28} 

运行结果如下：

    &data[-1]  =  12ff60
    &data[0]   =  12ff64
    &data[1]   =  12ff68
    &data[2]   =  12ff6c
    &data[3]   =  12ff70

    &left    = 12ff60
    &right  = 12ff5c

    data[-1] = 12              , data[3] = 4206956
    left         =12              , right     = 17

    data[-1] = 2               , data[3] = 4
    left        =2                , right     = 17

int型数组data的容量为3，因此，data【-1】和data【3】都是危险的越界元素。int型变量left和right是紧挨着data定义的变量，它们的内存空间有可能是连续的（是否连续以及如何分布都由编译器决定）。
结论：使用越界元素可能会改变其他变量值。因此，使用数组时，需要特别小心，不要使用越界元素。

一维数组示例

1数列查找
在无序序列中查找一个数。以下例子可以把无序序列保存在数组结构中，通过遍历数组，将目标数与所有的数组元素比较。实现方法如下：

       #include <stdio.h> 
       #define SIZE 10
       int main(void){                                                                                           
           int i;    
           int targrt;        
           int sequence[SIZE] = {3,78,41,2,40,5,33,8,7,24};    
               for(i = 0;i < SIZE; ++i)        
                   printf("%-4d",sequance[i]);    
               printf("\nInput the target value: \n");
               scanf("%d",&target);
               
               for(i = 0;i < SIZE; ++i)      
                   if(sequence[i] == target)            
                   break;    }       
                   if(SIZE == i)        
                       printf("Can not find %d in this sequence.\n");   
                   else        
                       printf("%d is the %dth(st/nd) element in this sequance\n",target,i+1);
           return 0;
        }  
当输入为4时，结果为Can not find 4 in this sequence.  
当输入为7时，结果为7 is the 9th(st/nd) element in this sequence.
       
(3)数列排序   把无序整数数列按照从大到小的顺序输出。示例代码如下：  
 ①   
 #include <stdio.h>   
 #define SIZE 10     
 int main(void){       
     int i,j;      
     int keyvalue[SIZE] = [0];      
     int maxindex;       
     int tmp;             
     printf("Please input %d intergets:\n",SIZE);             
     for(i = 0;i < SIZE; ++i)           
         scanf("%d",&keyvalue[i]);                  
         for(i = 0;i < SIZE - 1; ++i)           
              maxindex = i;                      
              for(j = i + 1;j < SIZE; ++j) {                        
                    if(keyvalue[maxindex] < keyvalue[j])                  
                            maxindex = j;                                 
                    if(maxindex! = i){                                  
                            tmp = keyvalue[maxindex];                  
                            keyvalue[maxindex] < keyvalue[i];                  
                            keyvalue[i] = tmp;              
                   }           
              }          
          printf("Print these intergers in ascending:\n");  
                             
          for(i = 0;i < SIZE; ++i)               
          printf("%-4d",keyvalue[i]");                          
          printf("\n");                      
          return 0 ;      
     }