数组 获取最值（最大值 最小值）选择排序 冒泡排序 快速排序 半查找（二分查找） 十进制转其他进制法

最新推荐文章于 2022-12-29 22:41:06 发布
最新推荐文章于 2022-12-29 22:41:06 发布
阅读量1.9k 收藏 4
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010209842/article/details/39521791
版权

数组

 

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

int [] arr = new int [4];

//需要一个容器，但是不明确容器的具体数据。

int [] arr = new int [] {3,1,4,5,}

//需要一个容器，存储已知的具体数据。

int [] arr = {12,4,4,3,3}

 

对数组操作最基本的动作就是存和取。

核心思想：就是对角标的操作。

 

length 长度判断

arr.length   arr数组的长度 

 

数组的遍历

 

class ArrayDemo2
{
	public static void main (String [] args)
	{
		int [] arr = {13,4,1,4,1};
			for (int x=0;x<arr.length ; x++)
			{
		    	System.out.println("arr["+x+"]="+arr[x]);
			}
	}
}

 

 

获取最值（最大值 最小值）

 

/*
	获取数组中的最大值。
	思路：
	1，需要进行比较。并定义变量记录住每次比较后较大的值。
	2，对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
		如果遍历到的元素大于变量中记录的元素，就用变量记录住该大的值。 
	3，遍历结果，该变量记录就是最大值。

	定义一个功能来是实现。
	明确一，结果。
			是数组中的元素。int .
	明确二，未知内容。
			数组.
*/
class ArrayDemo2
{
	public static void main (String [] args)
	{
		int [] arr = {12,3213,4,5,64,667,6};
		int max = getMax (arr);
			System.out.println("max="+max);
	}
	public static int getMax (int [] arr)
	{
		int max =arr[0];
		for (int x=1;x<arr.length ;x++ )
		{
			if(arr[x]>max)
				max = arr[x];
		}
		return max;
	}
}

 

通过脚标求最大值

 

class ArrayDemo2
{
	public static void main (String [] args)
	{
		int [] arr = {12,3213,4,5,64,667,6};
		int max = getMax (arr);
			System.out.println("max="+max);
	}
	public static int getMax (int [] arr)
	{
		int maxIndex =0;
		for (int x=1;x<arr.length ;x++ )
		{
			if(arr[x]>arr[maxIndex])
				maxIndex = x;
		}
		return arr[maxIndex];
	}
}


排序（选择排序 冒泡排序 高效）

Arrays.sort(arr) 

选择排序 

 

//排序法 选择
public class Test1 {

	public static void main(String[] args) {

		int[] arr = { 3, 4, 1, 23, 4, 11, 42, 5, };
		arrSort(arr);
	}

	public static void arrSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = x + 1; y < arr.length - 1; y++) {
				if (arr[x] > arr[y])
					swap(arr, x, y);
			}
			System.out.print(arr[x] + " ");
		}
		System.out.println();
	}

	public static void swap(int[] arr, int x, int y) {
		int temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
}

 

冒泡排序

 

//排序法 冒泡
public class Test1 {

	public static void main(String[] args) {

		int[] arr = { 3, 4, 1, 23, 4, 11, 42, 5, };
		arrPoob(arr);
	}

	public static void arrPoob(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = 0; y < arr.length - 1 - x; y++) {
				if (arr[y] > arr[y + 1])
					swap(arr, y, y + 1);
			}
			System.out.print(arr[arr.length - 1 - x] + " ");
		}
		System.out.println();
	}

	public static void swap(int[] arr, int x, int y) {
		int temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
}

高效方法

 

 

//排序法 高效
public class Test1 {

	public static void main(String[] args) {

		int[] arr = { 3, 4, 1, 23, 4, 11, 42, 5, };
		arrhh(arr);
	}

	public static void arrhh(int[] arr) {
		int index = 0;
		for (int x = 0; x < arr.length - 1; x++) {
			index = 0;
			for (int y = 0; y < arr.length - x; y++) {
				if (arr[index] < arr[y])
					index = y;
			}
			swap(arr, index, arr.length - 1 - x);
		}
		for (int z = 0; z < arr.length; z++) {
			System.out.print(arr[z] + " ");
		}
	}

	public static void swap(int[] arr, int x, int y) {
		int temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
}

 

折半查找 （二分查找）

查找法

 

//二分筛选法
//强调，一定是有序数列
//1，判断while(min <max)，返回min；
//2，判断while(arr[mid]!=key)，返回mid；
public class Test1 {

