数组中涉及的常见算法

最新推荐文章于 2022-12-31 13:00:13 发布
最新推荐文章于 2022-12-31 13:00:13 发布
阅读量306 收藏 3
点赞数
分类专栏： Java 算法 文章标签： Java 数组算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39794062/article/details/114653818
版权
Java 同时被 2 个专栏收录
112 篇文章 0 订阅
订阅专栏
算法
6 篇文章 1 订阅
订阅专栏

一、数组元素的赋值

杨辉三角

package com.test.Test;

public class YangHuiTest {
	public static void main(String[] args) {
		int[][] yangHui = new int[10][];

		for (int i = 0; i < yangHui.length; i++) {
			yangHui[i] = new int[i + 1];
			
			//每行的首末元素赋值为1
			yangHui[i][0] = 1;
			yangHui[i][i] = 1;
			
			//从第二行开始，每个非首末元素是上一行同列元素与上一行左侧一列元素之和
			if (i > 1) {
				for (int j = 1; j < yangHui[i].length - 1; j++) {
					yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
				}
			}
		}
		
		//双重循环遍历输出
		for (int i = 0; i < yangHui.length; i++) {
			for (int j = 0; j < yangHui[i].length; j++) {
				System.out.print(yangHui[i][j] + " ");
			}
			System.out.println();
		}
	}
}

输出结果：
在这里插入图片描述

回形数格式方阵的实现

从键盘输入一个整数（1~20）
则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2
4 3
输入数字3，则程序输出： 1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1    2   3   4
12 13 14  5
11 16 15  6
10  9   8   7

//方法一
class RectangleTest {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个数字");
		int len = scanner.nextInt();
		int[][] arr = new int[len][len];

		int s = len * len;
		/*
		 * k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
		 */
		int k = 1;
		int i = 0, j = 0;
		for (int m = 1; m <= s; m++) {				//一共要填写s = len*len个数据
			if (k == 1) {							//首先往右走
				if (j < len && arr[i][j] == 0) {	//在一行中向右走还没有走到头并且该位置还没有赋过值
					arr[i][j++] = m;				//赋值，j++再往右走一步
				} else {							
					k = 2;							//如果走到一行的最右边，k=2转向下走
					i++;							//向下走行数加一
					j--;							//因为执行了j++，所以要回退一下
					m--;							//因为j++的缘故，m在for循环又加了1，所以也要回退，再次进入下一次的for循环
				}
			} else if (k == 2) {
				if (i < len && arr[i][j] == 0) {
					arr[i++][j] = m;
				} else {
					k = 3;
					i--;							//向下走到底，回退一步
					j--;							//该往左走
					m--;
				}
			} else if (k == 3) {
				if (j >= 0 && arr[i][j] == 0) {
					arr[i][j--] = m;
				} else {
					k = 4;
					i--;							//向左走到头，该往上走
					j++;							//向左走到头，该向右回退一步
					m--;
				}
			} else if (k == 4) {
				if (i >= 0 && arr[i][j] == 0) {
					arr[i--][j] = m;
				} else {
					k = 1;
					i++;							//向上走到头，该向下回退一步
					j++;							//向上走到头，该往右走
					m--;
				}
			}
		}

		// 遍历
		for (int m = 0; m < arr.length; m++) {
			for (int n = 0; n < arr[m].length; n++) {
				System.out.print(arr[m][n] + "\t");
			}
			System.out.println();
		}
	}
}

//方法二
class RectangleTest1 {

