黑马程序员——C语言——数组和字符串

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1. 数组基本概念和分类

数组：相同类型的数据按照一定顺序排列的集合。

按存储内容分类

数值数组

字符数组

指针数组

结构数组

按维度分

一维数组

二维数组

多维数组

2. 一维数组

定义方式： 类型说明符   数组名[常量表达式]；

a 数组的长度可以是常量也可以是常量表达式还可以是宏。

b 数组表示符遵守标识符命名规范。

c 数组名不能与其他变量名同名。

d 数组的长度不可以是变量。(Xcode中做了优化，使用时不会报错)

注意：

数组如果没有初始化，数组元素有值，是垃圾数

部分初始化时，数组中没有被初始化的元素也有值，都是0。eg：int a[5]={1,2,3};   //没有初始化的元素值是0

如果使用先定义后初始化的方式，没有被初始化的元素不会被自动初始化为0.     eg： int b[3];  b[0]=2;      b[1], b[2]不会被自动初始化为0。

数组遍历示例代码：

#include <stdio.h>

int main(int argc, const char * argv[]) {
    //定义一个变量保存数组长度
    int len=0;
    printf("Please enter the length of array:\n");
    //接收从键盘输入的数组长度
    scanf("%d",&len);
    //定义一个数组
    int a[len];
    //for循环给数组元素赋值
    for (int i=0; i<len; i++) {
        printf("请输入第%d个元素:",i);
        scanf("%d",&a[i]);
    }
    //for循环打印数组元素
    for (int i=0; i<len; i++) {
        printf("a[%d]=%d\n",i,a[i]);
    }
    return 0;
}

一维数组的存储方式：

数组分配的是一段连续的内存空间

数组名代表数组的首地址，从首地址开始逐个存储

每个元素占相同的字节数

元素之间的地址是连续的

注意：数组名是一个常量，存放的是数组的首地址，即数组第一个元素的地址。

一维数组长度计算方法：

数组在内存中占用的总字节数：sizeof（数组名）

数组长度：sizeof（数组名）/sizeof(数组类型)    eg： int a[5];      sizeof(a)/sizeof(int)

数组元素作为函数的实参是值传递

数组名作为函数的实参是地址传递

数组名作为函数参数注意事项：

形参数组和实参数组的类型必须一致，否则会引起错误

形参数组和实参数组的长度可以不相同

形参数组的长度可以不写

冒泡排序代码示例：