	public static void main(String[] args) {
		int[] arr = { 1, 3, 5, 6, 8, 9 };
		System.out.println(halfSearch(arr, 4));
		int[] arr2 = { 11, 13, 15, 16, 18, 19 };
		System.out.println(halfSearch2(arr2, 14));
	}

	public static int halfSearch(int[] arr, int key) {
		int max = arr.length - 1;
		int min = 0;
		int mid = (min + max) / 2;
		while (min < max) {
			if (key > arr[mid])
				min = mid + 1;
			else if (key < arr[mid])
				max = mid - 1;
			else
				return mid;
			mid = (min + max) / 2;
		}
		return min;
	}

	public static int halfSearch2(int[] arr, int key) {
		int min, mid, max;
		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 (max < min)
				return min;
			mid = (min + max) / 2;
		}
		return mid;
	}
}

例题

 

 
/*
面试题：
给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，
那么个元素的存储的角标为如何获取。
{13,15,19,28,33,45,78,106};
*/
class Zz
{
	public static void main (String [] args)
	{
		int []arr ={13,15,19,28,33,45,78,106};
		int Index = halfSearch(arr,50);
		System.out.println(Index);
	}	
	public static int halfSearch(int []arr,int key)
	{
		int max,min,mid;
		min = 0;
		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;
	}
}

int index1 = Arrays.binarySearch(arr,5);

如果存在返回的具体的角标位置

不存在返回的是  （-插入点-1)

class ArrayTest4 
{
	public static void main(String[] args) 
	{
		String week = getWeek(71);
		System.out.println(week);
	}
	/*
	使用查表法。
	星期。
	String s = "abc";
	int x = 4;
	*/
	public static String getWeek(int num)
	{

		if(num>7 || num<1)
		{
			return "错误的星期";
		}
		String[] weeks = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};

		return weeks[num];
	}

}

十进制 转换为 二进制 和 十六进制

 

十进制 转换为 二进制

 

//十进制转二进制
//数组方法，和查表法。
public class Test1 {
	public static void main(String[] args) {
		int x = -60;
		toBin(x);
		System.out.println();
		toBinSearch(x);
	}

	public static void toBin(int x) {
		int[] arr = new int[32];
		int index = 0;
		while (x != 0) {
			arr[index++] = (x & 1);
			x = x >>> 1;
		}
		for (int z = index - 1; z >= 0; z--) {
			System.out.print(arr[z]);
		}
	}

	public static void toBinSearch(int x) {
		char[] chs = { '0', '1' };
		char[] arr = new char[32];
		int index = 0;
		while (x != 0) {
			arr[index++] = chs[(x & 1)];
			x = x >>> 1;
		}
		for (int z = index - 1; z >= 0; z--) {
			System.out.print(arr[z]);
		}
	}

 

十进制 转换为 十六进制

//十进制转十六进制
//数组方法，和查表法。
public class Test1 {
	public static void main(String[] args) {
		int x = -60;
		toHex(x);
		System.out.println();
		toHexSearch(x);
	}

	public static void toHex(int x) {
		char[] arr = new char[8];
		int index = 0;
		while (x != 0) {
			if ((x & 15) > 10)
				arr[index++] = (char) ((x & 15) - 10 + 'A');
			else
				arr[index++] = (char) ((x & 15) + '0');
			x = x >>> 4;
		}
		for (int z = index - 1; z >= 0; z--) {
			System.out.print(arr[z]);
		}
	}

	public static void toHexSearch(int x) {
		char[] chs = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
				'B', 'C', 'D', 'E', 'F' };
		char[] arr = new char[8];
		int index = 0;
		while (x != 0) {
			arr[index++] = chs[(x & 15)];
			x = x >>> 4;
		}
		for (int z = index - 1; z >= 0; z--) {
			System.out.print(arr[z]);
		}
	}
}

十进制转其他进制 合并法

 

