实验5 数组和函数

实验任务1

#include <stdio.h>

const int N=3;
int main(){
    int a[N] = {1,2,3};
    int i;
    
    printf("通过数组名及下标直接访问数组元素：\n");
    for(i=0; i<N; i++)
        printf("%d: %d\n", &a[i], a[i]);
    
    printf("通过地址间接访问数组元素：\n");
    for(i=0; i<N; i++)
        printf("%d: %d\n", a+i, *(a+i));
        
    return 0;
}

思考题

1.数组元素在内存中连续存放

2.对于数组元素及其地址的访问

  a+i和&a[i]等价，都表示数组元素a[i]的地址

  *(a+i)和a[i]等价，都表示数组元素a[i]

 

 

实验任务2

 

#include <stdio.h>
const int LINE = 2;
const int COL = 3;

int main(){
    int a[LINE][COL] = {1,2,3,4,5,6};
    int i, j;
    
    printf("通过数组名及下标直接访问数组元素：\n");
    for(i=0; i<LINE; i++)
        for(j=0; j<COL; j++)
            printf("%d: %d\n", &a[i][j], a[i][j]);
            
    printf("通过地址间接访问数组元素：\n");
    for(i=0; i<LINE; i++)
        for(j=0; j<COL; j++)
            printf("%d: %d\n", a[i]+j, *(a[i]+j));    
            
    printf("二维地址中a+i表示的地址：\n");
    for(i=0; i<LINE; i++)
        printf("a + %d: %d\n", i, a+i);    
        
    return 0;
}

 

思考题

1.c语言中，二维数组在内存中按行存放

2.对于二维数组元素及其地址的访问

a[i]+j和&a[i][j]等价，都表示二维数组元素a[i][j]的地址

*(a[i]+j)和a[i][j]等价，都表示二维数组元素a[i][j]

3.对于二维数组a[2][3]

a和&a[0]等价，都表示二维数组第0行的地址

a+1和&a[1]等价，都表示二维数组第0行的地址

 

 

实验任务3

// 使用指针变量间接访问一维数组
#include <stdio.h> 
#include <stdlib.h>

const int N = 3;

int main(){
    int a[N];
    int *p, i;
    
    // 通过指针变量p， 完成数组元素输入
    for(p=a; p<a+N; p++)
        scanf("%d", p);
        
    // 通过指针变量p， 完成数组元素输出
    for(p=a; p<a+N; p++)
        printf("%d", *p);
    printf("\n");
    
    p = a;
    // 通过指针变量p, 完成数组元素的输入
    for(i=0; i<N; i++)
        scanf("%d", p+i); 
        
    // 通过指针变量p， 完成数组元素输出
    for(i=0; i<N; i++)
        printf("%d", *(p+i));
    printf("\n");
    
    return 0;
}

思考题

1. 程序中，指针变量p在使用时指向确定地址
2. 程序源码中，line12-line13执行完后， 指针变量p指向a+N。Line16-line17执行完后，指针变量p指向a+N
3. 程序源码中，line22-line23执行完后， 指针变量p指向a。Line26-line27执行完后，指针变量p指向a
4. 对比Line16-line17和Line26-line27，他们通过指针变量间接访问一维数组时差异在于前者p所指的位置随着循环的进行而改变，后者p所指的位置不变。这样就可以在多种不同场合根据情况来灵活使用指针变量p

 

 

 

实验任务4

 

// 使用指针变量间接访问二维数组
#include <stdio.h>

int main(){
    int a[2][3] = {1,2,3,4,5,6};
    int i,j;
    int *p;   // p是指针变量，存放int型数据的地址
    int (*q)[3]; // q是指针变量，存放包含有3个元素的一维数组的地址
    
    // 通过指针变量p间接访问，输出二维数组a的元素值
    for(p=a[0]; p<a[0]+6; p++)
        printf("%d ", *p);
    printf("\n");
    
    // 通过行指针变量q间接访问，输出二维数组a的元素值
    for(q=a; q<a+2; q++)
        for(j=0; j<3; j++)
            printf("%d ", *(*q+j));
    printf("\n"); 
    
    return 0;
} 

 

思考题

1. 程序源码中，line11改成如下形式是可以的

for(p=&a[0][0]; p<&a[0][0]+6; p++)

1. 程序源码中，line18中，*q+j表示第q-a行第j列的元素地址，*(*q+j)表示第q-a行第j列的元素值。
2. 结合line11-line12和line16-line18，可知二维数组中，指向数组元素的指针变量p和指向一维数组指针变量q前者在访问时可以直接对二维数组进行访问，更加方便实用，而后者则要另外设置循环变量进行一维数组向二维数组的转换，然后再使用，所以会麻烦一些，在定义时也要更麻烦一些。
3. 基于对这个实验的理解，设有如下代码

