学习记录第十一天

一维数组作为函数参数
在C语言中，一维数组可以直接作为函数的参数传递。当数组作为参数时，实际上传递的是数组首元素的地址。

一维数组作为函数参数时，通常只需要传递数组名（即数组首元素的地址）和数组的长度。

void printArray(int arr[]，int len) 
{
    // 函数体
}

void printString(char s[])
{
    //函数体
}

二维数组作为函数参数
二维数组作为函数参数时，需要传递数组名（即数组首元素的地址），以及数组的行数和列数。例如：

void print2DArray(int array[][10], int rows) 
{
    // 函数体
}

在二维数组的例子中，列数必须在函数声明中明确指定，而行数可以作为参数传递。这是因为C语言在编译时需要知道数组的列数来正确地计算元素的地址。
注意事项
  1.在函数参数声明中，二维数组需要指定列数。
  2.函数内部通过数组名访问元素时，实际上是通过指针进行操作。
  3.当传递数组到函数时，函数内部操作的是数组的副本，但是由于数组名本身就是地址，所以函数内部对数组元素的修改会影响到原始数组。

一维数组排序函数：

void chooseSort(int a[],int len)  // 选择排序
{
    int i,j,t;
    for(i = 0;i < len -1;++i)
    {
        for(j = i + 1;j < len;++j)
        {
            if(a[i] > a[j])
            {
                t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
    }
}

void bubblingSort(int a[],int len) // 冒泡排序
{
    int i,j,t;
    for(i = len - 1;i > 0;--i)
    {
        for(j = 0;j < i;++j)
        {
            if(a[j] > a[j + 1])
            {
                t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }
        }
    }
}

void insertSort(int a[],int len)   //插入法排序
{
    int i,j,t;
    for(i = 1;i < len;++i)
    {
        t = a[i];
        j = i;
        while(j > 0 && a[j - 1] > t )
        {
            a[j] = a[j - 1];
            --j;
        }
        a[j] = t;
    }
}

一维字符型数组：

void myPuts(char s[])  //打印字符串
{
    int i = 0;
    while(s[i] != '\0')
    {
        putchar(s[i]);
        ++i;
    }
    putchar('\n');
}

int myStrlen(char s[])  //有效字符个数
{
    int i;
    for(i = 0;s[i] != '\0';++i)
    {
    }
    return i;
}

void myStrcpy(char dest[],char src[])  //字符串拷贝
{
    int i = 0;
    while(src[i] != '\0')
    {
        dest[i] = src[i];
        ++i;
    }
    dest[i] = '\0';
}

void myStrcat(char dest[],char src[])  //字符串拼接
{
    int len = myStrlen(dest);
    int i = 0;
    while(src[i] != 0)
    {
        dest[len + i] = src[i];
        ++i;
    }
    dest[len + i] = '\0';
}

int myStrcmp(char s1[],char s2[])  //字符串比较
{
    int i = 0;
    while(s1[i] == s2[i] && s1[i] != '\0' && s2[i] != '\0')
    {
        ++i;
    }
    i = s1[i] - s2[i];
    return i;
}

二维数组：

void printArray2D(int a[][4],int rows)   //打印二维数组
{
    int cols = sizeof(a[0]) / sizeof(a[0][0]);
    int i,j;
    for(i = 0;i < rows;++i)
    {
        for(j = 0;j < cols;++j)
        {
            printf("%-4d",a[i][j]);
        }
        myPuts("");
    }
}

int maxArray2D(int a[][4],int rows) //二维数组最大值
{
    int cols = sizeof(a[0]) / sizeof(a[0][0]);
    int i,j,max = a[0][0];
    for(i = 0;i < rows;++i)
    {
        for(j = 0;j < cols;++j)
        {
            if(a[i][j] > max)
            {
                max = a[i][j];
            }
        }
    }
    return max;
}

二位字符型数组：

void printStrings(char s[][100],int rows)  //打印
{
    int i;
    for(i = 0;i < rows;++i)
    {
        myPuts(s[i]);
    }
}

void sortStrings(char s[][100],int rows)  //字符串排序
{
    int i,j;
    char c[100];
    for(i = 0;i < rows;++i)
    {
        for(j = i + 1;j < rows;++j)
        {
            if(myStrcmp(s[i],s[j]) > 0)
            {
                myStrcpy(c,s[i]);
                myStrcpy(s[i],s[j]);
                myStrcpy(s[j],c);
            }
        }
    }
}

int stringFind(char s[][100],int rows,char str[])  //字符串查找
{
    int begin,mid,end;
    begin = 0;
    end = rows - 1;
 
    while(begin <= end)
    {
        mid = (begin + end) / 2;
        if(myStrcmp(str,s[mid]) > 0)
        {
            begin = mid + 1;
        }
        else if(myStrcmp(str,s[mid]) < 0)
        {
            end = mid -1;
        }
        else
        {
            break;
        }
    }
 
    if(begin <= end)
    {
        return mid;
    }
    else
    {
        return -1;
    }
}