C语言一维数组中如何查找指定元素？

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C语言一维数组中如何查找指定元素？相关的知识，希望对你有一定的参考价值。

我详细解释下，是这样的，我要做一个数列N项查找程序（无论是等比还是等差或其他什么的）。
假设有一个已经定义好的数组（无论是初始化还是逐个），现在我要制作一个输入查找程序，这个查找程序是这样的，我输入我要查找的第N项元素以及输出这个元素以及这个元素对应的数值。

假设数组a=[20]=2,4,6,8,10,现在我要查找数组中第4项元素，虽然我已经知道第4项元素对应的数值是8，但是要是数组元素很长怎么办？所以就产生我想制作一个数列N项查找程序。

以下是我写的，不过程序不对，请大家帮我改一下。

#include <stdio.h>
#include <stdlib.h>

void main()


int i,n,f;
long int a[20]=2,4;
for(i=2;i<20;i++)

a[i]=a[i-1]+2;

while(1)

printf("输入元素号：");
scanf("%d,",f);
switch(f)

for(i=0,n=1;i<20&&n<21&&n==f;i++,n++)


printf("元素的数值：%d\n",a[i]);





system("pause");


我的C语言水平只学到二维数组那里，还没有学函数，指针什么的。，如果我提出的数列N项查找程序要用到函数和指针的话，请指导下，我还不会用指针和函数。

1、打开pycharm，新建Test_List.py，如图所示。

2、定义lista=('A','B','C','D','E')，使用len函数来判断数组长度，ALT+F10执行后可以看到结果是5，注意获取列表的值用【数组名+[序号]】。

3、通过【数组名+[序号]】可以获取数组里指定位置的元素值，有个前提是【指定位置】必须小于数组长度。

4、碰到这种复杂的数组，想要获取指定位置的值，就必须明确指定位置。

5、复杂数组想要获取正确的结果，指定的位置必须是【数组索引】。

 参考技术A

在一维数组中查找指定元素的方法：

    首先，定义数组，并对数组元素进行赋值

    输入位置值，输出相应的元素值（即：查找指定位置的元素）

      先判断位置是否合法，不合法，则输出位置错误，请重新输入

      位置合法，则把位置值转为数组下标，通过下标来确定数据，进行输出，如：第一个元素的下标为0，第二个为1等等

    输入一个数值，输出相应的下标（即：查找指定元素的位置）

      循环遍历数组，检查数组中的各位数据是否与待查数值相等

        如果相等，则提前结束循环：break;

        否则，继续循环，检查下一个数

      遍历完所有数组元素后，结束循环

      循环结束后，检查循环变量值是否超过数组元素总数，

        如果未超过，表示找到了相应数据，输出其下标位置，

        否则，输出未找到相应元素。

参考代码：

 参考技术B #include <stdio.h>
#include <stdlib.h>

void main()

int i,f;
long int a[20]=2,4;
for(i=2;i<20;i++)
a[i]=a[i-1]+2;
   while(1)
   
printf("输入元素号：");
scanf("%d,",&f);
if(f<=21&&f>=1)
printf("元素的数值：%d\\n",a[f-1]);
else
printf("超出数组范围\\n");    

system("pause");
//看看符合不符合你的要求，如果满意请采纳，谢谢

本回答被提问者采纳 参考技术C 对于有序序列，较为实用的是“二分查找”，或叫做“折半查找”。

C语言中如何“指名道姓”的进行初始化

指定初始化器的概念

C90 标准要求初始化程序中的元素以固定的顺序出现，与要初始化的数组或结构体中的元素顺序相同。但是在新标准 C99 中，增加了一个新的特性：指定初始化器。利用该特性可以初始化指定的数组或者结构体元素。

数组的指定初始化器

一维数组的指定初始化器

利用指定初始化器的特性，我们可以这样定义并初始化一个数组：

 

  1.  
    int a[6] = {[4] = 10,[2] = 25};
     


上述的初始化就等同于如下方式：
 

 

  1.  
    int a[6] = {0,0,25,0,10,0};
     


可以看到通过这种方式能够不按照顺序，且指定具体的元素进行初始化。除了上述这样的用法，我们也能够初始化数组内一段范围内的用元素（注意这是GCC的扩展语法，而不是C99的标准），比如这样：
 

 

  1.  
    int a[5] = {[4] = 10,[0 ... 3] = 23};
     


上面这段程序的初始化也就等同于如下初始化：
 

 

  1.  
    int a[5] = {23,23,23,23,10};
     


那如果数组初始化里有指定的元素初始化又有未指定的元素又是如何分析呢？比如这样：
 

 

  1.  
    int a[5] = {11,[3] = 44,55,[1] = 22,33};
     


那它等同于下面的代码：
 

 

  1.  
    int a[5] = {11,22,33,44,55};
     