	public static void main(String[] args) {
		int n = 7;
		int[][] arr = new int[n][n];

		int count = 0; // 要显示的数据
		int maxX = n - 1; // x轴的最大下标
		int maxY = n - 1; // Y轴的最大下标
		int minX = 0; // x轴的最小下标
		int minY = 0; // Y轴的最小下标
		while (minX <= maxX) {						//相当于一个“回”字，四个for循环一圈一圈的赋值
			for (int x = minX; x <= maxX; x++) {
				arr[minY][x] = ++count;
			}
			minY++;
			for (int y = minY; y <= maxY; y++) {
				arr[y][maxX] = ++count;
			}
			maxX--;
			for (int x = maxX; x >= minX; x--) {
				arr[maxY][x] = ++count;
			}
			maxY--;
			for (int y = maxY; y >= minY; y--) {
				arr[y][minX] = ++count;
			}
			minX++;
		}

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				String space = (arr[i][j] + "").length() == 1 ? "0" : "";
				System.out.print(space + arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}

二、数值型数组

定义一个int类型的一维数组，包含10个随机值元素，要求所有的随机数都是两位数。

public class Test4 {
	public static void main(String[] args) {
		/*
		 * Math.random()				:[0.0,1)
		 * Math.random() * 90			:[0.0,90.0)
		 * (int)(Math.random() * 90)	:[0,89]
		 * (int)(Math.random() * 90+10)	:[10,99]
		 * 
		 * 公式：获取[a,b]范围的随机数：(int)(Math.random() * (b-1+1) + a) 	
		 * */
		int[] arr = new int[10];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);	
		}
	}
}

求最大值

		int max = 0;
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] > arr[max]) {
				max = i;
			}
		}
		System.out.println("最大值：" + arr[max]);

求最小值

		int min = 0;
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] < arr[max]) {
				max = i;
			}
		}
		System.out.println("最小值：" + arr[max]);

求平均数

		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		System.out.println("平均值：" + sum/10);

求总和

		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		System.out.println("总和：" + sum);

三、数组的复制、反转、查找

复制

	public static void main(String[] args) {
		int[] arr1, arr2;
		
		arr1 = new int[]{1,2,3,4};
		
		arr2 = new int[arr1.length];
		for (int i = 0; i < arr2.length; i++) {
			arr2[i] = arr1[i];
		}
		
	}

反转

		for (int i = 0; i < arr2.length/2; i++) {
			int temp = arr2[i];
			arr2[i] = arr2[arr2.length - 1 -i];
			arr2[arr2.length -1 -i] = temp;
		}

线性查找

		boolean isFlag = true;
		
		for (int i = 0; i < arr2.length; i++) {
			if (arr2[i] == 3) {
				System.out.println("查找到元素3");
				isFlag = false;
				break;
			}
		}
		if (isFlag) {
			System.out.println("未找到元素！");
		}

二分查找

		//二分查找必须是有序数组
		int[] array = new int[]{-22,3,4,7,33,56};
		boolean Flag = true;
		int findEle = 7;
		int left = 0;
		int right = array.length - 1;
		while(left <= right){
			int middle = (left + right) / 2;
			if (array[middle] == findEle) {
				System.out.println("找到元素：" + findEle);
				Flag = false;
				break;
			}else if (array[middle] > findEle) {
				right = middle - 1;
			}else {
				left = middle + 1;
			}
		}
		if (Flag) {
			System.out.println("未找到元素！");
		}

四、数组元素的排序算法

冒泡排序

