精华内容
下载资源
问答
  • JavaSE笔记05 一维数组

    2021-04-13 21:13:52
    一维数组的常见算法操作:1.一维数组的遍历:2.寻找一维数组中的最大值以及最小值:3.实现数组元素的反转:4.数组中的所有元素的求和/求平均:5.输入数组下标求对应元素以及输入数组元素求对应下标: 一.数组的...

    JavaSE笔记05 一维数组

    一.数组的概述:

    1.数组的概述:

    数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。数组既可以存储基本数据类型,也可以存储引用数据类型,注意数组必须将进行初始化,初始化之后才能使用。所谓的初始化就是在内存中为数组开辟一块空间,并为数组的元素赋其默认值

    一个数组的举例:
    int [] arr={10,30,50,70,90} ;
    对于上面的数组代码:
    数组arr为整型数组,即数组arr中只能存放整型的数组元素
    其次在arr数组中该数组的第一个元素是arr[0],其值是10,最后一个元素是arr[4],其值是90
    数组arr的长度是5

    2.数组的特点:

    数组的特点说明
    数组的长度一旦确定就不能修改
    创建数组对象会在内存中开辟一整块连续的空间。而数组名中引用的是这块连续空间的首地址
    遍历数组和获取某个元素的速度快,因为可以通过数组名+下标,直接定位到任意一个元素
    数组既可以存储基本数据类型,也可以存储引用数据类型
    //数组存储基本数据类型:
    int[] a = {80,90,100,110,120};  
    a数组的类型是:int[]
    元素的类型是int
    
    //数组存储引用数据类型:
     String[] strings = {“hello”,”java”};
     strings数组的类型是:String[]
     元素的类型是String
    

    3.数组的分类:

    数组的分类 分类的结果
    按照维度 一维数组、二维数组、多维数组
    按照元素的数据类型 基本数据类型元素的数据,引用数据类型元素的数组

    二.一维数组的初始化:

    Java中的数组必须先初始化,然后才能使用,所谓初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值
    对于一维数组的初始化有动态初始化静态初始化两种方法,对于这两种方法,各有特点:

    • 动态初始化: 只指定长度,由系统给出初始化值
    • 静态初始化: 给出初始化值,由系统决定长度
      注意事项: 这两种方式,只能使用一种,不能进行动静结合

    1.动态初始化数组:

    具体定义格式:
    数据类型[] 数组名 = new 数据类型[数组长度];
    数组长度其实就是数组中元素的个数
    举例: int[] arr = new int[3]; 定义了一个int类型的数组arr,这个数组可以存放3个int类型的值。

    对于上面的具体格式有两种表现格式:

    格式1: 数据类型[] 数组名;
    格式2: 数据类型 数组名[];

    两种格式中实际上更推荐使用第一种定义方式,比较清晰便捷
    接下来的数组动初始化实例将结合java程序在计算机内存进行说明,请先跳转至“三.Java中的内存分配以及堆栈的理解”进行阅读
    下面是关于动态初始化的代码实例:
    [1] 关于一个一维数组的动态初始化:

    class  ArrayTest{
    	public static void main(String[] args) {
    		int[] arr=new int[3];
    		System.out.println(arr); //打印数组的地址值
    		 arr[0]=10;
    		 arr[1]=20;
    		 arr[2]=30;
    
    		System.out.println(arr[0]);
    	}
    }
    

    在这里插入图片描述

    [2] 关于两个一维数组的动态初始化:

    class ArrayTest2 {
    	public static void main(String[] args) {
    		int[] arr=new int[3];
    		 arr[0]=10;
    		 arr[1]=20;
    		 arr[2]=30;
    
    		 int[] arr2=new int[2];
    		 arr2[0]=100;
    		 arr2[1]=200;
    		
    		//输出数组的地址值
    		System.out.println(arr);
    
    		System.out.println(arr2);
    
    		//输出数组中的元素
    		System.out.println(arr[2]);
    
    		System.out.println(arr2[0]);
    	}
    }
    

    在这里插入图片描述
    [3] 关于三个一维数组的动态初始化:(其中包含数组的引用)

    class  ArrayTest3{
    	public static void main(String[] args) {
    		int[] arr1=new int[2];
    		arr1[0]=15;
    		arr1[1]=20;
    
    		int[] arr2=new int[2];
    		arr2[0]=33;
    		arr2[1]=89;
    
    		int[] arr3=arr1;
    		arr3[0]=500;
    		//输出数组的地址值
    		System.out.println(arr1);  
    		System.out.println(arr2); 
    		System.out.println(arr3); 
    		//判断两个数组的地址值是否相等
    		System.out.println(arr1==arr3);
    		//输出数组中的元素
    		System.out.println(arr1[0]); 
    		System.out.println(arr1[1]);
    
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]); 
    
    		System.out.println(arr3[0]); 
    		System.out.println(arr3[1]); 
    	}
    }
    

    在这里插入图片描述

    2.静态初始化数组:

    静态初始化的格式:

    格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
    举例: int[] arr = new int[]{1,2,3};

    简化格式:
    数据类型[] 数组名 = {元素1,元素2,…};
    举例: int[] arr = {1,2,3};

    关于静态初始化数组的相关代码以及内存图解:

    class  ArrayDemo5{
    	public static void main(String[] args) {
    		//数组的静态初始化:由我们为数组元素赋值,由系统计算长度
    		int[] arr=new int[]{20,30,50,60};
    		arr[0]=30;
    		//静态初始化的简写方式,省略new那部分不写
    		double[] arr2={3.14,5.8,68,3.9};
    		System.out.println(arr[0]);
    		System.out.println(arr2[0]);
    	}
    }
    

    在这里插入图片描述

    三.Java中的内存分配以及堆栈的理解:

    首先需要介绍的是java虚拟机的内存分布图:
    在这里插入图片描述
    然后是着重对于堆内存和栈内存的比较:

    堆和栈存放变量的区别和说明
    栈:存放的局部变量。所谓局部变量是在方法中定义或者在方法声明上的变量
    堆:存放的是所有new出来的对象(数组也是对象)

    最后是对于整个java虚拟机中的各个部分的详细介绍:
    在这里插入图片描述

    四.数组操作中的两个常见异常:

    • ArrayIndexOutOfBoundsException:数组索引越界异常

    出现原因: 在获取数组元素或者给数组元素赋值访问了不存在的索引,就会出现数组角标越界
    代码演示:

    public class test {
        public static void main(String[] args) {
            int[] arr={10,20,30,40,50,60,70,80,90};
            for(int i=0;i<10;i++){
                System.out.println(arr[i]);
            }
        }
    }
    

    运行截图:
    在这里插入图片描述

    • NullPointerException:空指针异常

    出现原因: 在使用空数组进行方法操作时,传参传空参数等等都会造成这种异常
    代码演示:

    public class test {
        public static void main(String[] args) {
            String a=null;
            int x=a.length;
            System.out.println(x);
            }
        }
    }
    

    运行截图:
    在这里插入图片描述

    五.一维数组的常见算法及操作:

    1.一维数组的遍历:

    正序遍历:

    package zjl.westos.nwpu;
    
    //遍历数组中的所有元素,使用下标遍历法:
    public class ArrFind {
        public static void main(String[] args){
            int[] arr={0,1,2,3,4};
            for(int j=0;j<arr.length;j++){
                System.out.print(arr[j]+" ");
            }
        }
    }
    

    在这里插入图片描述
    倒叙遍历:

    package zjl.westos.nwpu;
    
    public class ArrFindInReverse {
        public static void main(String[] args){
            int[] array={20,30,40,50,60};
            for(int i=array.length-1;i>=0;i--){
                System.out.println(array[i]);
            }
        }
    }
    

    在这里插入图片描述

    2.寻找一维数组中的最大值以及最小值:

    package zjl.westos.nwpu;
    
    public class ArrFindMaxAndMin {
        public static void main(String[] args) {
            int[] array = {20, 30, 40, 50, 60, 70, 80};
            int emax = 0;
            int emin = 1000000;
            for (int elem : array) {
                if (elem > emax) emax = elem;
            }
            System.out.println("Array中的最大值是:" + emax);
            for (int elem : array) {
                if (elem < emin) emin = elem;
            }
            System.out.println("Array中的最小值是:" + emin);
        }
    }
    

    在这里插入图片描述

    3.实现数组元素的反转:

    package zjl.westos.nwpu;
    
    public class ArrReverse {
        public static void main(String[] args){
            int[] arr={10,20,30,40,50,60};
    
            int i,j;
            for (i=0,j=arr.length-1;i<j;i++,j--){
                int t=arr[i];
                arr[i]=arr[j];
                arr[j]=t;
            }
            for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
        }
    }
    

    在这里插入图片描述

    4.数组中的所有元素的求和/求平均:

    package zjl.westos.nwpu;
    
    public class ArrSumAndAverage {
        public static void main(String[] args) {
            int[] arr={10,20,30,40,50,60,70,80};
            int sum=0;
            double average;
            for (int i = 0; i < arr.length; i++) {
                sum+=arr[i];
            }
            average = sum*1.0/arr.length;
            System.out.println("数组中的值总和是:"+sum);
            System.out.println("数组中元素的平均值是:"+average);
        }
    }
    

    在这里插入图片描述

    5.输入数组下标求对应元素以及输入数组元素求对应下标:

    我将两个算法的代码融入了一个程序:

    package zjl.westos.nwpu;
    import java.util.Scanner;
    
    public class Week {
        public static void main(String[] args) {
            String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期七", "星期二"};
            Scanner input = new Scanner(System.in);
            System.out.println("请输入需要寻找的角标对应的元素:");
            int index_find = input.nextInt();
            String x = getElemFromIndex(week, index_find);
            System.out.println("对应角标的元素是:" + x);
    
            System.out.println("请输入需要寻找的元素及其对应的位置:输入内容是星期一至七");
            String s = input.next();
            getIndexFromElem(week, s);
        }
    
        public static String getElemFromIndex(String[] arr, int t) {
            return arr[t];
        }
    
        public static void getIndexFromElem(String[] arr, String t) {
            int []elem=new int[arr.length];
            int flag = 0;
            for (int i = 0; i < arr.length; i++) {
                if (t.equals(arr[i])) {
                    elem[flag] = i;
                    flag++;
                }
            }
            System.out.print("共出现了"+flag+"次,位置分别是:");
            if(elem[0]==0&&flag!=0){
                System.out.print(elem[0]+" ");
            }
            else if(elem[0]!=0){
                System.out.print(elem[0]+" ");
            }
            for(int i=1;i< elem.length;i++){
                if(elem[i]!=0){
                        System.out.print(elem[i]+" ");
                    }
                    else break;
            }
        }
    }
    

    注意:
    (1) String类型的元素在比较时不能使用==,使用==比较的是两个字符串所指向的地址,而使用s1.equals(s2)才比较的是字符串s1和s2的字面值是否相等
    (2) 函数getIndexFromElem中的循环体意义在于将出现次数不止一次的元素记录下来并输出
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 在程序中可以使用下标变量,即说明这些变量的整体为数...二维多维数组可以看作是一维数组的多次叠加产生的。 数组是计算机编程中的重要概念,运用数组可以方便地处理大规模的数据。 PHP 中的数组实际上是一个有...

    在程序中可以使用下标变量,即说明这些变量的整体为数组,数组中的每个变量的数据类型是相同的。
    当数组中每个元素都只带有一个下标时,称这样的数组为一维数组。
    一维数组是由数字组成的以单纯的排序结构排列的结构单一的数组。一维数组是计算机程序中最基本的数组。二维及多维数组可以看作是一维数组的多次叠加产生的。
    数组是计算机编程中的重要概念,运用数组可以方便地处理大规模的数据。
    PHP 中的数组实际上是一个有序映射。映射是一种把 values 关联到 keys 的类型。此类型在很多方面做了优化,因此可以把它当成真正的数组,或列表(向量),散列表(是映射的一种实现),字典,集合,栈,队列以及更多可能性。由于数组元素的值也可以是另一个数组,树形结构和多维数组也是允许的。
    下面我来介绍一个简单的一维数组求最大值、最小值、平均值;代码如下
    在这里插入图片描述
    结果如下:
    在这里插入图片描述
    本篇文章就是关于求一维数组98,23,76,99,88,68的最大值、最小值和平均值的具体介绍,仅供参考,希望对有需要的朋友有所帮助!

    展开全文
  • C#数组的应用:冒泡排序,折半查找维数组的应用 人类思维--计算机逻辑思维逻辑思维--代码实现 写书法:描红——临摹——碑贴——自成一体——草 复习:数组:一维,二维,多维一维:豆角。连续,同一类型。...

    C#数组的应用:冒泡排序,折半查找及二维数组的应用

    人类思维--计算机逻辑思维
    逻辑思维--代码实现

    写书法:
    描红——临摹——碑贴——自成一体——草

    复习:
    数组:一维,二维,多维
    一维:豆角。连续,同一类型。
    定义:数据类型[] 数组名=new 数据类型[长度]{.,.,.,.};
    赋值:数组名[下标] = 值
    取值:数组名[下标]
    灵活运用:与for循环的结合应用。
    1.求最大值,最小值。
    2.求总和,平均。
    3.随机(生成下标)抽值。

    数组的应用:
    (一).冒泡排序。
    1.冒泡排序是用双层循环解决。外层循环的是趟数,里层循环的是次数。
    2.趟数=n-1;次数=n-趟数。
    3.里层循环使用if比较相临的两个数的大小,进行数值交换。

    作业:
    1.先把冒泡排序写一遍。

    int[] a = new int[] { 23, 2, 5, 12, 55, 4, 6, 45, 34, };
    for (int i = 1; i <= a.Length; i++)//第一次循环趟数为数组长度-1
    {
    for (int j = 1; j <= a.Length - i; j++)//第二层循环次数为数组长度-循环趟数
    {
    if (a[j] > a[j - 1])//判断两个相邻数组元素的大小
    {
    int m = a[j - 1];//将两个数组元素的值调换
    a[j - 1] = a[j];
    a[j] = m;
    }
    }
    }
    for (int i = 0; i < a.Length; i++)//输出数组元素
    {
    Console.WriteLine(a[i]);
    }


    2.使用冒泡排序,做青歌赛的打分程序。要求去掉两个最高,两个最低分,求平均得分。

    代码。

    Console.WriteLine("请评委老师打分");
    int[] a = new int[10];
    for (int i = 0; i < a.Length; i++)
    {
    a[i] = Convert.ToInt32(Console.ReadLine());
    }
    for (int i = 1; i <= a.Length - 1; i++)//第一次循环趟数为数组长度-1
    {
    for (int j = 1; j <= a.Length - i; j++)//第二层循环次数为数组长度-循环趟数
    {
    if (a[j] > a[j - 1])
    {
    int m = a[j];//将两个数组元素的值调换
    a[j] = a[j - 1];
    a[j - 1] = m;
    }
    }
    }
    int sum = 0;
    Console.WriteLine("选手得分为");
    for (int i = 0; i < a.Length; i++)//输出选手的得分
    {
    Console.Write(a[i] + "\t");
    }

    for (int i = 2; i < a.Length - 2; i++)//计算去掉两个最高分和最低分后的总分
    {
    sum = sum + a[i];
    }
    double avg = 1.0 * sum / (a.Length - 4);//计算去掉两个最高分和最低分后的平均分
    Console.WriteLine("选手得分去掉两个最高分和两个最低分最后得分为" + avg + "分。");

    (二).折半查找。
    前提:数组必须是有序的。
    思路:用两个变量分别代表上限(top)和下限(bottom)的下标,再用一个变量代表中间(mid)的下标。
    1.求中间下标:mid = (top+bottom)/2
    2.上限下标下移:top = mid+1. 假设数组是升序排列。
    3.下限下标上移:bottom = mid-1;
    4.循环条件是:bottom>=top
    static void Main(string[] args)
    {
    int[] a = new int[] { 3, 5, 7, 9, 11, 13, 14, 18 };

    Console.Write("请输入要找的数:");
    int find = Convert.ToInt32(Console.ReadLine());

    int top, bottom, mid; //上限下标,下限下标,中间下标
    top = 0;
    bottom = a.Length - 1;

    while(bottom>=top) //只要下限下标还在上限下标的下面,就循环,否则没找到就结束。
    {
    //算中间下标
    mid = (top + bottom) / 2;
    //取中间的值
    int n = a[mid];
    if(n < find)
    {
    top = mid + 1; //调整上限的下标
    }
    else if(n>find)
    {
    bottom = mid - 1;// 调整下限的下标。
    }
    else
    {
    Console.WriteLine("找到了,在第" + mid + "个元素上");
    break;
    }
    }
    }

    例题:

    int[] a = new int[] { 3, 4, 5, 7, 8, 12, 15, 17 };
    Console.Write("请输入数值");
    int n = Convert.ToInt32(Console.ReadLine());
    int top = 0, bottom = a.Length - 1, mid;
    while (top <= bottom)
    {
    mid = (top + bottom) / 2;
    if (n > a[mid])
    {
    top = mid + 1;
    }
    else if (n < a[mid])
    {
    bottom = mid - 1;

    }
    else
    {
    Console.WriteLine("找到了,在第" + (mid + 1) + "个元素上");
    break;
    }


    }

    二维数组:
    表格的模型。
    定义:
    数据类型[,] 数组名 = new 数组类型[维度长度,维度长度];
    int[,] a = new int[3,4];
    int[,] a = new int[3, 4] { { 1, 2, 3, 4 },{ 5, 6, 7, 8 }, { 9, 0, 9, 8 } };
    赋值:
    数组名[下标,下标] = 值;
    a[0,0] = 5;
    a[2,3] = 10;
    取值:
    数组名[下标,下标];


    应用:

    推箱子游戏:

    //数据输入

    int x=3, y=1;//记录小人初始位置
    int[,] map= new int[10, 10]
    {
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,0,0,1,0,0,0,1},
    {1,0,0,0,0,1,0,0,0,1},
    {1,4,2,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,3,1},
    {1,1,1,1,1,1,1,1,1,1}
    };

    //打印初始图
    for (int i = 0; i < 10; i++)
    {
    for (int j = 0; j < 10; j++)
    {
    if (map[i, j] == 0)
    {
    Console.Write(" ");
    }
    else if (map[i, j] == 1)
    {
    Console.Write("■");
    }
    else if (map[i, j] == 2)
    {
    Console.Write("□");
    }
    else if (map[i, j] == 3)
    {
    Console.Write("★");
    }
    else if (map[i, j] == 4)
    {
    Console.Write("♀");
    }
    }

    Console.WriteLine();
    }

    //在键盘接受指令,对指令分析运算,输出数据
    while (true)//无数次执行循环体
    {

    ConsoleKeyInfo s = Console.ReadKey();//在键盘接受指令
    int t = map[x,y];

    if (s.Key.ToString() == "RightArrow")//若接受指令为“→”,
    {
    if (map[x, y + 1] == 0)//若右边方格为空格,小人物与空格交换数据
    {
    map[x, y] = map[x, y + 1];
    map[x, y + 1] = t;
    y++;
    }
    else if (map[x, y + 1] == 2 && map[x, y + 2] !=1)//若右边方格为箱子,右边方格接受小人物数据,小人物方格数据变零,右数第二个方格接受箱子方格数据
    {
    int m = map[x, y + 1];
    map[x, y + 1] = t;
    map[x, y] = 0;
    map[x, y + 2] = m;
    y++;

    }
    }
    else if (s.Key.ToString() == "LeftArrow")
    {
    if (map[x, y - 1] == 0)
    {
    map[x, y] = map[x, y - 1];
    map[x, y - 1] = t;
    y--;
    }
    else if (map[x, y - 1] == 2 && map[x, y - 2]!=1)
    {
    int m = map[x, y - 1];
    map[x, y - 1] = t;
    map[x, y] = 0;
    map[x, y - 2] = m;
    y--;

    }
    }
    else if (s.Key.ToString() == "UpArrow")
    {
    if (map[x - 1, y]==0)
    {
    map[x, y] = map[x - 1, y];
    map[x-1,y] = t;
    x--;
    }
    else if (map[x - 1, y] == 2 && map[x-2, y ] != 1)
    {
    int m = map[x-1, y ];
    map[x - 1, y] = t;
    map[x, y] = 0;
    map[x - 2, y] = m;
    x--;

    }


    }
    else if (s.Key.ToString() == "DownArrow")
    {
    if (map[x + 1, y] == 0)
    {
    map[x, y] = map[x + 1, y];
    map[x + 1, y] = t;
    x++;
    }
    else if (map[x + 1, y] == 2 && map[x + 2, y] != 1)
    {
    int m = map[x + 1, y];
    map[x + 1, y] = t;
    map[x , y] = 0;
    map[x + 2, y] =m;
    x++;

    }

    }
    Console.Clear();

    for (int i = 0; i < 10; i++)
    {
    for (int j = 0; j < 10; j++)
    {
    if (map[i, j] == 0)
    {
    Console.Write(" ");
    }
    else if (map[i, j] == 1)
    {
    Console.Write("■");
    }
    else if (map[i, j] == 2)
    {
    Console.Write("□");
    }
    else if (map[i, j] == 3)
    {
    Console.Write("★");
    }
    else if (map[i, j] == 4)
    {
    Console.Write("♀");
    }
    }

    Console.WriteLine();
    }
    if (map[9, 9] == 2)
    Console.WriteLine("恭喜成功!");

    }

    转载于:https://www.cnblogs.com/wllhq/p/4189874.html

    展开全文
  • 数组一维,二维,多维 一维:豆角。连续,同一类型。 定义:数据类型[] 数组名=new 数据类型[长度]{.,.,.,.}; 赋值:数组名[下标] = 值 取值:数组名[下标] 灵活运用:与for循环的结合应用。 1.求最大值,...
    人类思维--计算机逻辑思维
    逻辑思维--代码实现
    
    写书法:
    描红——临摹——碑贴——自成一体——草
    
    复习:
    数组:一维,二维,多维
    一维:豆角。连续,同一类型。
    定义:数据类型[] 数组名=new 数据类型[长度]{.,.,.,.};
    赋值:数组名[下标] = 值
    取值:数组名[下标]
    灵活运用:与for循环的结合应用。
    1.求最大值,最小值。
    2.求总和,平均。
    3.随机(生成下标)抽值。
    
    数组的应用:
    (一).冒泡排序。
    1.冒泡排序是用双层循环解决。外层循环的是趟数,里层循环的是次数。
    2.趟数=n-1;次数=n-趟数。
    3.里层循环使用if比较相临的两个数的大小,进行数值交换。
    
    作业:
    1.先把冒泡排序写一遍。
    
    int[] a = new int[] { 23, 2, 5, 12, 55, 4, 6, 45, 34, };
    for (int i = 1; i <= a.Length; i++)//第一次循环趟数为数组长度-1
    {
    for (int j = 1; j <= a.Length - i; j++)//第二层循环次数为数组长度-循环趟数
    {
    if (a[j] > a[j - 1])//判断两个相邻数组元素的大小
    {
    int m = a[j - 1];//将两个数组元素的值调换
    a[j - 1] = a[j];
    a[j] = m;
    }
    }
    }
    for (int i = 0; i < a.Length; i++)//输出数组元素
    {
    Console.WriteLine(a[i]);
    }
    
    2.使用冒泡排序,做青歌赛的打分程序。要求去掉两个最高,两个最低分,求平均得分。
    
    代码。
    
    Console.WriteLine("请评委老师打分");
    int[] a = new int[10];
    for (int i = 0; i < a.Length; i++)
    {
    a[i] = Convert.ToInt32(Console.ReadLine());
    }
    for (int i = 1; i <= a.Length - 1; i++)//第一次循环趟数为数组长度-1
    {
    for (int j = 1; j <= a.Length - i; j++)//第二层循环次数为数组长度-循环趟数
    {
    if (a[j] > a[j - 1])
    {
    int m = a[j];//将两个数组元素的值调换
    a[j] = a[j - 1];
    a[j - 1] = m;
    }
    }
    }
    int sum = 0;
    Console.WriteLine("选手得分为");
    for (int i = 0; i < a.Length; i++)//输出选手的得分
    {
    Console.Write(a[i] + "\t");
    }
    
    for (int i = 2; i < a.Length - 2; i++)//计算去掉两个最高分和最低分后的总分
    {
    sum = sum + a[i];
    }
    double avg = 1.0 * sum / (a.Length - 4);//计算去掉两个最高分和最低分后的平均分
    Console.WriteLine("选手得分去掉两个最高分和两个最低分最后得分为" + avg + "分。");
    
    
    
    (二).折半查找。
    前提:数组必须是有序的。
    思路:用两个变量分别代表上限(top)和下限(bottom)的下标,再用一个变量代表中间(mid)的下标。
    1.求中间下标:mid = (top+bottom)/2
    2.上限下标下移:top = mid+1.     假设数组是升序排列。
    3.下限下标上移:bottom = mid-1;
    4.循环条件是:bottom>=top
    static void Main(string[] args)
    {
    int[] a = new int[] { 3, 5, 7, 9, 11, 13, 14, 18 };
    
    Console.Write("请输入要找的数:");
    int find = Convert.ToInt32(Console.ReadLine());
    
    int top, bottom, mid; //上限下标,下限下标,中间下标
    top = 0;
    bottom = a.Length - 1;
    
    while(bottom>=top) //只要下限下标还在上限下标的下面,就循环,否则没找到就结束。
    {
    //算中间下标
    mid = (top + bottom) / 2;
    //取中间的值
    int n = a[mid];
    if(n < find)
    {
    top = mid + 1; //调整上限的下标
    }
    else if(n>find)
    {
    bottom = mid - 1;// 调整下限的下标。
    }
    else
    {
    Console.WriteLine("找到了,在第" + mid + "个元素上");
    break;
    }
    }
    }
    
    例题:
    
    int[] a = new int[] { 3, 4, 5, 7, 8, 12, 15, 17 };
    Console.Write("请输入数值");
    int n = Convert.ToInt32(Console.ReadLine());
    int top = 0, bottom = a.Length - 1, mid;
    while (top <= bottom)
    {
    mid = (top + bottom) / 2;
    if (n > a[mid])
    {
    top = mid + 1;
    }
    else if (n < a[mid])
    {
    bottom = mid - 1;
    
    }
    else
    {
    Console.WriteLine("找到了,在第" + (mid + 1) + "个元素上");
    break;
    }
    
    
    }
    
    
    
    二维数组:
    表格的模型。
    定义:
    数据类型[,] 数组名 = new 数组类型[维度长度,维度长度];
    int[,] a = new int[3,4];
    int[,] a = new int[3, 4] { { 1, 2, 3, 4 },{ 5, 6, 7, 8 }, { 9, 0, 9, 8 } };
    赋值:
    数组名[下标,下标] = 值;
    a[0,0] = 5;
    a[2,3] = 10;
    取值:
    数组名[下标,下标];
    应用:
    
    推箱子游戏:
    static void Main(string[] args)
    {
    int x = 3, y = 1;//记录小人初始位置
    int[,] map= new int[10, 10]
    {
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,0,0,1,0,0,0,1},
    {1,0,0,0,0,1,0,0,0,1},
    {1,4,2,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,3,1},
    {1,1,1,1,1,1,1,1,1,1}
    };
    
    //在键盘接受指令,对指令分析运算,输出数据
    while (true)//无数次执行循环体
    {
    for (int i = 0; i < 10; i++)//打印初始图
    {
    for (int j = 0; j < 10; j++)
    {
    if (map[i, j] == 0)
    {
    Console.Write(" ");
    }
    else if (map[i, j] == 1)
    {
    Console.Write("");
    }
    else if (map[i, j] == 2)
    {
    Console.Write("");
    }
    else if (map[i, j] == 3)
    {
    Console.Write("");
    }
    else if (map[i, j] == 4)
    {
    Console.Write("");
    }
    }
    
    Console.WriteLine();
    }
    
    ConsoleKeyInfo s = Console.ReadKey();//在键盘接受指令
    int t = map[x,y];
    
    if (s.Key.ToString() == "RightArrow")//若接受指令为“→”,
    {
    if (map[x, y + 1] == 0)//若右边方格为空格,小人物与空格交换数据
    {
    map[x, y] = map[x, y + 1];
    map[x, y + 1] = t;
    y++;
    }
    else if (map[x, y + 1] == 2 && map[x, y + 2] != 1)//若右边方格为箱子,右边方格接受小人物数据,小人物方格数据变零,右数第二个方格接受箱子方格数据
    {
    int m = map[x, y + 1];
    map[x, y + 1] = t;
    map[x, y] = 0;
    map[x, y + 2] = m;
    y++;
    
    
    }
    }
    else if (s.Key.ToString() == "LeftArrow")
    {
    if (map[x, y - 1] == 0)
    {
    map[x, y] = map[x, y - 1];
    map[x, y - 1] = t;
    y--;
    }
    else if (map[x, y - 1] == 2 && map[x, y - 2]!=1)
    {
    int m = map[x, y - 1];
    map[x, y - 1] = t;
    map[x, y] = 0;
    map[x, y - 2] = m;
    y--;
    
    }
    }
    else if (s.Key.ToString() == "UpArrow")
    {
    if (map[x - 1, y]==0)
    {
    map[x, y] = map[x - 1, y];
    map[x-1,y] = t;
    x--;
    }
    else if (map[x - 1, y] == 2 && map[x-2, y ] != 1)
    {
    int m = map[x-1, y ];
    map[x - 1, y] = t;
    map[x, y] = 0;
    map[x - 2, y] = m;
    x--;
    
    }
    
    
    }
    else if (s.Key.ToString() == "DownArrow")
    {
    if (map[x + 1, y] == 0)
    {
    map[x, y] = map[x + 1, y];
    map[x + 1, y] = t;
    x++;
    }
    else if (map[x + 1, y] == 2 && map[x + 2, y] != 1)
    {
    int m = map[x + 1, y];
    map[x + 1, y] = t;
    map[x , y] = 0;
    map[x + 2, y] =m;
    x++;
    
    
    }
    
    }
    Console.Clear();
    
    
    if (map[8, 8] == 2)//箱子推到指定位置,跳出循环
    {
    break;
    }
    
    }
    Console.WriteLine("恭喜成功!");
    
    

     


     

    转载于:https://www.cnblogs.com/dawasai/p/4190355.html

    展开全文
  • 2019-12-25

    2019-12-25 16:06:15
    一维数组最小值及下标 ** 有一数组内放5个整数,要求找出第一次出现的最小数和它的下标,然后把它和数组中最前面的元素即第一个数对换位置。输入格式:在一行中输入5个用空格间隔的整数。输出格式:在第一行输出变化后...
  • 第二次作业

    2018-11-27 23:52:00
    1. 薄弱知识点:(1)输出的格式控制;比如中段测试中输出值需要保留两位小数,忘记关键知识 (setprecision);...7-3一维数组最小值及下标(10 分) 有一数组内放5个整数,要求找出第一次出现的最...
  • 二、一维数组创建数组(静态/动态)获取数组下标及常见错误类型获取数组长度每个元素的长度一维数组中某个元素出现了几次求数组中最大/最小值数组的遍历与逆置利用增强for循环遍历数组复制数组将两个数组组合成一...
  • javaSE 数组练习题1

    2019-05-25 15:31:16
    1. 定义一个包含10个元素的数组,对其进行赋值,使每个元素的值等于其下标 int[] arr=new int[10]; for(int i=0;...2 定义一个10个元素组成的一维数组,求该数组中的最大值和最小值最大值和最...
  • 输入10个整数,存放在一维数组中,找出值最大和最小的元素,输出最大值、最小值及它们所在的元素下标。 【输入】 输入10个整数,整数以空格间隔。 【输出】 第一行输出最大值及其所在的元素下标,最大值和下标以空格...
  • 输入10个整数,存放在一维数组中,找出值最大和最小的元素,输出最大值、最小值及它们所在的元素下标。 【输入】 在一行中输入10个整数,整数以空格间隔。 【输出】 第一行输出最大值及其所在的元素下标,最大值和...
  • 面试题3:二维数组中的查找:对于在个每行从左到右依次递增,每列从上到下依次递增的二维数组查找个元素,可以选择从数组左上角开始查找array[i][j],如果目标元素大于array[i][j],i+=1,如果元素小于array...
  • 提示:可考虑用两个一维数组实现学生成绩和学生信息的存储。 (19)歌手大赛评分 某歌手大赛,共有十个评委给选手打分,分数采用百分制,去掉一个最高分,去掉一个最低分,然后取平均分,得到歌手的最后成绩。 ...
  • java范例开发大全(pdf&源码)

    热门讨论 2013-07-04 13:04:40
    实例55 一维数组的创建与使用 78 实例56 按相反的顺序输出 79 实例57 奇偶分组 80 实例58 找宝 81 实例59 寻找最小数 82 实例60 我的位置在哪里 83 实例61 复制数组 85 实例62 插入新元素 86 实例63 数组的合并 87 ...
  • Java范例开发大全 (源程序)

    热门讨论 2011-04-27 07:47:22
     实例55 一维数组的创建与使用 78  实例56 按相反的顺序输出 79  实例57 奇偶分组 80  实例58 找宝 81  实例59 寻找最小数 82  实例60 我的位置在哪里 83  实例61 复制数组 85  实例62 插入新元素 86...
  • java范例开发大全源代码

    热门讨论 2011-10-30 23:31:51
     实例55 一维数组的创建与使用 78  实例56 按相反的顺序输出 79  实例57 奇偶分组 80  实例58 找宝 81  实例59 寻找最小数 82  实例60 我的位置在哪里 83  实例61 复制数组 85  实例62 插入...
  • java范例开发大全

    2013-03-08 20:06:54
    实例55 一维数组的创建与使用 78 实例56 按相反的顺序输出 79 实例57 奇偶分组 80 实例58 找宝 81 实例59 寻找最小数 82 实例60 我的位置在哪里 83 实例61 复制数组 85 实例62 插入新元素 86 实例63 数组的合并 87 ...
  • 实例042 获取一维数组最小值 实例043 将二维数组中的行列互换 实例044 利用数组随机抽取幸运观众 实例045 用数组设置JTable表格的列名与列宽 3.2 数组操作 实例046 数组的下标界限 实例047 按钮控件数组实现...
  • 实例042 获取一维数组最小值 实例043 将二维数组中的行列互换 实例044 利用数组随机抽取幸运观众 实例045 用数组设置JTable表格的列名与列宽 3.2 数组操作 实例046 数组的下标界限 实例047 按钮控件数组实现...
  • 实例042 获取一维数组最小值 实例043 将二维数组中的行列互换 实例044 利用数组随机抽取幸运观众 实例045 用数组设置JTable表格的列名与列宽 3.2 数组操作 实例046 数组的下标界限 实例047 按钮控件数组实现...
  • 实例042 获取一维数组最小值 实例043 将二维数组中的行列互换 实例044 利用数组随机抽取幸运观众 实例045 用数组设置JTable表格的列名与列宽 3.2 数组操作 实例046 数组的下标界限 实例047 按钮控件数组实现...
  • 实例042 获取一维数组最小值 实例043 将二维数组中的行列互换 实例044 利用数组随机抽取幸运观众 实例045 用数组设置JTable表格的列名与列宽 3.2 数组操作 实例046 数组的下标界限 实例047 按钮控件数组实现...
  • 实例042 获取一维数组最小值 52 实例043 将二维数组中的行列互换 53 实例044 利用数组随机抽取幸运观众 54 实例045 用数组设置JTable表格的列名与列宽 55 3.2 数组操作 57 实例046 数组的下标界限 57 实例047 按钮...
  • 实例042 获取一维数组最小值 52 实例043 将二维数组中的行列互换 53 实例044 利用数组随机抽取幸运观众 54 实例045 用数组设置JTable表格的列名与列宽 55 3.2 数组操作 57 实例046 数组的下标界限 57 实例047 按钮...
  • 说明:抽取单一维度组成一维数组。相当于 SQL 语句"Select 字段 from 表"。返回值为 Array 类型。 Objs(输入数据).colList(字段名); 示例代码: // 从员工数据中获取所有姓名 Objs(input).colList('name'); 执行结果...
  • 实例042 获取一维数组最小值 52 实例043 将二维数组中的行列互换 53 实例044 利用数组随机抽取幸运观众 54 实例045 用数组设置JTable表格的列名与列宽 55 3.2 数组操作 57 实例046 数组的下标界限 57 实例047 按钮...
  • 实例042 获取一维数组最小值 52 实例043 将二维数组中的行列互换 53 实例044 利用数组随机抽取幸运观众 54 实例045 用数组设置JTable表格的列名与列宽 55 3.2 数组操作 57 实例046 数组的下标界限 57 实例047 按钮...
  • Java范例开发大全(全书源程序)

    热门讨论 2013-04-05 11:50:26
    实例55 一维数组的创建与使用 78 实例56 按相反的顺序输出 79 实例57 奇偶分组 80 实例58 找宝 81 实例59 寻找最小数 82 实例60 我的位置在哪里 83 实例61 复制数组 85 实例62 插入新元素 86 实例63 数组的...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    <br>实验四 综合(课程设计) 内容步骤: 1、假定一维数组a[n]中的每个元素值均在[0,200]区间内,用C++编写一个算法,分别统计出落在[0,20],[21,50],[51,80],[81,130],[131,200]等各区间内的元素...

空空如也

空空如也

1 2
收藏数 36
精华内容 14
关键字:

一维数组最小值及下标