C语言回顾-整型变量修饰符和一维数组

1.整型变量修饰符

1）改变整型变量的存储空间

#include <stdio.h>

int main(int argc, const char * argv[]) {
    //改变整型变量占用的存储空间
    //int4   short2  long8  (long long)8
    //short int占两个字节
    short int a=1;
    short int a1=a<<15;//2字节最小的负数-32768
    a1=(a<<15)-1;//2字节最大的正数32767
    printf("%hd\n",a1);
    
    int b=1;//int 类型占4字节
    int b1=b<<31;//4字节最小的负数
    b1=(b<<31)-1;//4字节最大的正数
    printf("%d\n",b1);
    
    long int c=1;//8字节
    long int c1=c<<63;
    c1=(c<<63)-1;
    printf("%ld\n",c1);

    return 0;

}

2）改变整型变量的符号

    //计算机默认的是有符号数
    unsigned short d=0-1;//每位都变成1
    printf("%u\n",d);

    unsigned int e=0-1;
    printf("%u\n",e);

2.char类型常量的存储问题

sizeof('a');//4，先找到‘a’d的ascii码值97，把97的按照int类型进行存储

ch a='a'; sizeof(a);//1，先找到‘a’d的ascii码值97，把97的按照一个字节存储

一个字节范围-128-127；0-127用来存储特殊的符号

3.数组

把具有相同类型的若干变量按有序的形式组织起来，这些按序排列的同类数据元素的集合称为数组

一维数组：数组的每个元素都不是一个数组

定义格式：数组类型 数组名 [数组长度]

1)数组长度可以是常量或者常量表达式

2)数组名不能和其他变量同名

3)数组的长度不可以为一个变量,xcode已优化

4)可以使用宏定义

5)定义数组的时候可以同时定义普通变量 int x,y,a[4];

一维数组的初始化

1）定义的同时进行初始化,部分初始化

int a[4]={1,2,3,4};

int a[]={1,2,3,4};//数组的长度根据后面的值的个数决定

int a[4]={1,2};

int a[4]={[3]=4,[8]=34};//给下标是3和8的元素赋值

2）先定义后初始化

3）使用变量定义的数组不可以定义数组的同时对数组进行初始化

 如果数组没有进行初始化，这时候数组元素是随机的垃圾值

如果进行了部分初始化，没初始化的那部分元素也自动被系统初始化为0了

对于字符是组来说，没有初始化的那部分元素也被系统初始化为0了

先定义后初始化的方式，如果部分元素被初始化了，系统不会对没有初始化的那部分元素进行初始化

4.一维数组的引用（访问）

a[0]...a[n-1]

5.一维数组的存储方式

1）连续的存储空间

2）数组名代表数组的首地址

3）每个元素的长度一样

4）数组中元素之间的地址是连续的

5）数组名是一个常量，存储的是数组的首地址

6.一维数组长度的计算方法

sizeof(数组名);//字节数

sizeof(数组名)/sizeof(数组元素类型)；//数组长度

7.数组元素作为函数参数，实参和形参指向同样的地址空间，修改形参数组元素的值，实参的值也会改变

数组名作为函数参数后，数组的长度信息会丢失，sizeof（arr）变成8，地址占8个字节

8.冒泡排序：相邻的数比较，大的数放后面，每趟取得最大的数放在最后

#include<stdio.h>
int main(int argc, const char * argv[]) {
    //定义一个字符数组
    int a[10]={22,34,5,45,51,62,66,44,32,31};
    int temp;
    for(int i=0;i<10-1;i++){
        for(int j=0;j<10-1-i;j++){
            if(a[j]>a[j+1]){
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    }
    for (int i=0;i<10;i++){
        printf("%d\t",a[i]);
    }
    return 0;
}

9.选择排序：每一个数跟后面的数比较，小的放到当前位置

#include<stdio.h>
int main(int argc, const char * argv[]) {
    //定义一个字符数组
    int a[10]={22,34,5,45,51,62,66,44,32,31};
    int temp;
    for(int i=0;i<10;i++){
        for(int j=i+1;j<10;j++){
            if(a[i]>a[j]){
                temp=a[j];
                a[j]=a[i];
                a[i]=temp;
            }
        }
    }
    for (int i=0;i<10;i++){
        printf("%d\t",a[i]);
    }
    return 0;
}

第二种方式：

#include<stdio.h>
int main(int argc, const char * argv[]) {
    //定义一个字符数组
    int a[10]={22,34,5,45,51,62,66,44,32,31};
    int min;
    int temp;
    for(int i=0;i<10;i++){
        min=i;//假设每次最小元素的下标是i;
        for(int j=i+1;j<10;j++){
            if(a[min]>a[j]){
                min=j;//找到最小元素的下标
            }
        }
        if(i!=min){//如果i=min不用交换，否则交换
            temp=a[min];
            a[min]=a[i];
            a[i]=temp;

        }
    }
    for (int i=0;i<10;i++){
        printf("%d\t",a[i]);
    }
    return 0;
}

10.折半查找：在有序数组中查找一个值，思路：设置一个low=0；higt=length-1找中间的元素mid=（low+high）/2跟key值比较，如果key值>mid的值，high=mid-1，如果key值大于mid，那么low=mid+1;继续查找，直到相等

//折半查找
    int key=51;
    int low=0,high=10-1;
    int mid=0;
    
    while(low<=high){
        mid=(low+high)/2;
        if(key<a[mid]){
            high=mid-1;
        }else if(key>a[mid]){
            low=mid+1;
        }else{
            printf("找到了%d",mid);
            break;
        }
    }

如果要插入一个数到有序数组中，那个返回的下标应该是low（查找不到的话，low的值比high的值大）

 

转载于:https://www.cnblogs.com/fanglove/p/4932811.html