public class BubbleSortTest {
	public static void main(String[] args) {
		int[] array = new int[]{22,-4,555,-44,23,57,1,5,66};
		System.out.println("原始数组：");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
		
		//冒泡排序
		for (int i = 0; i < array.length - 1; i++) {			//最后一个元素没必要排序，属所以length-1
			for (int j = 0; j < array.length - 1 - i; j++) {	//已经排序好的无需再比较，所以length-1-i
				if (array[j] > array[j+1]) {
					int temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		
		System.out.println("\n冒泡排序：");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
	}
}

输出结果：
在这里插入图片描述

快速排序

public class QuickSortTest {
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("快速排序之后：" + java.util.Arrays.toString(data));
	}

	private static void quickSort(int[] data) {
		subSort(data,0,data.length-1);			//分而治之
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {		//start、end记录数组开头和结尾
			int base = data[start];		//以第一个元素为参照
			int left = start;			//left指向第一个元素
			int right = end + 1;		//right指向末尾元素的后一个位置
			while(true){
				while(left < end && data[++left] <= base)		//从第二个元素开始与base比较，从左往右找比base大的值，然后left记录该值位置
					;
				while(right > start && data[--right] >= base)	//从最后一个元素开始与base比较，从右往左找比base小的元素，然后right记录该值位置
					;	
				if (left < right) {
					swap(data, left, right);
				}else {
					break;
				}
			}
			swap(data, start, right);							//交换base的值，放在中间合适位置
			
			subSort(data, start, right-1);						//一分为二的左部分数组递归调用快速排序
			subSort(data, right+1, end);						//一分为二的右部分数组递归调用快速排序
		}
		
	}

	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
		
	}
}

五、Arrays工具类的使用

java.util.Arrays是操作数组的工具类，定义了很多操作数组的方法。

public class ArraysTest {
	public static void main(String[] args) {
		//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}
	}
}
煎丶包
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组中的常见算法之回形数
weixin_50522909的博客
09-13 1947
数组中的常见算法之回形数 如下面这种数组形态我们成为回形数，即回旋排序，n行n列，中间的数即为n*n，例如n=7，那么最中间的数为49，下面是用Java数组来表示的代码： 01 02 03 04 05 06 07 24 25 26 27 28 29 08 23 40 41 42 43 30 09 22 39 48 49 44 31 10 21 38 47 46 45 32 11 20 37 36 35 34 33 12 19 18 17 16 15 14 13 public c
数组常见排序算法
Ringo19的博客
02-19 73
冒泡排序
数组、链表、堆栈和队列、线性表和顺序表 数组和链表.pdf
04-18
数组、链表、堆栈和队列、线性表和顺序表 数组和链表.pdf
数组常见算法汇总
MrDAW的博客
07-22 1539
数组常见算法汇总 1、寻找数组中的最大值 | 最小值 ` public class max_min { public static void main(String[] args) { int[] nums = {10,20,30,40,33,22,11,8}; //1.创建一个变量，用于存储遍历数组发现的最大值 int n = nums[0]; for (int i = 1; i < nums.length; i++) {
数组的常见算法
weixin_62914558的博客
07-28 765
数组的创建与元素的赋值；数组的赋值与复制；数组的反转；数组中指定元素的查找：搜索、检索；数组的排序算法（冒泡算法）
算法合集 —— 数组篇
weixin_59913110的博客
12-31 1058
本篇是对处理数组时常用的算法进行的总结。
【数据结构-数组】数组的相关算法
Mount256的博客
10-30 512
【数据结构-数组】数组的相关算法
数组的五大简单算法
qq_56870066的博客
09-19 360
数组几大算法1.倒置算法2.查找算法2.1.顺序查找2.2.折半查找3.插入算法4. 删除算法5. 排序算法5.1. 冒泡排序5.2. 插入排序5.3. 选择排序5.4. 快速排序 1.倒置算法 //数组倒置 # include <stdio.h> int main(void) { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int arr2[10] = { 0 };//用来存放倒置之后的内容 int i, j; for (i = 0, j = 9;
JavaScript数组排序的六种常见算法总结
10-14
在JavaScript编程中，数组排序是一项常见的操作，本文将详细介绍六种常见的排序算法，它们分别是希尔排序、sort排序、桶排序、冒泡排序，以及另外两种未在内容中具体提及的排序算法：快速排序和选择排序。这些算法在...
Python3实现从排序数组中删除重复项算法分析
09-19
在Python3中，从排序数组中删除重复项的算法是一个常见的问题，特别是在处理数据清洗或优化数据存储时。这个问题要求我们保持数组的排序顺序，并在原地修改数组，即不使用额外的空间。以下是对三种不同解决方案的...
JavaScript常用数组算法小结
10-22
JavaScript中的数组算法是编程中常见的问题，特别是在处理数据集合时。本文将重点介绍两种常见的数组操作：数组去重和数组顺序扰乱。 一、数组去重 数组去重是指从一个包含重复元素的数组中，创建一个新的数组，...
第03章 方法与数组 06 二维数组与最大最小值算法
09-13
在二维数组中找到最大值和最小值是常见的问题，这通常涉及到遍历整个数组。以下是一个简单的示例，展示了如何找到二维数组中的最大值： ```java int max = array[0][0]; for (int i = 0; i ; i++) { for (int j = ...
数组中求第K大数的实现方法
09-05
在编程和算法设计中，"数组中求第K大数"是一个常见的问题，它涉及到高效地从一组数据中找出第K个最大值。本问题的解决方案通常基于分治策略，如快速选择算法，这是一种简化版的快速排序算法，用于解决特定情况下的...
对数组进行冒泡排序，并理解“arr”、&arr[0]、*arr
weixin_56916549的博客
07-31 1453
对数组进行冒泡排序，理解“arr”、&arr[0]、*arr，数组作参数到底传递的是啥，数组名和数组首元素的关系
数组常用的函数
m0_74331185的博客
10-18 2421
数组常用函数js
Java实现归并排序-有图有真相
热门推荐
qq_36442947的博客
08-12 5万+
归并排序 1、原理 归并排序是一种概念上最简单的排序算法，与快速排序一样，归并排序也是基于分治法的。归并排序将待排序的元素序列分成两个长度相等的子序列，为每一个子序列排序，然后再将他们合并成一个子序列。合并两个子序列的过程也就是两路归并。 2、复杂度 归并排序是一种稳定的排序算法，归并排序的主要问题在于它需要一个与待排序数组一样大的辅助数组空间。由于归并排序每次划分时两个子序列的长度基本一...
数组中涉及到的常见算法
xiaotai1234的博客
08-09 1125
数组中涉及到的常见算法 1.数组元素的赋值(杨辉三角、回形数等) 面试题目：创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同 class ArrayExer { public static void main(String[] args) { //方式一： // int[] arr = new int[6]; // for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31) // arr[i] = (in
高温热流热线式风量变送器毕业设计.docx
最新发布
07-06
本设计针对目前垃圾焚烧场、焚化炉中高温气体的流速监测中存在的问题而提出。热流热线式风速传感器是利用放置在流场中具有加热电流的热线式敏感元件的热量转移与空气的流速之间的对应关系求得空气流动速度。传感器采用恒温差控制电路模块，使金属丝的温度差保持不变，消除了由于环境温度的变化对测量精度的影响，扩大了应用范围。流体参数可谓工业过程、科学计量和进行各种经济核算所必须的重要参数，是能源计量的重要组成部分。流体参数的测量在工业生产和过程控制中占有重要地位，特别是在热电厂、石油、矿山、冶金、航空、机械、医疗器械等领域。由于流体性质、流动状态、流动条件以及感测机理的复杂性，造成了流体参数测量系统的多样性、专用性和价格差异的悬殊性。通过流体流速的测量，人们可以了解流动过程，并且根据流体的流动状态对生产工艺进行自动控制，进而实现能源的有效管理，从而保证产品的质量，提高生产效率，节约能源。 风速测量作为流速测量领域一个重要的部分，与人们的日常生产、生活密不可分。当今世界，风速、风量仪表更多的出现在工业生产、日常生活等领域，它 与国民经济、工业生产、科学研究和环境保护息息相关。随着工业自动化的飞速发展，人们对
三峡大学算法设计与分析论文-倍增思想在算法运用与实现
01-13
作者首先从一个常见的问题引入，即在有序数组中查找最大的不小于或最小的大于特定数的元素。传统方法是线性搜索，时间复杂度为O(n)。而通过引入倍增的思想，可以将时间复杂度降低到O(log n)。 倍增算法的核心在于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值