第3章 方法与数组（多维数组：冒泡排序、选择排序、插入排序、二分（折半）查找算法）

最新推荐文章于 2023-03-17 11:26:00 发布
最新推荐文章于 2023-03-17 11:26:00 发布
阅读量190 收藏
点赞数
分类专栏： Java 文章标签： java 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43796123/article/details/105440081
版权

9. 方法与函数

1.方法打印三角形

import java.util.Scanner;
class Function{
	public static void main(String[] args) {
		System.out.println("输入想要打印*的行数");
		Scanner sc = new Scanner(System.in);
		int line = sc.nextInt();
		printStar(line);
	}
	public static void printStar(int line){
		for(int i=0;i<=line;i++){
			for(int j=0;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

2.方法判断是不是闰年

import java.util.Scanner;
class JudgeLeepYear1 {
	public static void main (String[] args) {
		System.out.println("请输入一个年份：");
		Scanner sc = new Scanner(System.in);
		int year = sc.nextInt();
		boolean bl = judgeleepyear(year);
		if(bl) {
			System.out.println(year + "年是闰年√");			
		}else {
			System.out.println(year + "年不是闰年×");
		}
	}
	public static boolean judgeleepyear(int year) {
		if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
			return true;
			//System.out.println(year + "年是闰年√");
		}else{
			return false;
			//System.out.println(year + "年不是闰年×");
		}
	}
}
数组

数组的赋值方式：

1.使用默认的初始值来初始化数组中的每一个元素

数组元素类型[]数组名 = new 数字元素类型[数组中元素的个数(数组的长度)]

如 int[] scores = new int[3];

2.先声明，然后再赋予默认的初始值

数字元素类型[]数组名；

数组名=new 数组元素类型[数组中元素的个数(数组的长度)]

如 int[] scores ；

scores = new int[3];

3.先声明，然后再使用指定的值进行初始化

数组元素类型[]数组名=new 数组元素类型[]{元素1，元素2，…}；

如 int[] scores = new int[]{56,78,98};

4.将第三种写法可以简化为(使用数组常量值给数组进行赋值)

数组元素类型[]数组名 = {元素1，元素2，…}；

如 int[] scores = {56,78,98};

数组的遍历：

class ArrayList {
	public static void main(String[] args) {
		int[] nums = new int[10];
		for(int i = 1;i <= nums.length;i++){
			System.out.println("nums["+(i-1)+"]="+i);				
		}
		 int[] score = new int[]{89,8989,9,898,98,99};
		for(int x:score){
			System.out.println(x);  
		}
	}		
}

1.判断一个随机数组是否有输入的数

import java.util.*;
class test {
	public static void main(String[] args) {
		int[] nums = new int[5];
		int len = nums.length;
		Random r = new Random();
		for(int i = 0;i < len;i++){
			nums[i] = r.nextInt(100);
		}
	
		System.out.println("输入一个数：");
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();
		boolean flag = false;
		System.out.println("生成的随机数是：");
		for(int x:nums) {
			System.out.println(x);
			if(num == x){
				flag = true;
				break;
			}
		}
		if(flag){
			System.out.println("有你输入的数");
		}else{
			System.out.println("没有你输入的数");
		}
		
	}
}

2.打印
            A
          B B B 
        C C C C C 
      D D D D D D D
    E E E E E E E E E
  F F F F F F F F F F F
G G G G G G G G G G G G G 

import java.util.*;
class test {
	public static void main(String[] args) {
		char[] cs = {'A','B','C','D','E','F','G'};
		int len = cs.length;
		
		for(int i = 1;i <= len;i++){
			for(int j = i;j < len;j++){
				System.out.print(" ");
			}
			for(int j = 1;j <= i*2-1;j++){
				System.out.print(cs[i-1]);
			}
			System.out.println();
		}		
	}
}

多维数组

3.有3个班级各3名学员参赛，纪录每个学员的成绩，并计算每个班级的平均分

import java.util.*;
class test {
	public static void main(String[] args) {	
		int [][] scores = {{78,79,80},{88,89,90},{56,57,58}};
		int classLen = scores.length;
		for(int i = 0;i < classLen;i++) {
			int sum = 0;
			int count = scores[i].length;
			for(int j = 0;j < count;j++){
				sum += scores[i][j];
			}
			int avg = sum/count;
			System.out.println("第"+(i+1)+"班的平均成绩是："+avg);
		}
		
	}
}

4.求最大值最小值算法

class maxmin {
	public static void main(String[] args) {
		int[] num = {12,23,434,3,7,5555,56,78,0};
		int max = max(num);
		System.out.println("最大值是："+max);
		int min = min(num);
		System.out.println("最小值是："+min);
	}
	public static int max(int[] num){
		int max = num[0];
		int len = num.length;
		for(int i = 1;i < len;i++) {
			if(num[i] > max) {
				num[i] = num[i]+max;
				max = num[i]-max;
				num[i] = num[i]-max;
			}
		}
		return max;
	}
	public static int min(int[] num){
		int min = num[0];
		int len = num.length;
		for(int i = 1;i < len;i++) {
			if(num[i] < min) {
				num[i] = num[i]+min;
				min = num[i]-min;
				num[i] = num[i]-min;
			}
		}
		return min;
	}
}
5. 冒泡排序（比较相邻的元素，如果第一个比第二个大，就交换它们两个，对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重读以上的步骤，除了最后一个。持续每次对越来越少的元素重读上面的步骤，直到没有任何一对数字需要比较。相同元素的前后顺序并没有改变）————冒泡排序是一种稳定排序算法
class maopao {
	public static void main(String[] args) {
		int[] nums = {34,4,56,17,90,65};
		int len = nums.length;
		for(int i = 0;i < len-1;i++) {//外循环控制轮数，比较轮数等于数列的长度-1；
			for(int j = 0;j < len-1-i;j++) {
				if(nums[j]>nums[j+1]){
					nums[j] = nums[j]+nums[j+1];
					nums[j+1] = nums[j]-nums[j+1];
					nums[j] = nums[j]-nums[j+1];
				}				
			}
		}
		System.out.println("冒泡排序结果：");
		for(int x:nums){
			System.out.println(x);
		}
		
	}
}
/*
34 4 56 17 90 65

4 34 17 56 65 90	//第一轮 5次

4 17 34 56 65		//第二轮 4次

4 17 34 56			//第三轮 3次

4 17 34 			//第四轮 2次

4 17				//第五轮 1次
*/
6. 选择排序算法（每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已经排好的数列的最后，直到全部待排序的数据元素排序完毕）————选择排序是不稳定的排序方法
class xuanze {
	public static void main(String[] args) {
		int[] nums = {34,4,56,17,90,65};
		int minIndex = 0;//用于纪录每次比较的最小值下标
		//控制轮数
		for(int i = 0;i < nums.length-1;i++) {
			minIndex = i;//每轮假设一个最小值下标
			for(int j = i+1;j < nums.length;j++) {
				if(nums[minIndex] > nums[j]) {
					minIndex = j;
				}
			}
			//判断需要交换的数下标是否为自己
			if(minIndex != i) {
				nums[minIndex] = nums[minIndex]+nums[i];
				nums[i] = nums[minIndex]-nums[i];
				nums[minIndex] = nums[minIndex]-nums[i];
			}
		}
		System.out.println("选择排序结果：");
		for(int n: nums) {
			System.out.println(n);
		}		
	}
}
/*
34 4 56 17 90 65
4 34 56 17 90 65 第一轮 5次
4 17 56 34 90 65 第二轮 4次
4 17 34 56 90 65 第三轮 3次
4 17 34 56 90 65 第四轮 2次
4 17 34 56 65 90 第五轮 1次
*/
7. 插入排序算法（基本思想：每步将一个待排序的纪录，按其顺序码大小插入到前面已经排序的子序列的合适位置（从后向前找到合适的位置后插入），直到全部插入排序完为止）
class Insert {
	public static void main(String[] args) {
		int[] nums = {34,4,56,17,90,65};
		//控制比较的轮数
		for(int i = 1;i < nums.length;i++) {
			int temp = nums[i];//记录操作数
			int j = 0;
			for(j = i-1;j >= 0;j--) {
				if(nums[j] > temp) {
					nums[j+1] = nums[j];
				}else{
					break;
				}
			}
			if(nums[j+1] != temp) {
				nums[j+1] = temp;
			}
		}
		System.out.println("插入排序结果：");
		for(int n: nums) {
			System.out.println(n);
		}
	}
}

在这里插入图片描述

8. 二分(折半)查找算法 （前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，若大于中间索引值对应的元素，去右半部分查找，否则，去左半部分查找。以此类推直到找到为止找不到返回一个负数）
import java.util.Scanner;
class erfenSearch {
	public static void main(String[] args) {
		int[] nums = {10,20,50,88,90};
		System.out.println("输入你想要查找的数：");
		Scanner sc = new Scanner(System.in);
		int get = sc.nextInt();
		int index = binarySearch(nums,get);
		System.out.println("你要查找的数在数组中第"+(index+1)+"个");
	}
	public static int binarySearch(int[] nums,int key){
		int start = 0;
		int end = nums.length-1;
		
		while(start <= end) {
			int middle = (start+end)/2;
			if(nums[middle] > key) {
				end = middle-1;
			}else if(nums[middle] < key) {
				start = middle+1;
			}else{
				return middle;
			}
		}
		return -1;
	}
}
Pluto,
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二维数组冒泡排序
YanJiDao的博客
11-18 893
import java.util.Arrays; public class Task03 { public static void main(String[] args) { int[][] a={{1,10,4,3},{6,11,12,5,13},{8,2,14,15,16,17},{18,9,7,19,20}}; int i,j,k; for(i=0;i for(j
一维数组 二维数组 多维数组 冒泡排序
weixin_30325971的博客
03-01 94
数组的定义1、数组里面的内容必须是同一类型2、数据必须有长度限制 一维数组： ***一、数据类型[] 变量名 = new 数据类型[长度]； string[]shuzu=new string []{}; int[]shuzu=new int[]{}; 数组可以定义string变量 也可以定义int变量 int a; int[] sz = new ...
多维数组，Arrays类，冒泡排序
shenmone的博客
05-23 158
多维数组 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。 二维数组：int A[ ] [ ] = mew int[2] [5]; 解析：以上二维数组A可以看成一个两行五列的数组。 public static void main(String[] args) { int[][] array = {{1,2},{2,3},{3,4},{4,5,6}}; System.out.println(array[3][1]);//
希尔排序（C语言实现）
CC1035471274的博客
05-21 1313
算法思想直插排序是特殊的希尔排序，直插排序每次插入前的遍历步长为1，而希尔排序初始步长为要排的数的一半，之后每执行一次步长折半。代码实现如下：#include <stdio.h> #include <malloc.h>void Shell_sort(int *a, int len); //函数声明int main(void) { int i; int len; int *
008day数组的练习 ，多维数组，冒泡排序
Yanxiaona111的博客
08-04 216
一、静态函数和实例函数 自定义函数、js的内置函数。 Math.random(); 属于Math对象的。 isNaN()：window对象 Array.isArray():Array构造函数对象。 window对象的函数可以直接调用。 函数的分类：从函数的调用者来分类。 1: 静态方法： 函数的方法。这里的函数通常是构造函数。 目前接触到的所有的静态方法都是js内置的静态方法。 静态方法的调用者，在js中，首字母都是大写的，这些大写的对象 不仅仅代表了一个对象，还代表了类型。 静态方法通常是作为工具方法使用
C++多种排序源代码分享
10-23
- 折半插入排序：改进版的插入排序，通过二分查找确定插入位置，降低了比较次数，提高了效率，但整体时间复杂度仍为O(n^2)。 2. 希尔排序： - 希尔排序是插入排序的一种优化版本，通过增量序列对数据进行分组，...
实验6+数组——二维数组和字符数组.doc
11-15
常见的排序算法有冒泡排序、选择排序、插入排序等。 * 查找算法：用于在数组中查找指定元素。常见的查找算法有顺序查找、折半查找等。 三、字符数组和字符串处理函数 * 字符数组是指数组元素是字符类型的数组，...
软考辅导-数据结构与算法(“结点”文档)共134张.pptx
12-01
常用的排序算法有冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序等。 查找算法 查找算法是指对数据元素的查找操作。常用的查找算法有线性查找、折半查找、二叉树查找等。 数值计算算法 数值计算...
java基础知识学习教程-5数组.pptx
最新发布
10-30
数组算法举例包括冒泡排序、二分查找算法等。冒泡排序的解决思路是不断的比较数组中相邻的两个元素，较小者向左移动，较大者向右移动，从而实现数组中元素从左到右变为从小到大顺序的过程。二分查找算法又叫折半查找...
数据结构总结（自学、期末复习或考研备用）.pdf
01-16
第九章排序，介绍了多种排序算法，如直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、桶排序和基数排序，并对这些排序算法进行了综合比较。 理解并熟练掌握这些数据...
python对数组进行反转的方法
12-25
本文实例讲述了python对数组进行反转的方法。分享给大家供大家参考。具体实现方法如下： arr = [1,2,3] arr.reverse() print(arr) 输出： [3,2,1] 希望本文所述对大家的Python程序设计有所帮助。 您可能感兴趣的文章:python reverse反转部分数组的实例python list转置和前后反转的例子python numpy 反转 reverse示例
冒泡排序法，遍历n维数组！
Wsh20210301的博客
04-11 346
关于数组中的几个经典例题 冒泡排序法： 1.现有一个数组，子串都为数字，要求从小到大的方式排列数组并且打印出来! var arr=[1,25,14,99,8,39]; 参考代码块1： <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <
java数组排序练习——使用冒泡法排序int型的数组，使用选择排序排序Date型的数组...
Mao的博客
07-09 374
java数组排序练习——使用冒泡法排序int型的数组，使用选择排序排序Date型的数组 PracticeSort.java /* 练习， 使用冒泡法排序int型的数组 使用选择排序法排序Date型的数组 */ public class PracticeSort { public static void main(String[] args) { int[] a = ...
【数组】(选择、冒泡)排序、折半查找、获取最值、二维数组
it_Shine的博客
09-05 787
一、数组的定义和使用 1、概念：同一种类型数据的集合。其实就是一个容器。 2、数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。 3、数组定义的格式： 【格式一】：元素类型[] 数组名 = new 元素类型[元素个数或者数组长度]; 示例： int[] arr = new int[3]; 【格式二】：元素类型[] 数组名 = new 元素类型[]{元素，元素，
二维数组已选择排序、折半查找
ITclody的专栏
06-18 1303
1）选择排序      选择排序思想：   选择排序（Selection sort）是一种简单直观的排序算法。   工作原理：首先在未排序序列中找到最小元素，存放到排序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。依次类推，直到所有元素均排序完毕。  选择排序代码实现：       void xuanZe(int nums[],int len){  i
Python：数列翻转
WQ的博客
03-30 6528
【问题描述】 编写程序，对列表中的数据进行翻转转换，即将数组中第一个数和最后一个数交换、第二个数和倒数第二个数交换，依此类推。 建议使用列表的reverse方法。在搜索引擎输入“python reverse”可以检索到该方法的用法描述。 【输入形式】 数组元素的个数（n） 以及n个整数，采用空格隔开它们 【输出形式】 交换以后的数组，采用空格隔开它们 【样例输入】 4 1 2 3 4 【样例输出】 4 3 2 1 a=list(map(int,input().split())) de
数列翻转 华中农业大学 Python
Qianier的博客
03-29 2365
编写程序，对列表中的数据进行翻转转换，即将数组中第一个数和最后一个数交换、第二个数和倒数第二个数交换，依此类推。 a = input() b = [] for i in a.split(): b.append(int(i)) c = b[::-1] print(" ".join(str(i) for i in c)) ...
Python——实验四
weixin_52776993的博客
05-13 4182
Python——实验四 一、数字出现次数排序 【问题描述】 给定n个整数，请统计出每个整数出现的次数，按出现次数从多到少的顺序输出。 【输入形式】 第一行包含一个整数n，表示给定数字的个数; 第二行包含n个整数，相邻的整数之间用一个空格分隔，表示所给定的整数。 【输出形式】 输出有多行，每行包含两个整数，分别表示一个给定的整数和它出现的次数。按出现次数递减的顺序输出。如果两个整数出现的次数一样多，则先输出值较小的，然后输出值较大的。 【样例输入】 12 5 2 3 3 1 3 4 2 5 2 3 5 【样例
python：交换列表的第一个和最后一个元素(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-17 988
python：交换列表的第一个和最后一个元素(附完整源码)
" C语言实现排序算法：折半插入、冒泡、简单选择、快速、堆排序
实验题目是要求实现折半插入排序、冒泡排序、简单选择排序、快速排序、堆排序这几种排序算法。具体要求包括至少测试3组数据，包括正序、逆序和随机数据，以及对冒泡排序和快速排序每一趟的结构进行演示并计算比较...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值