5.1一维数组

回到主页

引言

为什么需要数组？？？

  1. 为例解决大量同类型数据的存储和使用的问题。
  2. 可以模拟现实世界

一、一维数组的定义

  1. 定义：类型说明符 数组名[常量表达式]
    例子： int a[100] ; float b [40] ; char c[80]
  2. 说明：
    1. 数组名命名规则和变量名相同，遵循标识符命名规则。
    2. 数组名后是方括弧括起来的常量表达式，不能是原括弧。
    3. 常量表达式表示元素的个数，即数组的长度，下标从0开始。
    4. 常量表达式中可以包括常量和符号常量，不能包含变量。
  3. 合法的几个数组例子
int a[2];
int b[2*2];
const int x = 2; // const 是常变量标识符
int c[2*x]; //方括号里相当于个整型常量表达式  
int e[(int)3.1];  // 强制类型转换也可以哦  
int f['A'];  //相当于65
int g[true];  //相当于1

二、一维数组的初始化

完全初始化

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

不完全初始化

int b[5]={1,2,3};
//没被赋值的元素，系统会给赋一个默认值0

不初始化

只定义不初始化，里面全是垃圾值。

清零

int c={0};

初始化的几种错误写法

1. 
int m[5];
m[5]={1,2,3,4,5};
//只能在定义时初始化这样赋值，其他情况都表示下标。
2. 
int n[5]={1,2,3,4,5};
n[5]= 100;//没有a[5]这个元素，最大只有a[4]
3. 
int a[5]={1,2,3,4,5};
int b[5];
//如果要把a数组中的值全部赋值给b数组
错误写法：
b=a;
正确写法：
for(i=0;i<5;++i)
   b[i]=a[i];

三、一维数组的引用

  1. 形式：数组名[下标]
    1. 下标可以是常数、变量或者整型表达式
    2. 数组必须先定义后使用
    3. C语言规定只能逐个引用数组元素而不能一次引用整个数组
    4. C编译不检查数组下标是否越界

四、一维数组的特点

  1. 数组内存是连续分配的
  2. 所有的变量的数据类型必须相同
  3. 所有变量所占的字节大小必须相同

五、一维数组的操作

排序

冒泡排序

int main(void)
{
    int a[5]={1,2,6,4,5};
    int i;
    int len = 5;
    int j,k,m;
    for(j=0;j<len-1;++j)
        for(k=0;k<len-1-i;++k)
        {
            if(a[k]<a[k+1])//倒序，由大到小排序
            {
                m=a[k];
                a[k]=a[k+1];
                a[k+1]=m;
            }
            
        }
    for(i=0;i<len;++i)
    {
        printf("%d\n",a[i]);
    }
    system("pause");
    return 0;
}

选择排序

先比较所有数组元素的最大值，并记录最大元素所在的位置，一次比较结束后，将整个最大值放到后边。

int main(void)
{
    int a[8]={1,4,10,3,5,7,2,2};
    int i;
    int len = 8;
    int k;
    int x=0;
    for(int k = 0; k < len-1;++k)
    {
      int c=0;
      //int i;
      for(i = 1; i < len-k; ++i)
      {
		   if(a[c] < a[i])
				c = i;
		}
      int b = a[c];
		a[c] = a[i-1];
		a[i-1] = b;
    }  
    for(x=0;x<len;++x)
    {
        printf("%d\n",a[x]);
    }
    return 0;     
}

添加&删除&查找&倒置

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define LEN 10
/*
1. 统计数组中有效元素的个数
*/
int length(int a[])
{
    int i=0;
    while(i<LEN)
    {
        if(a[i]==0)
            break;
        else
        {
            ++i;
        }
    }
    return i;
}
/*
2. 输出数组中有效元素
*/
void show(int a[])
{
    int len = length(a);
    int i;
    for(i=0;i<len;++i)
    {
        printf("%d\n",a[i]);
    }
}
/*
3. 删除数组中指定位置的某个元素
*/
bool del(int a[],int index)
{
    int len = length(a);
    int i;
    int m=0;
    if(index<(len+1) && index>0 && len>0)
    {
        for(i=index-1;i<len;++i)
        {
            a[i]=a[i+1];
        }
        a[len-1]=0;
        return true;
    }
    else
    {
        return false;
    }
    
}
/*
4.在数组指定位置中增加一个有效元素
*/
bool add(int a[],int index,int x)
{
    int len = length(a);
    int i;
    int m=0;
    if(index<=(len+1) && index>0 && len>0)
    {
        for(i=len;i>(index-1);--i)
        {
            a[i]=a[i-1];
        }
        a[index-1]=x;
        return true;
    }
    else
    {
        return false;
    }   
}
/*
5.将数组元素倒置
*/
bool invert (int a[])
{
    int len = length(a);
    int i,m;
    if(len>=0)
    {
        for(i=0;i<(len/2);++i)
        {
            m=a[i];
            a[i]=a[len-i-1];
            a[len-i-1]=m;
        }
        return true;
    }
    else
    {
        return false;
    }    
}
/*
为了满足下面二分法的要求
*/
int sort(int a[])
{
    int i;
    int len = length(a);
    int k;

    for(int k = 0; k < len-1;++k)
    {
        int c=0;
        //int i;
        for(i = 1; i < len-k; ++i)
        {
			if(a[c] < a[i])
				c = i;
		}
        int b = a[c];
		a[c] = a[i-1];
		a[i-1] = b;
    }

    return 0;    
}
/*
6.普通查找：查找某个指定的数字是否在数组中，找到则返回所在位置（下标+1），没找到返回-1
*/
int find1(int a[],int x)
{
    int len = length(a);
    int i;
    int y=-1;
    sort(a);//没必要，只是为了验证两种查找方式的结果是否一样
    if(len>0)
    {
        for(i=0;i<len;++i)
        {
            if(a[i]==x)
            {
                int y=i+1;
                return y;
            }
        }
    }
    return -1;  
}
/*
7.二分法查找：查找某个指定的数字是否在数组中，找到则返回所在位置（下标+1），没找到返回-1
*/
int find2(int a[],int x)
{
    //必须先排好序,从小到大
    sort(a);
    int len = length(a);
    int from = 0;
    int end = len-1;
    while(from <= end)
    {
        if(x == a[(from+end)/2])
            return (from+end)/2+1;
        else if(x > a[(from+end)/2])
            from = (from+end)/2 + 1;
        else 
            end = (from+end)/2 - 1;
    }
    return -1;

}

int main(void)
{
    int a[LEN]={1,4,10,3,5,7,2,2};
    //del(a,3);
    //add(a,2,9);
    //invert(a);
    //show(a);  
    printf("法一查找的结果是：%d\n",find1(a,10));
    printf("法二查找的结果是：%d\n",find2(a,10));
    printf("数组中有效元素个数是：%d\n",length(a));
    system("pause");
    return 0;
}

本文章使用limfx的vsocde插件快速发布