C语言之一维数组

　　C语言数组
　　当我们处理大量数据值时，我们需要任意数量的不同变量。随着变量数量的增加，程序的复杂性也会增加，因此程序员会对变量名称感到困惑。在某些情况下，我们需要处理大量类似的数据值。为了使这项工作更容易，C编程语言提供了一个名为＂数组＂的概念。数组是一种特殊类型的变量，用于一次存储多个相同数据类型的值。数组是存储在具有单个名称的连续内存位置中的类似数据项的集合。数组声明
　　在C语言中，当我们想要创建一个数组时，我们必须知道要存储在该数组中的值的数据类型以及要存储在该数组中的值的数量。创建一个数组语法: 类型 数组名[size]创建具有大小和初始值的数组的语法:类型 数组名[size]={value1,value2,…};创建没有大小和初始值的数组的语法:类型 数组名[ ]={value1,value2,…};
　　在上面的语法中，数据类型指定我们存储在该数组中的值的类型，size指定可以存储在该数组中的最大值数。
　　示例代码
　　int a [3] ;
　　这里，编译器使用单个名称＂a＂分配6个字节的连续内存位置，并告诉编译器将三个不同的整数值（每个内存为2个字节）存储到该6个字节的内存中。对于上述声明，内存组织如下:
　　在上面的内存分配中，所有三个内存位置都有一个通用名称＂a＂。因此无法直接访问单个内存位置。编译器不仅分配内存，还为数组的每个单独的内存位置分配一个数字引用值。该参考编号称为＂索引＂或＂下标＂。以上示例的索引值如下，数组下标从0开始，故最大下标是 size-1
　　不同的初始化方式
　　int arr[8]; //不初始化
　　int arr[8]=0; //error 数组初始化需要代扣好的初始值设定项列表(大括号初始化)
　　int arr[8]={0}; //true 告诉编译器，所有的都按一个方式初始化
　　int arr[8]={6}; //true 只有第一个为6，剩下的元素都自动初始化为0
　　int arr[8]={1,2,3,4,5,6}; //true
　　int arr[8]={0,1,2,3,4,5,6,7,8}; //error 初始值太多，超出了数组的存储范围
　　int arr[8]={,,,5,2,0}; //error 初始化只从从左到右，前面和中间都不能省略
　　int arr[]={1,2,3,4,5}; //true 数组里有几个元素？未指定数组大小，编译器会自动推导出来
　　int arr[]; //error 既不告诉编译器要多大内存，也不说有几个元素，编译器并不知道改怎么分配内存
　　数组的遍历通常通过循环操作，如下代码#include  int main()  {   int arr[5] = { 1,2,3,4,5 };   int length = 5;   printf(＂------数组打印-------- ＂);   for (int i = 0; i < length; i++)   {     printf(＂%d ＂, arr[i]);   }   printf(＂ ＂);   printf(＂------用户输入-------- ＂);   for (int i = 0; i < length; i++)   {     int result=scanf(＂%d＂, &arr[i]);   }   printf(＂------数组打印-------- ＂);   for (int i = 0; i < length; i++)   {     printf(＂%d ＂, arr[i]);   }   printf(＂ ＂);   return 0; }
　　数组输入可以采用换行作为数据间隔，也可以用空格作为数据间隔，运行结果如下:一维数组常规操作
　　插入数据
　　数组的插入主要场景有以下几种:从零无序插入从零有序插入,需要调整数据有数据按序号插入，需要挪动数组
　　示例程序| 从零无序插入数组，输入一组数据，-1作为结束
　　数组在做任何插入前都需要考虑满的状态，数组充当一个容器，插入数据只需要计数变量count改变，并且充当数组下标，整体操作比较简单，图示如下:
　　示例代码实现如下:#include  int main()  {   int array[20] = { 0 };   const int max = 20;   int count = 0;   int value, data;   while (1)    {     value = scanf(＂%d＂, &data);     if (data == -1)      {       break;     }     if (count == max)      {       printf(＂已满!＂);       break;     }     array[count++] = data;   }   for (int i = 0; i < count; i++)    {     printf(＂%d ＂, array[i]);   }   printf(＂ ＂);   return 0; }
　　运行效果如下:
　　示例程序| 从零插入数组，输入一组数据，实现数据从小到大存储，-1作为结束
　　可以在上述代码的基础上进行改进，增加排序的功能，当插入第一个元素的时候，默认有序，后面插入的元素，只需要和前面的元素比较，如果小于前面的元素就进行交换，调整到第一次小于插入元素的位置，或者调整到下标为0的位置。图示如下:
　　示例代码实现如下:#include  int main()  {   int array[20] = { 0 };   const int max = 20;   int count = 0;   int value, data;   while (1)    {     value = scanf(＂%d＂, &data);     if (data == -1)      {       break;     }     if (count == max)      {       printf(＂已满!＂);       break;     }     array[count++] = data;     for (int k = count - 1; k > 0; k--)      {       if (array[k] < array[k - 1])       {         int temp = array[k];         array[k] = array[k - 1];         array[k - 1] = temp;       }       else         break;     }    }   for (int i = 0; i < count; i++)    {     printf(＂%d ＂, array[i]);   }   printf(＂ ＂);   return 0; }
　　运行效果如下:
　　示例程序| 给定已有数组，在指定第几个元素的位置插入指定数据
　　需要注意的问题就是第几个元素和序号的区别 ，序号是从0开始的，第几个元素是从1开始的。编写代码时候需要考虑序号的有效性，然后唯一要做的就是腾出一个位置，然后插入元素即可，或者先插入到数组最后面，然后一次挪动元素到指定位置也可以。实现示意图如下:
　　示例代码实现如下:#include  int main()  {   int array[20] = { 555,567,666,999,888 };   const int max = 20;   int count = 5;   int value = 0;   int index = 0;   int insertData = 0;   value=scanf(＂%d%d＂, &index,&insertData);   if (count == max)    {     printf(＂已满无法插入! ＂);     return 0;   }   if (index<1 || index>count)    {     printf(＂序号有误，无法插入! ＂);     return 0;   }   array[count++] = insertData;   for (int k = count - 1; k >= index; k--)    {     int temp = array[k];     array[k] = array[k - 1];     array[k - 1] = temp;   }   for (int i = 0; i < count; i++)    {     printf(＂%d ＂, array[i]);   }   printf(＂ ＂);   return 0; }
　　运行效果如下:
　　查找数据
　　查找数据相对于来说比较简单，一般是遍历数据直接if比较即可，当然还有一种有序数据的查找可以采用二分法查找提高查找效率。
　　示例程序| 给定已有数组，查找指定数据的数组下标#include  int main()  {   int array[20] = { 555,567,666,999,888 };   const int max = 20;   int count = 5;   int pos = -1;   int value = 0;   int searchData = 0;   value=scanf(＂%d＂, &searchData);   for (int i = 0; i < count; i++)    {     if (array[i] == searchData)      {       pos = i;       break;     }   }   if (pos == -1)    {     printf(＂未找到指定数据! ＂);   }   else    {     printf(＂指定数组下标是:%d ＂, pos);   }   return 0; }
　　上述代码中的pos初始值为-1 ，因为数组下标也有0下标，作为未找到的的判定 ，所以初始值是-1。
　　运行效果如下:
　　示例程序| 给定已有有序数组，采用二分法查找指定数据的数组下标#include  int main() {   int array[10] = { 1,2,3,4,5,6,7,8,9,10 };   int left = 0;   int right = 9;   int mid = 0;   int value, searchData = 0;   int pos = -1;   value = scanf(＂%d＂, &searchData);    while (left < right)   {     mid = (left + right) / 2;     if (array[mid] > searchData)     {       right = mid - 1;     }     else if (array[mid] < searchData)     {       left = mid + 1;     }     else     {       pos = mid;       break;     }   }   if (pos == -1)   {     printf(＂未找到指定数据! ＂);   }   else   {     printf(＂指定数组下标是:%d ＂, pos);   }   return 0; }
　　运行效果如下:
　　删除数据
　　要注意的就是数组的删除是伪删除，只要找到指定数据，然后把后面的元素往前移动即可，然后计数变量做减一操作即可，整体难度不大，当然数组的删除也有按照第几个元素删除，也有删除指定数据的方式。实现示意图如下:
　　示例程序| 给定已有数组，删除指定的第几个元素。#include int main() {    int array[10] = { 555,567,666,999,888 };   const int max = 10;   int count = 5;   int index, value = 0;   value = scanf(＂%d＂, &index);   if (index<1 || index>count)    {     printf(＂索引有误,无法删除! ＂);     return 0;   }   for (int i = index-1; i < count-1; i++)    {     array[i] = array[i + 1];   }   count--;    //数组真正的删除   for (int i = 0; i < count; i++)   {     printf(＂%d ＂, array[i]);   }   printf(＂ ＂);   return 0; }
　　运行效果如下:
　　示例程序| 给定已有数组，删除指定数据。#include int main() {    int array[10] = { 555,567,666,999,888 };   const int max = 10;   int count = 5;   int index=-1, value = 0;   int data = 0;   value = scanf(＂%d＂,&data);   //先查找到序号，剩下的处理方案和序号删除类似   for (int i = 0; i < count; i++)    {     if (array[i] == data)      {       index = i;       break;     }   }   if (index == -1)   {     printf(＂未找到指定数据,无法删! ＂);   }   else    {     for (int i = index; i < count - 1; i++)     {       array[i] = array[i + 1];     }     count--;    //数组真正的删除   }   for (int i = 0; i < count; i++)   {     printf(＂%d ＂, array[i]);   }   printf(＂ ＂);   return 0; }
　　运行效果如下:
　　修改数据
　　修改数据相对于来说比较简单，一种是通过输入序号进行修改，注意序号有效性， 实际下标是序号减一即可，还有一种就是查找数据进行修改。
　　示例程序| 给定已有数组，修改指定序号下的数据#include int main() {    int array[10] = { 555,567,666,999,888 };   const int max = 10;   int count = 5;   int index=0, value = 0;   int data = 0;   value = scanf(＂%d＂,&index);   //先查找到序号，剩下的处理方案和序号删除类似   if (index<1 || index>count)   {     printf(＂序号有误，无法修改！＂);   }   else    {     value=scanf(＂%d＂, &array[index]);   }   printf(＂ ＂);   return 0; }
　　示例程序| 给定已有数组，修改指定数据为新的数据#include int main() {    int array[10] = { 555,567,666,999,888 };   const int max = 10;   int count = 5;   int index=-1, value = 0;   int data = 0;   value = scanf(＂%d＂,&data);   //先查找到序号，剩下的处理方案和序号删除类似   for (int i = 0; i < count; i++)    {     if (array[i] == data)      {       index = i;       break;     }   }   if (index == -1)   {     printf(＂未找到指定数据,无法修改! ＂);   }   else    {     array[index] = data;   }   for (int i = 0; i < count; i++)   {     printf(＂%d ＂, array[i]);   }   printf(＂ ＂);   return 0; }
　　数组简单排序
　　示例程序| 冒泡排序
　　冒泡排序算法思想是相邻的两个元素进行比较，不满足要求规则进行交换，第一次冒泡决定了第一大元素，故第二次冒泡可减少笔记次数一次。外循环给予每个元素有冒泡机会，内循环描述比较次数，代码实现如下:#include int main() {    int array[] = { 0,1,2,9,3,4,5,6,7,8 };   int arrayNum = 10;   for (int i = 0; i < arrayNum - 1; i++)   {     for (int j = 0; j < arrayNum - 1 - i; j++)     {       if (array[j] > array[j + 1])       {         int temp = array[j];         array[j] = array[j + 1];         array[j + 1] = temp;       }     }   }   for (int i = 0; i < arrayNum; i++)    {     printf(＂%d ＂, array[i]);   }   printf(＂ ＂);   return 0; }
　　示例程序| 选择排序
　　选择排序算法思想是填坑思想，第一个位置，选择最小的填进去，第二个位置选择剩余元素最小的填充第二个位置，
　　依次类推，外循环用来遍历每一个坑位，内循环去找剩余元素最小的，找到和当前坑元素交换即可。代码实现如下:int minIndex;   int temp;   for (int i = 0; i < arrayNum; i++)    {     minIndex = i;       //从剩下的元素中找最小的     for (int j = i + 1; j < arrayNum; j++)      {       if (array[j] < array[minIndex])        {         minIndex = j;       }     }     //和选出来的那个元素进行交换     temp = array[i];     array[i] = array[minIndex];     array[minIndex] = temp;   }
　　示例程序| 插入排序
　　插入排序算法思想是插队思想，第一个元素当做有序数据，后续数据插在最后面，依次和前面元素比较，类似有序插入数据，比较到第一次小于插入元素的位置，或者比较到0的位置即可，外循环遍历每个数据，内循环描述插入过程，代码实现如下:#include int main() {    int array[] = { 0,1,2,9,3,4,5,6,7,8 };   int arrayNum = 10;   int preIndex, current;   for (int i = 1; i < arrayNum; i++)   //把第一个元素当做是有序序列   {     preIndex = i - 1;        //第一个元素的序号     current = array[i];        //暂时存储，腾出一个位置     while (preIndex >= 0 && array[preIndex] > current)     {       array[preIndex + 1] = array[preIndex];       preIndex--;     }     array[preIndex + 1] = current;   }   for (int i = 0; i < arrayNum; i++)    {     printf(＂%d ＂, array[i]);   }   printf(＂ ＂);   return 0; }客观请留步
　　如果阁下正好在学习C/C++，看文章比较无聊，不妨关注下关注下小编的视频教程，通俗易懂，深入浅出，一个视频只讲一个知识点。视频不深奥，不需要钻研，在公交、在地铁、在厕所都可以观看，随时随地涨姿势。