Int a[2][3];

Int (*q)[3];

Int *p;

p = a[0];

q = a;

则，以下能够正确表示数组元素a[1][2]地址的有 ABCDEFG

1. &a[1][2]
2. a[0]+5
3. p+5
4. *q+5
5. *(q+1)+2
6. &a[0][0]+1*3+2
7. a[0]+1*3+2

 

 

 

 

实验任务5-1

// 练习：使用二分查找，在一组有序元素中查找数据项
// 形参是数组，实参是数组名
#include <stdio.h> 

const int N=5;

int binarysearch(int x[], int n, int item);  // 函数声明

int main(){
    int a[N]={2,7,19,45,66};
    int i, index, key;
    
    printf("数组a中的数据:\n");
    for(i=0; i<N; i++)
        printf("%d ",a[i]);
    printf("\n");
    
    printf("输入待查找的数据项： ");
    scanf("%d",&key) ;
    
    // 调用函数binarysearch()在数组a中查找指定数据项key，并返回查找结果给index
    // 补足代码
    index=binarysearch(a, N, key);
    
    if(index>=0)
        printf("%d在数组中，下标为%d\n", key, index);
    else
        printf("%d不在数组中\n", key); 
        
    return 0;
} 

// 函数功能描述
// 使用二分查找算法在数组x中查找特定值item，数组X大小为n
// 如果找到，返回其下标
// 如果没找到，返回-1
int binarysearch(int x[], int n, int item){
    int low, high, mid;
    
    low=0;
    high=n-1;
    
    while(low<=high){
        mid = (low+high)/2;
        
        if(x[mid] == item)
            return mid;
        else if(x[mid]>item)
            high = mid - 1;
        else
            low = mid + 1; 
    }
    
    return -1;
}

 

 

 

实验任务5-2

// 练习：使用二分查找，在一组有序元素中查找数据项
// 形参是指针变量，实参是数组名
#include <stdio.h> 

const int N=5;

int binarysearch(int *x, int n, int item);  // 函数声明

int main(){
    int a[N]={2,7,19,45,66};
    int i, index, key;
    
    printf("数组a中的数据:\n");
    for(i=0; i<N; i++)
        printf("%d ",a[i]);
    printf("\n");
    
    printf("输入待查找的数据项： ");
    scanf("%d",&key) ;
    
    // 调用函数binarysearch()在数组a中查找指定数据项key，并返回查找结果给index
    // 补足代码
    index=binarysearch(a, N, key);
    
    if(index>=0)
        printf("%d在数组中，下标为%d\n", key, index);
    else
        printf("%d不在数组中\n", key); 
        
    return 0;
} 

// 函数功能描述
// 使用二分查找算法在数组x中查找特定值item，数组X大小为n
// 如果找到，返回其下标
// 如果没找到，返回-1
int binarysearch(int *x, int n, int item){
    int low, high, mid;
    
    low=0;
    high=n-1;
    
    while(low<=high){
        mid = (low+high)/2;
        
        if(item==*(x+mid))
            return mid;
        else if(item<*(x+mid))
            high = mid - 1;
        else
            low = mid + 1; 
    }
    
    return -1;
}

 

 

 

实验任务6

// 练习：使用选择法对字符串按字典序排序 
#include <stdio.h> 
#include <string.h>

const int N=5;

void delectSort(char str[][20], int n);     // 函数声明，形参str是二维数组名 
int main(){
    char name[][20] = {"Bob", "Bill", "Joseph", "Taylor", "George"};
    int i;

    printf("输出初始名单：\n");
    for(i=0; i<N; i++)
        printf("%s\n", name[i]);
    
    delectSort(name,N);    // 调用 选择法对数组name数组中的字符串排序
    
    printf("按字典序输出名单：\n");
    for(i=0; i<N; i++)
        printf("%s\n", name[i]);
    
    return 0; 
}


// 函数定义
// 函数功能描述：使用选择法对二维数组str中的n个字符串按字典序排序
void delectSort(char str[][20], int n){
    int i, j, k;
    char temp[100];
    
    for(i=0; i<n-1; i++){
        k=i;    // k用于记录当前最小元素的下标
        
        for(j=i+1; j<n; j++) 
            if (strcmp(str[j],str[k])==-1)
                k=j;    // 如果str[j]比当前最小元素还要小，就更新k，确保它总是存放最小元素的下标
                
        if(k != i){    // 找到最小元素后，交换str[i]和str[k]
            strcpy(temp, str[i]);
            strcpy(str[i], str[k]);
            strcpy(str[k], temp);
        } 
    }
}