如果定义数组时没有指定数组的大小，那么数组实际的大小又是多少呢？比如这样：
 

 

  1.  
    int main(void)
     
  2.  
    {
     
  3.  
    int number[] = {[20] = 1,[10] = 8,9};
     
  4.  
    int n = sizeof(number)/sizeof(number[0]);
     
  5.  
    printf("The Value of n is:%d\\n",n);
     
  6.  
    }
     


输出结果是这样的：
 

 

  1.  
    The Value of n is:21
     


也就是说，如果未给出数组的大小，则最大的初始化位置确定数组的大小
 

二维数组的指定初始化器
 

二维数组同样可以采用指定初始化器的方法，下面是一个二维数组的初始化：
 

 

  1.  
    int array[2][2] = 
     
  2.  
    {
     
  3.  
    [0] = {[0] = 11},
     
  4.  
    [1] = {[1] = 22},
     
  5.  
    };
     


这样的初始化也就等同于下述代码：
 

 

  1.  
    int array1[2][2] = 
     
  2.  
    {
     
  3.  
    {11,00},
     
  4.  
    {00,22}
     
  5.  
    };
     


通过上述代码，我们也可以知道，二维数组的指定初始化器的方法中，第一个 []里的数字表示的是初始化的二维数组的行数，而在 {}内的则是对当前行的元素进行初始化，实际也就是说 {}内的初始化方法也就和一维数组的一样了，一维数组可行的方法，二维数组也是可行的。
 

应用
 

在讲述了数组指定初始化器的基本概念之后，我们来看一个具体的例子，下面这个例子是基于状态机的编程方法实现的 ATM 机器，首先 ATM 具有如下几种状态;
 

 

我们就可以使用状态机的思路来编写这个程序，首先使用枚举的方式来定义各个状态和相应的操作：
 

 

  1.  
    typedef enum
     
  2.  
    {
     
  3.  
    Idle_State,
     
  4.  
    Card_Inserted_State,
     
  5.  
    Pin_Entered_State,
     
  6.  
    Option_Selected_State,
     
  7.  
    Amount_Entered_State,
     
  8.  
    last_State
     
  9.  
    }eSysyemState;
     
  10.  
     
  11.  
    typedef enum
     
  12.  
    {
     
  13.  
    Card_Insert_Event,
     
  14.  
    Pin_Enter_Event,
     
  15.  
    Option_Selection_Event,
     
  16.  
    Amount_Enter_Event,
     
  17.  
    Amount_Dispatch_Event,
     
  18.  
    last_Event
     
  19.  
    }eSystemEvent;
     


然后是对应操作的具体实现：
 

 

  1.  
    eSysyemState AmountDispatchHandler(void)
     
  2.  
    {
     
  3.  
    return Idle_State;
     
  4.  
    }
     
  5.  
     
  6.  
    eSysyemState EnterAmountHandler(void)
     
  7.  
    {
     
  8.  
    return Amount_Entered_State;
     
  9.  
    }
     
  10.  
     
  11.  
    eSysyemState OptionSelectionHandler(void)
     
  12.  
    {
     
  13.  
    return Option_Selected_State;
     
  14.  
    }
     
  15.  
     
  16.  
    eSysyemState InsertCardHandle(void)
     
  17.  
    {
     
  18.  
    return Card_Inserted_State;
     
  19.  
    }
     
  20.  
     
  21.  
    eSysyemState EnterPinHandler(void)
     
  22.  
    {
     
  23.  
    return Pin_Entered_State; 
     
  24.  
    }
     


为了使得状态机的实现看起来不是那么的冗长，我们这里采用查表的方式，首先重定义一个函数指针二维数组类型：
 

 

  1.  
    typedef eSysyemState (* const afEventHandler[last_State][last_Event])(void);
     


简单说一个这是一个二维数组，二维数组里面存放的是函数指针，这个函数指针指向的是返回值为 eSysyemState，形参为 void 的函数。在重定义了这个类型之后，我们就可以用其定义新的变量了，在这之前，补充一点数组相关的内容，比如有如下代码：
 

 

  1.  
    typedef int array[3];
     
  2.  
    array data;
     


那么上述代码也就等同于如下代码：
 

 

  1.  
    int data[3];
     


有了上述代码之后，我们就可以实现我们的查找表了，具体代码如下：
 

 

  1.  
    static afEventHandler StateMachine = 
     
  2.  
    {
     
  3.  
    [Idle_State] = {[Card_Insert_Event] = InsertCardHandle},
     
  4.  
    [Card_Inserted_State] = {[Pin_Enter_Event] = EnterPinHandler },
     
  5.  
    [Pin_Entered_State] = {[Option_Selection_Event] = OptionSelectionHandler},
     
  6.  
    [Option_Selected_State] = {[Amount_Entered_Event] = EnterAmountHandler},
     
  7.  
    [Amount_Entered_State] = {[Amount_Dispatch_Event] = AmountDispatchHandler},
     
  8.  
    };
     