#include <stdio.h>
void BubbleSort(int a[],int length){
    //外层循环控制比较的趟数
    for (int i=0; i<length-1; i++) {
        //内层循环每趟比较把最大数下沉
        for (int j=0; j<length-i-1; j++) {
            //前一个元素比后一个元素值大，则两个数交换顺序
            if (a[j]>a[j+1]) {
                int temp;
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    }
}

int main(int argc, const char * argv[]) {
    //定义一个变量保存数组长度
    int len=0;
    printf("Please enter the length of array:\n");
    //接收从键盘输入的数组长度
    scanf("%d",&len);
    //定义一个数组
    int a[len];
    //for循环给数组元素赋值
    for (int i=0; i<len; i++) {
        printf("请输入第%d个元素:",i);
        scanf("%d",&a[i]);
    }
    //调用冒泡排序方法
    BubbleSort(a, len);
    for (int i=0; i<len; i++) {
        printf("%d ",a[i]);
    }

    return 0;
}

选择排序：

思想：每一趟比较都把最小数保存到未排列序列的第一个位置

代码示例：

#include <stdio.h>

int main(int argc, const char * argv[]) {
    //定义一个变量保存数组长度
    int len=0;
    printf("Please enter the length of array:\n");
    //接收从键盘输入的数组长度
    scanf("%d",&len);
    //定义一个数组
    int a[len];
    //for循环给数组元素赋值
    for (int i=0; i<len; i++) {
        printf("请输入第%d个元素:",i);
        scanf("%d",&a[i]);
    }
    
    //选择排序实现
    for (int i=0; i<len-1; i++) {
        //假设每次a[i]都是最小元素
         int min=i;
        for (int j=i+1; j<len; j++) {
            if (a[min]>a[j])
                //找到最小元素的下标保存到min中
                min=j;

        }
        //如果找到比a[i]小的元素，交换a[i]和最小元素的值，否则不交换
        if (i!=min) {
            int temp;
            temp=a[min];
            a[min]=a[i];
            a[i]=temp;
        }
        
    }
    
    for (int i=0; i<len; i++) {
        printf("%d ",a[i]);
    }
    return 0;
}

折半查找：

思想：在有序表中取中间元素作为比较对象，若给定值与中间元素的值相等，则查找成功，若给定的值小于中间元素的值，在左边区域查找，若给定的值大于中间元素，在右边区域找。

折半查找代码实现：

/**
 *用折半查找方法查找一个数据
 */
#include <stdio.h>
#define N  10

int binarySearch(int a[],int key){
    //low保存查找范围的低下标，high保存查找范围的高下标，mid保存查找范围的中间下标
    int low=0,high=N-1,mid;
    while (low<=high) {
        
        mid=(low+high)/2;
        
        //把要查找的值和中间元素的值比较，若相等则查找成功，返回下表
        if (key==a[mid]) {
            return mid;
        }else if (key<a[mid]) {
            //若小于中间元素的值，在左边区域查找
            high=mid-1;
        }else if (key>a[mid]){
        //若大于中间元素的值，在右边区域查找
            low=mid+1;
        }
    }
    //如果没有查找到，返回-1
   return -1;
}

int main(int argc, const char * argv[]) {
    //定义一个有序数组
    int a[N]={0,1,2,3,4,5,6,7,8,9};
    //定义一个变量，保存要查找的值
    int key=-1;
    printf("请输入要查找的值：");
    //接收从键盘输入的要查找的值
    scanf("%d",&key);
    
    int index=binarySearch(a, key);
    if (index!=-1) {
        printf("查找到了，下标是%d",index);

    }else{
        printf("没有该值！");
    }
               return 0;
}

3. 二维数组

二维数组可以看做一个特殊的一维数组

二维数组的存储：数组名代表数组的首地址，从首地址开始，依次存入第一行、第二行····行与行之间地址连续，行内地址也连续

二维数组做函数的参数可以省略第一维。

4. 字符串

字符串是位于双引号中的字符序列，在内存中以“\0”结束

C语言中没有字符串变量，可以用字符数组来保存字符串。

字符数组的定义：char  数组名[常量表达式]；

二维字符数组定义： char  数组名[常量表达式1][常量表达式2]；

字符数组的初始化

定义的同时初始化：char ch[3]={'a','b','c'};   char ch1[3]={'a'};     char ch2[3]={[2]='A'};

先定义后初始化：char c[3];  c[0]='a'; c[1]='b'; c[2]='c';

字符数组用来保存字符串

字符串在字符数组中以单个字符的形式保存。

字符数组存储字符串时初始化形式：

char str[4]={"abc"};    // str[0]='a'    str[1]='b'   str[2]='c'    str[3]='\0'

char str2[4]="abc";   //注意，此处数组长度必须是4，因为还要存储‘\0’

字符串的形式输入和输出

%s：输出字符串，从给定的地址开始，输出字符串，直到遇到'\0'结束     注意：以%d可以查看空字符

示例代码如下：

    char str[]="hello world";
    printf("%s\n",str);
    printf("%s\n",&str[6]);   //打印出world

字符数组也可以用%s打印

    char ch[10]={'a','b','c','d','e','\0'};   //加上'\0'
    for (int i=0; i<10; i++) {
        printf("ch[%d]=%d\n",i,ch[i]);
    }
    printf("%s\n",ch);  //用%s打印字符数组,如果没有<span style="font-family: Arial, Helvetica, sans-serif;">'\0'，用%s打印的时候会一直往下打印，知道遇到</span><span style="font-family: Arial, Helvetica, sans-serif;">'\0'</span>

%s接收从键盘输入的字符串注意事项：

以%s输入的时候，遇到空格结束

输入的字符串长度要小于数组长度

字符串长度计算：

strlen( ):字符串长度计算函数,计算长度不包含‘\0’

使用sizeof(数组名)计算时，如果数组中有'\0'，则计算长度不准确。

'\0'使用代码示例：

/**
 *判断某个字符是否出现在字符串中，如果出现，返回第一次出现的位置，不出现则返回-1
 */
#include <stdio.h>
int searchLetter(char c[],char ch){
    //'\0'判断字符串是否结束
    for (int i=0; c[i]!='\0'; i++) {
        //第一次出现要查找字符则返回出现位置
        if (ch==c[i]) {
            return i;
        }
    }
    //不在数组中则返回-1
    return -1;
    
}
int main(int argc, const char * argv[]) {
    //定义一个字符串
    char str[]="hello world";
    //保存要判断的字符
    char ch;
    printf("请输入要判断的字符：");
    //接收从键盘输入的字符保存在变量ch中
    scanf("%c",&ch);
    //定义一个变量接收函数返回值
    int result=searchLetter(str, ch);
    //根据返回值结果判断输入字符是否存在数组中
    if (result!=-1) {
        printf("字符%c第一次出现的下标是：%d",ch,result);
    }else{
        printf("字符%c不在该数组中!",ch);
    }
    return 0;
}

字符串处理函数

puts( ):字符串输出函数，可以自动换行，但不能格式化输出

使用格式：puts(字符数组名);

gets( ):字符串输入函数，可以接收空格，但是会有不安全警告

strcat(A,B):把字符串B连接到字符串A的后面

strcpy:(str1,str2):把str2拷贝到str1中，str2会覆盖到str1中的内容

strcmp(str1,str2):比较两个字符串的大小，从左至右逐个比较字符，按ASCII值大小比较，知道出现不同字符或遇到'\0'为止。