java-数组静态初始化、选择排序、冒泡排序、数组的折半查找、折半查找练习

最新推荐文章于 2023-10-27 17:05:08 发布
最新推荐文章于 2023-10-27 17:05:08 发布
阅读量442 收藏 1
点赞数 2
分类专栏： S1:Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32823673/article/details/71791395
版权

（一）数组静态初始化

1.

package test;

public class test {

	public static void main(String [] args)
	{
		//元素类型[]  数组名=new  元素类型[元素个数]     (关键字new用来在内存中产生一个容器实体，用来存储很多数据的地方)
		//需求：  想定义一个可以储存3个整数的容器
		/*int[] x=new int[3];
		int x[]=new int[3];//等价于上面的，但是最好用上面的
		int[] x=new int[]{3,1,2,7,4,5};//数组中元素的内容静态初始化
		int[] x={3,1,2,7,4,5};
		
		int[] x=new int[5];
		x[0]=90;
		x[1]=80;*/
		int[] a=new int[3];
		System.out.println(a[2]);
	}
}


控制台输出结果：
0

package test;

public class test {

	public static void main(String [] args)
	{
		//获取数组中的元素
		//int arr[]=new int[3];
		int[] arr={1,2,7,4,5,6};
		//数组中有一个属性可以直接获取到数组元素个数，length
		//使用方式，数组名称.length=
		//System.out.println(arr.length);
		int sum=0;
		for(int x=0;x<arr.length;x++)
		{
			sum+=arr[x];
			System.out.println("arr["+x+"]="+arr[x]+';');
		}
		
		System.out.println(sum);
	}
}


arr[0]=1;
arr[1]=2;
arr[2]=7;
arr[3]=4;
arr[4]=5;
arr[5]=6;
25

（二）排序（选择排序）

package test;

public class test {
	public  static void fun(int[] arr)
	{
		for(int x=0;x<arr.length-1;x++)
		{
			for(int y=x+1;y<arr.length;y++)
			{
				if(arr[x]>arr[y])
				{
					int temp=arr[x];
					arr[x]=arr[y];
					arr[y]=temp;
				}
			}
		}
		
	}
	public static void main(String[] args)
	{
		int[] arr={3,4,5,12,1,3};//此处要是没有“【】”会报错
		//在排序前打印
		print(arr);
		fun(arr);
		//在排序后打印
		print(arr);
	}
	
	public static void print(int[] arr)
	{
		System.out.print("[");
		for(int x=0;x<arr.length;x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}
	
}


控制台输出结果：
[3,4,5,12,1,3]
[1,3,3,4,5,12]

2.冒泡排序：

package test;

public class test {
	public  static void fun(int[] arr)
	{
		for(int x=0;x<arr.length-1;x++)
		{
			for(int y=0;y<arr.length-x-1;y++)//-x是为了让每一次比较的元素减少，-1是为了避免角标越界
			{
				if(arr[y]>arr[y+1])//冒泡是相邻两个元素之间进行比比较
				{
					int temp=arr[y];
					arr[y]=arr[y+1];
					arr[y+1]=temp;
				}
			}
		}
		
	}
	public static void main(String[] args)
	{
		int[] arr={3,4,5,12,1,3};//此处要是没有“【】”会报错
		//在排序前打印
		print(arr);
		fun(arr);
		//在排序后打印
		print(arr);
	}
	
	public static void print(int[] arr)
	{
		System.out.print("[");
		for(int x=0;x<arr.length;x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}
	
}


控制台输出结果：
[3,4,5,12,1,3]
[1,3,3,4,5,12]

（3） 

package test;

public class test {
	public  static void fun(int[] arr)
	{
		for(int x=0;x<arr.length-1;x++)
		{
			for(int y=0;y<arr.length-x-1;y++)//-x是为了让每一次比较的元素减少，-1是为了避免角标越界
			{
				if(arr[y]>arr[y+1])//冒泡是相邻两个元素之间进行比比较
				{
					/*int temp=arr[y];
					arr[y]=arr[y+1];
					arr[y+1]=temp;*/
					swap(arr,y,y+1);
				}
			}
		}
		
	}
	   