现在再来看到这个初始化的方法也就比较清楚了，这实际上也就是一个二维数组使用指定初始化器解析的方法，最后，也就是我们的状态机运行代码：
 

 

  1.  
    #include <stdio.h>
     
  2.  
     
  3.  
    int main(void)
     
  4.  
    {
     
  5.  
    eSysyemState eNextState = Idle_State;
     
  6.  
    eSystemEvent eNewEvent;
     
  7.  
    while(1)
     
  8.  
    {
     
  9.  
    eNewEvent = ReadEvent();
     
  10.  
    /*省略相关判断*/
     
  11.  
    eNextState = (*StateMachine[eNextState][eNewEvent])();
     
  12.  
    }
     
  13.  
    return 0;
     
  14.  
    }
     


结构体的指定初始化器
 

定义了如下结构体：
 

 

  1.  
    struct point
     
  2.  
    {
     
  3.  
    int x,y;
     
  4.  
    }
     


那么对于结构体变量的初始化可以采用以下的方式：
 

 

  1.  
    struct point p = 
     
  2.  
    {
     
  3.  
    .y = 2,
     
  4.  
    .x = 3
     
  5.  
    };
     


上述代码也就等价于如下代码：
 

 

  1.  
    struct point p = {3,2};
     


那这样的初始化有什么作用呢？下面是 linux 内核的一段代码：
 

 

  1.  
    const struct file_operations eeprom_fops =
     
  2.  
    {
     
  3.  
    .llseek = eeprom_lseek,
     
  4.  
    .read = eeprom_read,
     
  5.  
    .write = eeprom_write,
     
  6.  
    .open = eeprom_open,
     
  7.  
    .release = eeprom_close
     
  8.  
    };
     


上述就是通过指定初始化器的方法来进行初始化的，其中 file_operations 这个结构体中的成员有很多，上述初始化的成员只是其中一部分，
 

 

  1.  
    struct file_operations {
     
  2.  
    struct module *owner;
     
  3.  
    loff_t (*llseek) (struct file *, loff_t, int);
     
  4.  
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
     
  5.  
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
     
  6.  
    int (*open) (struct inode *, struct file *);
     
  7.  
    int (*flush) (struct file *, fl_owner_t id);
     
  8.  
    int (*release) (struct inode *, struct file *);
     
  9.  
    /*还有很多，省略*/
     
  10.  
    }
     


采用这种指定初始化器的方法，使用灵活，而且代码易于维护。因为如果按照固定顺序赋值，当我们的 file_operations 结构体类型发生改变时，比如添加成员、减少成员、调整成员顺序，那么使用该结构体类型定义变量的大量 C 文件都需要重新调整初始化顺序，那将导致程序大幅度地更改。
 

结构体数组的指定初始化器
 

在叙述了上面关于结构体和数组的指定初始化器之后，我们也可以以这种方式来来初始化结构体数组，比如这样：
 

 

  1.  
    #include <stdio.h>
     
  2.  
    int main(void)
     
  3.  
    {
     
  4.  
    struct point {int x,y;};
     
  5.  
    struct point pts[5] =
     
  6.  
    {
     
  7.  
    [2].y = 5,
     
  8.  
    [2].x = 6,
     
  9.  
    [0].x = 2
     
  10.  
    };
     
  11.  
    int i;
     
  12.  
    for(i = 0;i < 5;i++)
     
  13.  
    printf("%d %d\\n",pts[i].x,pts[i].y);
     
  14.  
    }
     


输出结果如下：
 

 

  1.  
    2 0
     
  2.  
    0 0
     
  3.  
    6 5
     
  4.  
    0 0
     
  5.  
    0 0
     


总结
 

以上便是指定初始化器所包含的大致内容，这也是自己之前的知识盲点，通过这次总结学习，也能够很好的掌握了，不积跬步，无以至千里～
 

参考资料：
 

[1] https://blog.51cto.com/zhaixue/2346825
 

[2] https://www.geeksforgeeks.org/designated-initializers-c/
 

[3] https://aticleworld.com/state-machine-using-c/
 

您的阅读是对我最大的鼓励，您的建议是对我最大的提升
 

 

                

        
以上是关于C语言一维数组中如何查找指定元素？的主要内容，如果未能解决你的问题，请参考以下文章
 

 C语言中怎么把一维数组赋给另外一个一维数组


 c语言如何实现-数组排序，二分查找


 用C语言实现一维数组中删除第N个元素的程序怎么写


 C语言一维数组赋值方法


 c语言编程，已经从小到大排好的一维9元素数组在插入一个数，按顺序，怎么写程序?谢谢


 c语言学习--数组