c语言基础（五）

数组

1.格式

类型名（int[10]）+变量名（arr）：int arr[10]表示包含十个int类型元素的数组。
定义数组的时候，数组的大小就确定了

2.数组初始化

完全初始化：int arr[s]={1,2,3,4,5,};
数组没有制定大小，编译器默认后面的初始化是完全初始化

在数组中，有{}则初始化，另外上式中5后边的,不影响
s这个数规定数组大小,当然也可以不规定数组的大小，但需要写出所有元素。
几个初始化的例子：
char buf[]={“ABC”}; 
char buf[]=”ABC”; 
int a[]={1,2,3};
部分初始化：int arr_[5] = {1, 2}; 
数组置零：int arr[5]={};

数组部分初始化：

    int arr[5];
    int arr_[5] = {1, 2};
    int arr_3[5] = {};
    int arr_4[5] = {[2]=100};

数组元素是从下标为0开始的
注：数组越界，编译器不检查，提高效率（牺牲了安全性）

3.左值和右值

int arr[s]={1,2,3,4,5,};左值右值以等号=分开
左值代表的是内存空间，右值代表的是值（内存空间的内容）
arr++作为左值？这在c语言中是不被允许的
数组名不能为左值，数组名是元素的地址，是常量
即：1.数组名在程序运行开始就确定了常数地址
2.没有多字节的数可以赋值
右值：数组名可以作为右值，打印的是地址，数组首元素的首地址
arr，&arr，&arr[0]的值相同，即表达的内容相同。
arr元素的地址，&arr数组的地址

4.传值调用

&是取地址运算符，& a为变量a的地址
*是指针运算符，*p为指针变量，p所指向存储单元的内容，而指针变量p中一般只存放地址
& arr[0]取数组首元素的首地址
*arr 取数组的首地址
传值调用就是左值右值的传递
数组名作为参数时，丢了数组本身的大小，退化成了一个指针
数组名作为参数传递的是地址(数组首元素首地址)
数组名作为参数，要加上元素个数

数组的几道例题

1.冒泡排序

#include<stdio.h>
void main(void)
{

    //冒泡排序
    int arr[10];

    //赋值
    int i = 0, j = 0, temp = 0;
    printf("请输入10个数，稍后我们将会按照冒泡排序进行排序：\n");
    for (i=0; i<10; i++)
        scanf("%d", arr+i);
    //  scanf("%d", &arr[i]);

    //遍历
    printf("---------------排序前-----------\n");
    for (i=0; i<10; i++)
    {
        //      printf("arr[%d] = %d.\n", i, arr[i]);
        printf(" %d", arr[i]);
    }

    printf("\n");
    //冒泡排序  
    //比较数组里相邻两个数,由小到大
    for (i=0; i<10-1; i++)
    {
        for (j=0; j<10-1-i; j++)
        {
            if (arr[j] > arr[j+1])
            {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;    
            }
        }   
    }

    printf("---------------排序后-----------\n");

    for (i=0; i<10; i++)
    {
        printf(" %d", arr[i]);
    }

    printf("\n");   
}

2.选择排序

#include<stdio.h>
void main(void)
{
    int arr[10];


    int i = 0, j = 0, temp = 0;
    printf("请输入10个数，稍后我们将按照选择排序进行排序：\n");

    for (i=0; i<10; i++)
        scanf("%d", arr+i);
    printf("---------------排序前-----------\n");
    for (i=0; i<10; i++)
    {
        printf(" %d", arr[i]);
    }

    printf("\n");
    for (i=0; i<10; i++)
    {
        for (j=i+1; j<10; j++)
        {
            if (arr[i] > arr[j])
            {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;  
            }
        }

    }
    printf("---------------排序后-----------\n");
    for (i=0; i<10; i++)
    {
        printf(" %d", arr[i]);
    }
}

3.进制转换

#include <stdio.h>
//数字进制转换
void func(void)
{
    //输入要转换的数字
    int a = 0, b = 0;
    printf("输入正整数:");
    scanf("%d", &a);

    if (a < 0)
    {
        printf("参数错误");
        return;
    }

    printf("输入要转换的进制:");
    scanf("%d", &b);
    //定义一个数组，保存转换的进制数

    char arr[100] = {}; 
    int i = 0;
    do
    {
        arr[i] = a % b;
        a = a / b; 
    }while (a > 0);     i++;          

    for (i=i-1; i>=0; i--)
    {
        //大于10和小于10
        if (arr[i] < 10)
        {
            printf("%d", arr[i]);
        }
        else
        {
            printf("%c", arr[i]-10+'A');
        }
    }

    printf("\n");
}