	public static void swap(int[] arr,int a,int b)
	{
		int temp=arr[a];
		arr[a]=arr[b];
		arr[b]=temp;
	}
	public static void main(String[] args)
	{
		int[] arr={3,4,5,12,1,3};//此处要是没有“【】”会报错
		//在排序前打印
		print(arr);
		fun(arr);
		//在排序后打印
		print(arr);
	}
	
	public static void print(int[] arr)
	{
		System.out.print("[");
		for(int x=0;x<arr.length;x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}
	
}


控制台输出:
[3,4,5,12,1,3]
[1,3,3,4,5,12]

(数组的折半查找)：


package test;

public class test {
	public static void main(String [] args)
	{
		/*int[] arr={11,22,33,44,55,66,77,88,99,00};
		int index=fun(arr,99);
		System.out.println("index="+index);*/
		int[] arr={2,4,5,7,19,10};
		int index=fun(arr,19);
		System.out.println("index="+index);
	}
	//折半查找可以提高效率，但是必须要保证该数组是有序数组
	//min=0;
	//max=arr.length-1;
	//mid=(min+max)/2;
	
	public static int fun(int[] arr,int key)
	{
		int min,max,mid;
		min=0;
		max=arr.length-1;
		mid=(min+max)/2;
		while(arr[mid]!=key)
		{
			if(key>arr[mid])
				min=mid+1;	
			else if(key<arr[mid])
				max=mid-1;
			if(min>max)
				return -1;
			mid=(max+min)/2;
		}
		return mid;
	}
	
