c 语言的例题 数组的 经典题 - 推酷
c 语言的例题 数组的 经典题
数组的应用：
1.依次按照下面要求完成操作：
声明一个包含6个元素的int数组chuck，并将它初始化为从2开始的连续6个偶数。
编写语句，将chuck数组的第一个元素和最后一个元素的和赋值给变量even，并将even输出。
编写语句，显示chuck数组中第3个元素的值。
编写语句，将chuck数组中第5个元素的值改为100。
编写语句，依次显示chuck数组中所有的元素，元素间用逗号隔开。
倒序输出chuck数组中所有的元素。
另外定义一个6个元素的int数组dipsea(要求在定义时所有元素初始化为0)，将chuck数组的内容赋值给
dipsea数组，然后显示dipsea数组所有元素的值，元素间用逗号隔开。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int chuck[6] = { 2, 4, 6, 8, 10, 12 };
int i = 0;
chuck[4] = 100;
printf(&6个偶数元素为：\n&);
for (i = 0; i & 6; i++) {
printf(&%d,&, chuck[i]);
printf(&\n&);
printf(&第一个元素和最后一个元素的和为：\n&);
even = chuck[0] + chuck[5];
printf(&%d\n&, even);
printf(&chuck数组中第3个元素的值为：\n&);
printf(&%d\n&, chuck[2]);
printf(&chuck数组中第5个元素的值为：\n&);
printf(&%d\n&, chuck[4]);
printf(&倒序输出为：\n&);
for (i = 5; i &= 0; i--) {
printf(&%d &, chuck[i]);
printf(&\n&);
int dipsea[6] = { 0, 0, 0, 0, 0, 0 };
printf(&dipsea数组所有元素的值为：\n&);
for (i = 0; i & 6; i++) {
dipsea[i] = chuck[i];
printf(&%d &, dipsea[i]);
return EXIT_SUCCESS;
2.编写一个程序，从键盘上接收10个整数，将它们保存到一个数组里。在输入完成后输出用户刚刚输入的
10个整数。
从键盘上再接收一个整数，将它保存到int变量number里。
从刚才第一次接收的10个整数中，查找是否有整数number，如果有则输出它在数组中的位置，否则输出没
有找到（没有找到是指数组中没有一个元素的值与number值相等，则输出没有找到）。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[10];
printf(&请输入10个整数：&);
fflush(stdout);
for(i=0;i&10;i++){
scanf(&%d&,&arr[i]);
printf(&数组元素为：\n&);
for(i=0;i&10;i++){
printf(&%d &,arr[i]);
printf(&\n&);
printf(&请在输入一个整数:\n&);
fflush(stdout);
scanf(&%d&, &number);
for (i = 0; i & 10; i++)
if (arr[i] == number)
if (i &= 10){
printf(&没有找到!\n&);
printf(&%d在数组中得位置是：arr[%d]!&, arr[i], i);
return EXIT_SUCCESS;
3.定义一个数组days，将其初始化为今年每月的天数，编写一段程序，将每月的天数打印出来。打印形式
如下:Month 1 has 31days.
#include &stdio.h&
#include &stdlib.h&
#define MONTHS 12
int main(void) {
int days[MONTHS] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
for (i = 0; i & MONTHS; i++) {
printf(&MONTH %d has %d days.\n&, i + 1, days[i]);
return EXIT_SUCCESS;}
4.编写一段程序，要求定义一个含有5个元素的数组，实现数组接收键盘输入的数字，输入完毕后打印数组
元素，并比较得出数组中元素的最大值和最小值，并输出。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[5];
int i,max,
printf(&请输入五个整数：&);
fflush(stdout);
for(i=0;i&5;i++){
scanf(&%d&,&arr[i]);
printf(&数组元素为：\n&);
for(i=0;i&5;i++){
printf(&%d &,arr[i]);
max=min=arr[0];
for(i=0;i&=4;i++){
if(max&arr[i]){
max=arr[i];
}else if(min&arr[i]){
min=arr[i];
printf(&\n&);
printf(&最大值为：%d\n最小值为：%d\n&,max,min);
return EXIT_SUCCESS;
5.定义一个由整数组成的数组，求出其中奇数的个数和偶数的个数，并打印。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[]={1,2,3,4,5,6,7};
int i,js=0,os=0;
int len =sizeof(arr)/sizeof(int);
printf(&数组元素为：\n&);
for(i=0;i&i++){
if(arr[i]%2==0){
printf(&%d &,arr[i]);
printf(&\n&);
printf(&偶数个数为：%d\n奇数个数为：%d&,os,js);
return EXIT_SUCCESS;}
6.定义一个int型的一维数组，包含10个元素，分别赋值为1~10， 然后将数组中的元素都向前移一个位置
，即a[0]=a[1],a[1]=a[2],…最后一个元素的值是原来第一个元素的值，然后输出这个数组。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[]={1,2,3,4,5,6,7,8,9,10};
printf(&原数组为：\n&);
for(i=0;i&10;i++){
printf(&%d &,arr[i]);
printf(&\n&);
temp=arr[0];
for(i=0;i&9;i++){
arr[i]=arr[i+1];
printf(&向前移动后的数组为：\n&);
for(i=0;i&10;i++){
printf(&%d &,arr[i]);
return EXIT_SUCCESS;}
7.有一个3行4列的数组，编写一段程序，求出其中的最大值，以及最大值所在的行号和列号。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int i,j,c,d,
max=a[0][0];
//循环行数
for(i=0;i&=2;i++){
//循环列数
for(j=0;j&=3;j++){
if(max&=a[i][j]){
max=a[i][j];
printf(&最大数为：%d\n行号为：%d\n列号为：%d&,max,c+1,d+1);//下标从0开始
return EXIT_SUCCESS;
8.定义一个包含有5个元素的int数组，并且初始化为0；
从键盘上接收5个整数，依次保存到int数组中。
要求你想办法，把数组的元素值倒序过来存储。
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int arr[5]={0,0,0,0,0};
printf(&请输入五个整数：&);
fflush(stdout);
for(i=0;i&5;i++){
scanf(&%d&,&arr[i]);
printf(&五个整数逆序输出为：\n&);
for(i=4;i&=0;i--){
printf(&%d &,arr[i]);
return EXIT_SUCCESS;
打印一个十行的杨辉三角，打印效果如图所示：
#include &stdio.h&
#include &stdlib.h&
int main(void) {
int i, j, a[11][11];
for (i = 1; i & 11; i++) {/*for循环i的范围从1到10*/
a[i][i] = 1;/*对角线元素全为1*/
a[i][1] = 1; /*每行第一列元素全为1*/&}
printf(&打印图形如下：\n&);
for (i = 3; i & 11; i++)/*for循环范围从第3行开始到第10行*/
for (j = 2; j &= i - 1; j++)/*for循环范围从第2列开始到该行行数减一列为止*/
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];/*第i行j列等于第i-1行j-1列的
值加上第i-1行j列的值*/
for (i = 1; i & 11; i++) {
for (j = 1; j &= j++)
printf(&%-5d&, a[i][j]);/*通过上面两次for循环将二维数组a中元素输出*/
printf(&\n&);/*每输出完一行进行一次换行*/
return EXIT_SUCCESS;}
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致中国领先的IT技术网站
51CTO旗下网站
Java数组声明、创建、初始化
本文讲述了Java数组的几个相关的方面，讲述了对Java数组的声明、创建和初始化，并给出其对应的代码。
作者：ACMer-giraffe来源：| 13:26
一维数组的声明方式：
type var[]; 或type[]
声明数组时不能指定其长度（数组中元素的个数），
Java中使用关键字new创建数组对象，格式为：
数组名 = new 数组元素的类型 [数组元素的个数]
TestNew.java：
程序代码：
public&class&TestNew &{ &&&&&&public&static&void&main(String&args[])&{ &&&&&&&&&&int[]&s&; &&&&&&&&&&int&i&; &&&&&&&&&&s&=&new&int[5]&; &&&&&&&&&&for(i&=&0&;&i&&&5&;&i++)&{ &&&&&&&&&&&&&&s[i]&=&i&; &&&&&&&&&&} &&&&&&&&&&for(i&=&4&;&i&&=&0&;&i--)&{ &&&&&&&&&&&&&&System.out.println(&&&+&s[i])&; &&&&&&&&&&} &&&&&&}& &}&
1.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。
TestD.java(动态)：
程序代码：
public&class&TestD &{ &&&&&&public&static&void&main(String&args[])&{ &&&&&&&&&&int&a[]&; &&&&&&&&&&a&=&new&int[3]&; &&&&&&&&&&a[0]&=&0&; &&&&&&&&&&a[1]&=&1&; &&&&&&&&&&a[2]&=&2&; &&&&&&&&&&Date&days[]&; &&&&&&&&&&days&=&new&Date[3]&; &&&&&&&&&&days[0]&=&new&Date(<font color="#c0,4,5)&; &&&&&&&&&&days[1]&=&new&Date(<font color="#c0,2,31)&; &&&&&&&&&&days[2]&=&new&Date(<font color="#c0,4,4)&; &&&&&&} &} &&class&Date &{ &&&&&&int&year,month,day&; &&&&&&Date(int&year&,int&month&,int&day)&{ &&&&&&&&&&this.year&=&year&; &&&&&&&&&&this.month&=&month&; &&&&&&&&&&this.day&=&day&; &&&&&&} &} &&
TestS.java(静态)：
程序代码：
public&class&TestS&&& &{&&& &&&&&&public&static&void&main(String&args[])&{&&& &&&&&&&&&&int&a[]&=&{0,1,2}&;&&& &&&&&&&&&&Time&times&[]&=&{new&Time(19,42,42),new&Time(1,23,54),new&Time(5,3,2)}&;&&& &&&&&&}&&& &}&&& &&class&Time&&& &{&&& &&&&&&int&hour,min,sec&;&&& &&&&&&Time(int&hour&,int&min&,int&sec)&{&&& &&&&&&&&&&this.hour&=&hour&;&&& &&&&&&&&&&this.min&=&min&;&&& &&&&&&&&&&this.sec&=&sec&;&&& &&&&&&}&&& &}&& &
TestDefault.java(默认)：
程序代码：
public&class&TestDefault&&& &{&&& &&&&&&public&static&void&main(String&args[])&{&&& &&&&&&&&&&int&a&[]&=&new&int&[5]&;&&& &&&&&&&&&&System.out.println(&&&+&a[3])&;&&& &&&&&&}&&& &}& &
【编辑推荐】
【责任编辑： TEL：（010）】
大家都在看猜你喜欢
原创头条原创头条头条
24H热文一周话题本月最赞
讲师：2人学习过
讲师：24人学习过
讲师：12人学习过
精选博文论坛热帖下载排行
本书共10章，介绍的内容包括恶意软件（包括病毒、木马和蠕虫等）的深度防御方法，黑客的主要类型和防御方法，企业网络内、外部网络防火墙系...
订阅51CTO邮刊以下试题来自：
填空题在Java语言中，需要定义含有两个子数组的二维整型数组x，第一个子数组元素为7，8，第二个子数组元素为l，2，3，4，5，采用直接赋值创建此二维数组的语句为______。 int[][]x={{7，8}，{1，2，3，4，5}}；
为您推荐的考试题库
你可能感兴趣的试题
1.填空题 System．exit(0)；2A．ResultSet类 B．Driver Manager类C．Statement类 D．Connection类3A．将对象自己作为参数，调用别的方法B．当方法的局部变量隐藏成员变量时，利用this引用成员变量C．使用super调用超类的构造方法D．构造函数内调用另一构造函数4A．next B．breakC．switch D．continue5A．java.io包中 B．java. input包中C．Java．output包中 D．java．lang. io包中
热门相关试卷
最新相关试卷疯狂Java讲义：数组的初始化
疯狂Java讲义：数组的初始化
　　4.5.3 数组的初始化
　　Java语言中数组必须先初始化，然后才可以使用。所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值。
　　学生提问：能不能只分配内存空间，不赋初始值呢？
　　答：不行！一旦为数组的每个数组元素分配了内存空间，每个内存空间里存储的内容就是该数组元素的值，即使这个内存空间存储的内容是空，这个空也是一个值（null）。不管以哪种方式来初始化数组，只要为数组元素分配了内存空间，数组元素就具有了初始值，初始值的获得有两种形式：一种由系统自动分配，一种由程序员指定。
　　数组的初始化有两种方式：
　　静态初始化：初始化时由程序员显式指定每个数组元素的初始值，由系统决定需要的数组长度。
　　动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值。
　　静态初始化
　　静态初始化的语法格式如下：
　　arrayName = new type[]{element1, element2 , element3 , element4 …}
　　在上面的语法格式中，前面的type就是数组元素的数据类型，此处的type必须与定义数组变量时所使用的type相同，也可以是定义数组时所使用的type的子类；并使用花括号把所有的数组元素括起来，多个数组元素之间以英文逗号（，）隔开，定义初始化值的花括号紧跟[]之后。值得指出的是：执行静态初始化时，显式指定的数组元素值的类型必须与new关键字后type类型相同，或者是其子类的实例。下面代码定义使用了这三种形式类进行静态初始化：
　　程序清单：codes/04/4-5/TestArray.java
　　//定义一个int数组类型的变量，变量名为intArr.
　　int[] intA
　　//使用静态初始化，初始化数组时只指定数组元素的初始值，不指定数组长度。
　　intArr = new int[]{5, 6, 8 , 20};
　　//定义一个Object数组类型的变量，变量名为objArr.
　　Object[] objA
　　//使用静态初始化，初始化数组时数组元素的类型是定义数组时数组元素类型的子类
　　objArr = new String[] {"Java" , "李刚"};
　　Object[] objArr2 ;
　　//使用静态初始化
　　objArr2 = new Object[] {"Java" , "李刚"};
　　因为Java语言是面向对象的编程语言，能很好地支持子类和父类的继承关系：子类实例是一种特殊的父类实例。在上面程序中，String类型是Object类型的子类，即字符串是一种特殊的Object实例。关于继承更详细的介绍，请参考本书第5章。
　　除此之外，静态初始化还有如下简化的语法格式：
　　arrayName = {element1, element2 , element3 , element4 …}
　　在这种语法格式中，直接使用花括号来定义一个数组，花括号把所有数组元素括起来形成一个数组。
　　实际开发过程中，可能更习惯将数组定义和数组初始化同时完成，如下代码（程序清单同上）：
　　//数组的定义和初始化同时完成，使用简化的静态初始化写法
　　int[] a = {5, 6 , 7, 9};
　　动态初始化
　　动态初始化只指定数组的长度，由系统为每个数组元素指定初始值，动态初始化的语法格式如下：
　　arrayName = new type[length];
　　在上面语法中，需要指定一个int整型的length参数，这个参数指定了数组的长度，也就是可以容纳数组元素的个数。与静态初始化相似的，此处的type必须与定义数组时使用的type类型相同，或者是定义数组时使用的type类型的子类。下面代码示范了如何进行动态初始化（程序清单同上）：
　　//数组的定义和初始化同时完成，使用动态初始化语法
　　int[] prices = new int[5];
　　//数组的定义和初始化同时完成，初始化数组时元素的类型是定义数组时元素类型的子类
　　Object[] books = new String[4];
　　执行动态初始化时，程序员只需指定数组的长度，即为每个数组元素指定所需的内存空间，系统将负责为这些数组元素分配初始值。指定初始值时，系统按如下规则分配初始值：
　　数组元素的类型是基本类型中的整数类型（byte、short、int和long），则数组元素的值是0.
　　数组元素的类型是基本类型中的浮点类型（float、double），则数组元素的值是0.0.
　　数组元素的类型是基本类型中的字符类型（char），则数组元素的值是'\u0000'.
　　数组元素的类型是基本类型中的布尔类型（boolean），则数组元素的值是false.
　　数组元素的类型是引用类型（类、接口和数组），则数组元素的值是null.
　　不要静态初始化和动态初始化同时使用，也就是说不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值。
　　数组初始化完成后，就可以使用数组了，包括为数组元素赋值，访问数组元素值和获得数组长度等。
&&&&&& 返回目录：
&&&&&& 编辑推荐：
H3C认证Java认证Oracle认证
基础英语软考英语项目管理英语职场英语
.NETPowerBuilderWeb开发游戏开发Perl
二级模拟试题一级模拟试题一级考试经验四级考试资料
软件测试软件外包系统分析与建模敏捷开发
法律法规历年试题软考英语网络管理员系统架构设计师信息系统监理师
高级通信工程师考试大纲设备环境综合能力
路由技术网络存储无线网络网络设备
CPMP考试prince2认证项目范围管理项目配置管理项目管理案例项目经理项目干系人管理
职称考试题目
招生信息考研政治
网络安全安全设置工具使用手机安全
生物识别传感器物联网传输层物联网前沿技术物联网案例分析
Java核心技术J2ME教程
Linux系统管理Linux编程Linux安全AIX教程
Windows系统管理Windows教程Windows网络管理Windows故障
数据库开发Sybase数据库Informix数据库
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&[Java小程序] 将所有数值为0的元素置于数组最后 - Java学习: 让积累成为一种习惯 - ITeye技术网站
博客分类：
本文实现一个Java小程序： 将所有数值为0的元素置于数组最后。
移动前： [1, 3, 0, 3, 1, 4, 5, 0, 3, 1, 0, 2, 3, 1, 9, 8, 2, 2, 5, 2]
移动后： [1, 3, 3, 1, 4, 5, 3, 1, 2, 3, 1, 9, 8, 2, 2, 5, 2, 0, 0, 0]
如果数组中没有需要移动的数，那么就保持不变。
1. 定义一个与给定数组长度等长的整形数组，同时定义一个名为nonZerosCount的整形变量，用于统计不为0的元素个数。
2. 循环遍历给定的整形数组，如果该元素不为0，则将该位置的元素数值放置到目标数组上去，目标数组上的位置由变量nonZerosCount的值决定。
基于这两点，写出方法，如下：
public int[] moveZerosToEnd(int[] data) {
/**记录一个当前不为零的数字个数*/
int nonZerosCount = 0;
int[] result = new int[data.length];
for(int i=0;i&data.i++)
if( 0 != data[i])
result[nonZerosCount++] = data[i];
* 如果不为0的数字个数小于数组的长度，那么将剩余数组中的元素赋值为0。
因为整形数组元素的默认值是0，其实下面的步骤可以省略。
int length = data.
while(nonZerosCount & length)
result[nonZerosCount++] = 0;
这样，将所有值为0的元素放置到数组最后面的功能就实现了。
接下来，再实现一个方法，可以指定一个数字Num，然后将所有值为Num的的元素放置在数组的最后面。
public int[] moveNumToEnd(int[] data, int numToMove) {
/**记录一个当前不为numToMove的数字个数*/
int nonZerosCount = 0;
int[] result = new int[data.length];
for(int i=0;i&data.i++)
if( numToMove != data[i])
result[nonZerosCount++] = data[i];
* 剩余元素的组都是numToMove
int length = data.
while(nonZerosCount & length)
result[nonZerosCount++] = numToM
完整代码和测试结果如下：
public class MoveNumsToEndExample {
* 返回一个指定长度和范围的随机数组。
* @param seed
* @param length
public int[] generateRandomNumbers(int seed, int length)
int[] randomNumbers = new int[length];
Random ran = new Random();
for(int i=0;i&i++)
randomNumbers[i] = ran.nextInt(seed);
return randomN
public int[] moveZerosToEnd(int[] data) {
/**记录一个当前不为零的数字个数*/
int nonZerosCount = 0;
int[] result = new int[data.length];
for(int i=0;i&data.i++)
if( 0 != data[i])
result[nonZerosCount++] = data[i];
* 如果不为0的数字个数小于数组的长度，那么将剩余数组中的元素赋值为0。
因为整形数组元素的默认值是0，其实下面的步骤可以省略。
int length = data.
while(nonZerosCount & length)
result[nonZerosCount++] = 0;
public int[] moveNumToEnd(int[] data, int numToMove) {
/**记录一个当前不为numToMove的数字个数*/
int nonZerosCount = 0;
int[] result = new int[data.length];
for(int i=0;i&data.i++)
if( numToMove != data[i])
result[nonZerosCount++] = data[i];
* 剩余元素的组都是numToMove
int length = data.
while(nonZerosCount & length)
result[nonZerosCount++] = numToM
import java.util.A
public class Main {
public static void main(String[] args) {
MoveNumsToEndExample example = new MoveNumsToEndExample();
//产生一个随机整数数组
int[] randomNumber = example.generateRandomNumbers(10, 20);
System.out.print("Before moving zeros
System.out.println(Arrays.toString(randomNumber));
System.out.print("After
moving zeros
//移动所有的0到最后
System.out.println(Arrays.toString(example.moveZerosToEnd(randomNumber)));
//移动所有的1到最后
System.out.print("After
moving ones
System.out.println(Arrays.toString(example.moveNumToEnd(randomNumber,1)));
//移动所有的8到最后
System.out.print("After
moving eights --&");
System.out.println(Arrays.toString(example.moveNumToEnd(randomNumber,8)));
某一次运行的结果如下:
Before moving zeros& --&[3, 9, 1, 5, 2, 1, 3, 3, 8, 1, 8, 6, 5, 9, 8, 0, 0, 6, 0, 4]
After& moving zeros& --&[3, 9, 1, 5, 2, 1, 3, 3, 8, 1, 8, 6, 5, 9, 8, 6, 4, 0, 0, 0]
After& moving ones&& --&[3, 9, 5, 2, 3, 3, 8, 8, 6, 5, 9, 8, 0, 0, 6, 0, 4, 1, 1, 1]
After& moving eights --&[3, 9, 1, 5, 2, 1, 3, 3, 1, 6, 5, 9, 0, 0, 6, 0, 4, 8, 8, 8]
转载请注明出处：
要这么复杂？一头一尾两个指针，一个向后一个向前，遇到0和非0时交换数据不就可以了吗？
这样做是一种方法，但是并不能保证原有非零数字在数组中的顺序。
MouseLearnJava
浏览: 179607 次
来自: 杭州
simpleDean 写道请问，Logger.setLevel ...
我运行了这个例子，怎么结果是这样的：2号车泊车6号车泊车5号车 ...
nanjiwubing123 写道参考你的用法，用如下方式实现 ...
SurnameDictionary文章我没看完，现在懂了
SurnameDictionary.populateCorre ...