int main(void)
{
    func();
}

4.利用传值调用完成冒泡排序

#include <stdio.h>

//传值调用

//数组名作为参数，要加上自己的大小(个数)
void func(int arr[], int lenth)
{
    int i = 0;

    for (i=0; i<lenth; i++)
    printf("arr[%d] = %d.\n", i, arr[i]);

    arr[1] = 11;

}
int main(void)
{
    int arr[10] = {1, 2, 3, 4, 5};
    printf("in main arr = %p.\n", arr);
    printf("in main sizeof(arr) = %d.\n", sizeof(arr));
    //函数调用只要传进去实参的变量名字

    func(arr, 10);
    printf("arr[1] = %d.\n", arr[1]);
    return 0;
}

5.利用传值调用完成数组元素调换

#include <stdio.h>

void func(int arr[], int lenth)
{
    int i = 0, temp = 0;
    for (i=0; i<lenth/2; i++)
    {
        temp = arr[lenth-1-i];
        arr[lenth-1-i] = arr[i];
        arr[i] = temp;
    }
    for(i=0;i<lenth;i++)
    {
            printf("%d",arr[i]);
    }
}


int main(void)
{
    int arr[5]={11,2,3,44,5};

    func(arr,5);
    return 0;
}

6.利用传值调用完成二分查找

6.1循环

#include <stdio.h>

int search_arr_element(int arr[], int left, int right, int data)
{
    //定义保存中间下标的变量
    int mid = 0;

    while (left <= right)
    {   
        //中间下标赋值
        mid = (left + right) / 2;
        //比较符合条件的下标
        if ( data > arr[mid])
        {
            left = mid + 1;
        }
        else if (data < arr[mid])
        {
            right = mid - 1;
        }
        else
        {   
            printf("找到了%d下标%d.\n", data, mid);
            return mid;
        }
    }
    printf("%d查无此数.\n", data);
    return -1;
}
int main(void)
{
    int arr[5] = {2, 5, 8, 11, 13};

    search_arr_element(arr, 0, 4, 12);
    return 0;
}

6.2递归

#include <stdio.h>
void search(int arr[], int left, int right, int data)
{
    int mid = (left + right) / 2;
    //回归条件（得到正确结果）
    if (data == arr[mid])
    {
        printf("找到数组下标%d的数据%d.\n", mid, data);

        return mid;
    }
    //回归条件（得到非正确结果）
    if (left > right)
    {
        printf("找不到数据%d.\n", data);
        return;
    }
    if (data > arr[mid])
    {
        search(arr, mid+1, right, data);
    }

    if (data < arr[mid])
    {
        search(arr, left, mid-1, data);
    }
}

int main(void)
{
    int arr[5] = {2, 5, 8, 11, 13};

    search(arr, 0, 4, 12);
    return 0;
}

6.3利用传值调换完成数组循环右移

#include <stdio.h>
#include <string.h>

//循环右移:2位->891234567
void func(char buf[], int steps)
{
    int i = 0, j = 0, lenth = 0;
    char temp = 0;

    lenth = strlen(buf);

    for (i=0; i<steps; i++)  // 等同于 while (steps--)
    {
        temp = buf[lenth-1];
        for (j=lenth-1; j>0; j--)
        {
            buf[j] = buf[j-1];
        }
        buf[0] = temp;
    }
}


int main(void)
{
    char buf[] = "123456789";
    int steps = 0;

    printf("输入要移动的位数：");
    scanf("%d", &steps);

    printf("buf = [%s].\n", buf);

    func(buf, steps);

    printf("buf = [%s].\n", buf);
    return 0;
}

字符串

字符串常量char buf_2[ ]=”ABC”,sizeof(buf_2)=4
字符串常量后有\0
c语言里没有字符串的原生类型，如string是c++的，所有字符串都是以字符数组的形式存储在内存中
字符串相当于提供了一个首地址，结束’\0’，整个区间就是字符串(不包含’\0’)

char *类型指向常量字符串
char a[]类型填写变量字符串

char *p1 = "123";   
char *p2 = "123";
此时p1=p2，因为两个char *格式的变量都指向了同一个常量区的字符串“123“

char str1[] = "123";
char str2[] = "123";
此时str1!=str2，因为两个char型数组指向了不同的存在于栈中的字符串“123“