	//定义功能，获取key第一次出现在数组中的位置，如果返回是-1，那么代表该key在数组中不存在
	/*public static int fun(int [] arr,int key)
	{
		for(int x=0;x<arr.length;x++)
		{
			if(arr[x]==key)
			{
				return x;
			}
		}
		return -1;
	}*/
}


控制台输出结果：
index=4

package test;

public class test {
	public static void main(String [] args)
	{
		/*int[] arr={11,22,33,44,55,66,77,88,99,00};
		int index=fun(arr,99);
		System.out.println("index="+index);*/
		int[] arr={2,4,5,7,19,10};
		int index=fun(arr,19);
		System.out.println("index="+index);
	}
	//折半查找可以提高效率，但是必须要保证该数组是有序数组
	//min=0;
	//max=arr.length-1;
	//mid=(min+max)/2;
	//折半查找的第一种方式
	/*public static int fun(int[] arr,int key)
	{
		int min,max,mid;
		min=0;
		max=arr.length-1;
		mid=(min+max)/2;
		while(arr[mid]!=key)
		{
			if(key>arr[mid])
				min=mid+1;	
			else if(key<arr[mid])
				max=mid-1;
			if(min>max)
				return -1;
			mid=(max+min)/2;
		}
		return mid;
	}*/
	//折半的第二种方式
	public static int fun(int[] arr,int key)
	{
		int min=0,mid,max=arr.length-1;
		while(min<=max)
		{
			mid=(max+min)>>1;
		    if(key>arr[mid])
		    min=mid+1;
		    else if(key<arr[mid])
		    	max=mid-1;
		    else
		    	return mid;
		}
		return -1;
	}
	
}

控制台输出结果：
index=4

（折半查找的练习）：

package test;

public class test {
	public static void main(String [] args)
	{
		int[] arr={2,4,5,7,10,19,22,34};//比方说将20插进该数组中。找到插入的该数的位置
		int index=get_index(arr,20);
		System.out.println("index="+index);
	}
	//折半查找可以提高效率，但是必须要保证该数组是有序数组
	//min=0;
	//max=arr.length-1;
	//mid=(min+max)/2;
	//有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的
	public static int get_index(int[] arr,int key)
	{
		int min=0,mid,max=arr.length-1;
		while(min<=max)
		{
			mid=(max+min)>>1;
		    if(key>arr[mid])
		    min=mid+1;
		    else if(key<arr[mid])
		    	max=mid-1;
		    else
		    	return mid;
		}
		return min;//min就是8插入的数组的下标
	}
}


控制台输出结果：
index=6



Lila_老妖
关注
专栏目录
详解Java静态数组
qf2019的博客
08-10 1529
说到Java静态数组，我们第一时间可能就会想到相应的动态数组，两者看上去挺相似，实质却大不一样。Java静态数组是一定义出来就创建了，而动态数组则是定义时不创建，使用时才创建，一定意义上节省了内存空间。本文我们主要来讲一讲相对比较简单的Java静态数组。 实际上我们之前学习的大部分数组都是静态数组，然而在很多的时候，静态数组根本不能满足我们编程的实际需要，比方说我需要在程序运行过程中动态的向数组中添加数据，这时我们的静态数组大小是固定的，显然就不能添加数据，要动态添加数据必须要用到动态数组，动态数组中的各个
Java基础-----数组和数据存储
qq_48788523的博客
12-03 613
关于数组,你知道吗?
JAVA中静态数组与动态数组
chenxiaoxu069074004的专栏
05-06 437
前面我们学习的数组都是静态数组，其实在很多的时候，静态数组根本不能满足我们编程的实际需要，比方说我需要在程序运行过程中动态的向数组中添加数据，这时我们的静态数组大小是固定的，显然就不能添加数据，要动态添加数据必须要用到动态数组，动态数组中的各个元素类型也是一致的，不过这种类型已经是用一个非常大的类型来揽括—Object类型。Object类是JAVA.LANG包中的顶层超类。所有的类型都可以与Obj
详解java静态数组
TylerGuoj的博客
08-13 4371
数组是一种线性表 顾名思义，数组就是数据组合在一起，是一个存储数据容器。其一般定义： 数组是具有相同数据类型元素的有序集合。 从定义可知 所有元素必须是相同数据类型。 那么可以推导数组也是一种数据类型，且它的类型由其元素的数据类型决定。其中，数据类型刻画操作对象的特性，是一个值的集合和该值集上的一组操作的总称，即 数据类型 = 值域 + 操作。 数组中元素是有序的。 有序指数据元素之间的关系，即除首尾元素，其他元素都有且只有一个前驱元素、后继元素。 ​元素有序说明数组是一种线性表，在逻辑内存上，数组不管
java-- 静态数组
最新发布
weixin_61500949的博客
10-27 416
遍历：就是一个一个数据的访问。
Java 静态初始化顺序
snow365的专栏
08-06 1067
原帖：http://topic.csdn.net/u/20081031/20/6a66d680-fd4e-4ffd-808e-34cea79eb7d6.htmlpackage NewPractice;public class Test1 {    public static int k = 0;    public static Test1 t1 = new Test1("
Java基础07--数组
Yu__peng的博客
04-11 335
Java基础07--喝自己之前偷懒的洗脚水（七）数组数组的概述一维数组二维数组的使用数组的常见算法Arrays工具类的使用数组的常见异常 数组 数组的概述 1. 数组的理解： 数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。 2.数组的常见概念： 数组名 元素 角标、下标、索引 数组的长度：元素的个数 3.数组的特点： 1）有序排列 2）数组属于引用类型数据变量，数组的元素，既可以是基本数据类型，也可以是引用数组类型 3）创建数组对象
21天学会Java之(Java SE第八篇):数组、冒泡排序法、二分法查找
热门推荐
小志Coding笔记
05-07 1万+
数组 数组的定义 数组是相同类型数据的有序集合，数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。数组的三个基本特点： 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。 其元素必须是相同类型，不允许出现混合类型。 数组类型可以是任何数据类型，包括基本类型和引用类型。 注意事项： 数组变量属引用类...
【Java开发】数组的详解
我的主页
03-09 1168
本期讲解:数据的创建与初始化、数组的类型、JVM内存分布、数组的应用场景、数组练习题(顺序查找、二分查找、冒泡排序、数组转字符串、数组复制)。
java 二维数组排序算法二分法
qq_43382750的博客
06-29 361
Java传递 传值:传基本数据类型 传引用:引用类型的传递,传地址 //值传递,原数据不受影响(栈内存中两个方法同时运行互不影响) //传引用,原数据跟着改变(传的是栈内存中的地址,通过地址改变堆内存中的数据后也就是改的原数据) 如下图左边是栈内存右边是堆内存 public static void main(String[] args) { int i = 10; m1(i); System.out.pri...
java数组是静态的
fdsafdsafdsafdsafa
11-11 209
java数组是静态的，而javaScript的数组是动态的。 当数组被初始化后，该数组的长度就不可变了。java程序中的数组必须经过初始化才可以使用。所谓初始化，就是为数组对象的元素分配内存空间，并为每个数组元素指定初始值。   String[] str ;//声明一个字符串数组，未分配内存 System.out.println(str); //此时IDE会报错：the local va...
java入门之 静态数组
Y_999777的博客
10-17 2832
java入门之 静态数组
java入门，静态数组
m0_73374675的博客
11-01 631
主要讲述静态数组，声明和创建以及数组的遍历循环
java 静态数组 动态数组_Java – 静态和动态数组初始化
weixin_42118056的博客
02-25 580
是否真的在运行时初始化的每个数组都是动态的在编译期间初始化的每个数组都是静态的？例如：int array[];public main() {array = new int[100];}编译器知道数组有多少元素,因此它可以在编译期间启动它？或者我需要给每个int一个值,使它变为静态？像这样：int array[3] { 1, 2, 3};并且可以定义一个数组在main()函数之外应该有多少个元素？ ...
java 静态初始化执行顺序
大树叶 技术专栏
07-06 596
1)String类能否被继承？　 　　Sting是这样定义的：public final class String extends Object，里边有final关键字，所以不能被继承。 2)关于静态初始化的考题 在初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。 　　在类被加载进来后，在链接的准备阶段，JVM会为该类所有的类变量（static　变量）
java静态数组和对象内存分配
iuciuc的博客
07-04 592
Java 中定义数组（静态数组）的语法有两种： type arrayName[]; type[] arrayName; 同C或C++不同，java在定义数组时不分配空间，所以不必指出数组大小，在new时才会分配空间，必须指明数组大小。 数组有一个length属性，通过数组名.length调用。arrayName=new type[arraySize];在定义对象时同理例如：
java的数组静态初始化
m0_63436028的博客
04-10 893
int[] arr = new int[3]; /* [],说明这是个数组 int[] a int a[]都是表示一个数组 arr数组名称 new为数组申请内存空间 */ int[] arr1 ={1,2,3}; //静态初始化 索引范围[0,3] //获取长度 int b=arr1.length; ...
黑马程序员-Java数组声明、创建、初始化、及排序
success_51的专栏
08-08 317
黑马程序员-Java数组声明、创建、初始化、及排序简单总结 ------- android培训、java培训、期待与您交流！ ---------- 一维数组的声明方式： type var[]; 或type[] var; 声明数组时不能指定其长度（数组中元素的个数）， Java中使用关键字new创建数组对象，格式为： 数组名 = new 数组元素的类型 [数组元素的个数] 实
Java静态数组和动态数组的定义方式
私欲日生，如地上尘，一日不扫，便又有一层。着实用功，便见道无终穷，愈探愈深，必使精白无一毫不彻方可。
04-21 2216
数组的定义方式 静态： //简化语法常用 定义和初始化同步完成 int [] a = {5,2,6,4,10}; 动态： //数组的定义和初始化同时完成，使用动态初始化语法 int[] prices = new int[5]; 补充： //初始化数组时元素的类型是定义数组时元素类型的子类 Object[] books = new String[4]; ...
Java数组上机实验：排序与折半查找
这里涉及了折半查找（也称二分查找），这是一种在已排序数组中查找特定元素的高效算法。折半查找的基本思想是将数组分为两半，然后根据目标值与中间元素的比较结果缩小查找范围，直到找到目标值或确定不存在。实验中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值