//十进制转其他进制合并法
public class Test1 {
	public static void main(String[] args) {
		int x =0;
		toBin(x);
		System.out.println();
		toBa(x);
		System.out.println();
		toHex(x);
	}
	public static void toBin(int x){
		train(x,1,1);
	}
	public static void toBa(int x){
		train(x,7,3);
	}
	public static void toHex(int x){
		train(x,15,4);
	}
	public static void train(int x,int n,int m){
		if(x==0)
		{
			System.out.print(0);
			return;
		}
		char[] chs = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
				'B', 'C', 'D', 'E', 'F' };
		char[] arr = new char[32];
		int index =0;
		while(x!=0){
			arr[index++] = chs[x&n];
			x=x>>>m;
		}
		for(int z = index-1;z>=0;z--){
			System.out.print(arr[z]+" ");
		}
	}
}

 

二维数组

int [][] arr = new arr[3][2]；

int [][] arr= { { ，，}{，，}{，，，} }；

分别对二维数组中的每一个小数组进行初始化。

arr[0]=new int[2];

arr[1]=new int[1];

arr[2]=new int[3];

 

int[] arr = new int[3];  
System.out.println(arr);//[I@1fb8ee3  @左边是实体的类型。 @右边是实体的哈希值。

int[][] arr = new int[3][2];//创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有2个元素。
System.out.println(arr);//直接打印二维数组。   [[I@c17164
System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。 [I@1fb8ee3
System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。 0

int[][] arr = new int[3][];
System.out.println(arr);//直接打印二维数组。   [[I@c17164
System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。null
System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。 NullPointerException

int[][] arr = new int[3][2];
System.out.println(arr.length);//打印二维数组的长度。其实就是一维数组的个数。
System.out.println(arr[1].length);//打印二维数组中角标为1一维数组的长度。

 

 

逍遥单机君
关注
数组获取最值(获取数组中的最大值最小值)
星·沉的博客
12-04 669
public class 最值 { public static void main(String[] args) { // TODO Auto-generated method stub int [] a = {3,5,9,4}; int max = 0; for (int f = 0; f<a.length;f++) { if (a[f]>max) { max=a[f]; } } System.out.prin
冒泡法求最大值.C
06-07
搜集的一种简单的排序方法，部分代码：#include <stdio.h> #define N 10 void input(int arr[], int n); /*函数声明*/ void sort(int *ptr, int n); void output(int arr[], int n); void main() { int a[N], *p; input(a,N); p=a; sort(p,N); output(p,N); }
冒泡查找数组里最大的值
qq_40246956的博客
06-04 579
void plus(){ int arr[10]={4,2,8,11,3,6,9,33,23,15}; int lenth=sizeof(arr)/sizeof(arr[0]); int temp; for (int j=0;j&lt;lenth-1;j++) { if (arr[j]&gt;arr[j+1]) { temp=arr[j]; arr[j+1]=arr[j]...
C++产生随机数，并用冒泡对其排序求最大值
cygreat的博客
12-29 3614
写这个程序的主要原因是，课程作业需要用LabVIEW写类似的一个功能，我就试着用C++写一下试试，其实原理很简单，就是用rand（）函数产生随机数存入到数组当中去，然后对数组中的 数用冒泡算法进行排序就可以了。 先介绍一下rand（）这个函数的用法，这个函数可以用来产生随机数，但不是真正意义上的随机数，它是一个伪随机数，它是根据一个数，也可以称它为种子，作为一个基准，然后以某个递推公式推算出
选择排序之每次挑出最大值和最小值
hello_IT_的博客
09-19 1525
public class Version2 { public static void main(String[] args) { //准备数据 int[] arr = newArr(15); int[] arr1 = Arrays.copyOf(arr, arr.length); System.out.println("原素...
冒泡排序得出最大值的算法
10-28
冒泡排序算出最大值的算法，给新手朋友们参考一下！~
快速排序找数列最大值-Java
qq_43822715的博客
04-11 614
import java.util.Scanner; public class Main { private static void quicksort(int[] array,int low,int high){ int left = low; int right = high; int temp = array[low]; //基准...
Java基础-用选择排序法找出随机数组中的最小值
woOzie_的博客
02-25 224
public class HelloWorld{ public static void main(String[] args){ int[] a = new int[5]; a[0] = (int) (Math.random() * 100); a[1] = (int) (Math.random() * 100); a[2] = (int) (Math.random() * 100); a[3] = (int) (Math.random() * 10
关于选择排序的优化——同时找出最小值与最大值
m0_52433479的博客
01-16 921
关于选择排序的优化——同时找出最小值与最大值 近期在学习排序算法，第一种方法就是选择排序。首先选择排序是一种不稳定的算法，其思想是通过遍历数组，找出最小值（最大值）的位置，放到已排序序列的启示（末尾）位置。 根据选择排序的基本思想，我们可以对算法进行优化，在一次遍历中，找到最小值与最大值，再进行交换，这样就可以节省一半的时间。 经典选择排序算法代码 public void Sort(){ int[] arr = {38,24,123,57,67,21,87,54,34,12,36,2,42}; arr
a，b求最大值
weixin_34234721的博客
10-12 361
方案一：int max=((a+b)+abs(a-b))/2; mix(a,b)+abs(a-b)=max(a,b); max(a,b)=(mix(a,b)+max(a,b)+abs(a-b))/2; 由于a和b谁小不知道，所以这样加一下，就是2max(a,b)了 方案二： int c=a-b; char *strs[2]={"a大","b大"}; c=unsigned(c)>...
TIA博途中如何使用MAX和MIN数学函数求取几个变量的最大值和最小值？.docx
02-10
TIA博途中如何使用MAX和MIN数学函数求取几个变量的最大值和最小值？
快速排序算法的拓展和应用（寻找前k个最小值，寻找数组中数量超过一半的值）
yg838457845的博客
08-21 554
# include &lt;iostream&gt; # include &lt;vector&gt; using namespace std; //快速排序算法 int Partition(vector&lt;int&gt;* a, int begin, int end){ int i = begin; int j = end; int key = (*a)[beg...
寻找数组中的最大值和最小值
xuguoli_beyondboy的专栏
08-21 1955
编程之美有一道是关于寻找数组中的最大值和最小值的题目，该作者提供了四种思路解法： 第一种思路： 直接暴力遍历寻找数组中的最大值和最小值，该算法比较次数为2*N次。 第二种思路： 首先按顺序将数组中相邻的两个数分在同一组，例如数组为{5,6,8,3,7,9},按其思路分组，其结果如图所示： 接着比较同一组中奇数位数字和偶数位数字，将较大的数放在偶位数上，较小的数放在奇数位上，经过N/2次
求出数组中的最大值和最小值
一个学习的博客
07-30 418
public class Array7 { public static void main(String[] args) { int[] arrayA={2, 23,56 ,24, 57,5,6}; //先默认第一个元素最大 int max=arrayA[0]; for (int i = 1; i < arrayA.length; i++) { if (arrayA[i]>max){ //这里将每.
c语言从给定数组中找出最大值,求给定数组的最大值与次大值
weixin_36450655的博客
05-21 1118
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#defineN20intmain(){inta[N];inti;intcompare=0,add=0;intmax,smax;for(i=0;i//max=smax=-1;//mustbesmallerthananyofa[i]++compare;add+=2;if(a[0]...
数组最大值和最小值的求法
Pasby的博客
03-29 2189
作为一名学生，这都是我平时在学习中遇到的一些问题，不清楚不明白的地方，总结给大家的，希望能够帮助到大家 题目：给出10个整数（9,8，27,7，10,98,67,87,4，88），求出最大值和最小值 //写一个main方法 public static void main(String[] args) { //先创建一个数组，将整数写到数组中 int arr [] = new int [] {...
快速排序
niukeming的博客
06-03 1070
快速排序： 一、快速排序的简介 快速排序是一种总体上来讲时间复杂度较低的排序，其主要利用了分冶的思想；在排序一大段数据时，每次通过选取key值， 然后利用不同的方法将该段数据分为两段（小于等于key的一段在一边，大于key的一段在一边，key的数据在这两段的中间）； 然后通过递归的方法分别对上述的左右两段数据采用同样的思想分段；快速排序每一趟下来，位于两段中间的key值就会被置 于最...
数组最大值/最小值计算方法
sunqy1995的博客
06-11 1929
遍历数组比较大小 将第一个值认为是最大值或者最小值，经过每一次的循环进行判断赋值，比当前大或者小时进行替换，依次这样，到最后获得的就是最大值/最小值。 let arr = [1,5,3,2,7,4]; let max = arr[0], min = arr[0]; for (let i = 1; i < arr.length-1; i ++) { if (max < arr...
数组作业（2022.12.29）
最新发布
m0_68542867的博客
12-29 242
12.29
Java排序与查找详解：冒泡排序、快速排序及二分查找算法图解
本资源详细介绍了Java中的三种重要排序算法——冒泡排序、快速排序和二分查找，以及它们的工作原理、优化策略和关键代码实现。 **快速排序**： 快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排记录...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值