20220715 第二小组 罗大禹 学习笔记
作者：互联网
Java
今日重点
- 查找算法
- 冒泡排序
- 数组的反转
- 数组的扩容
学习心得
今天老师下午上课时，由于自己本身有些困倦，注意力无法集中，导致选择排序和插入排序没听懂，课后我会再去看老师讲课的视频学习
学习内容
数组
老师写程序的思路分享：
1. 成需求要求的功能
2. 再根据程序运行的结果进行优化处理
3. 再去研究的代码的重构（优化）
4. 研究算法
查找算法：(理解)
线性查找：
（我们目前写的，一个一个找）
好处：简单，便于理解。
点击查看代码
import java.util.Scanner;
public class Ch01 {
public static void main(String[] args) {
/*
需求
找出一个数在数组中的位置
找到了，把下标保存，你要找的数是xxx，在目标数组中的下标是xxx
找不着，显示你要找的数是xxx，在目标数组中是不存在的
*/
//我的代码
int [] arr = new int[]{1,58,46,33,10,5,-8};
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数");
int num = sc.nextInt();
int arr1=0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]==num){
arr1=i;
System.out.println("你要找的数是："+num+"，在目标数组中的下标是"+i);
break;
}else if(i==arr.length-1){
System.out.println("你要找的数是:"+num+"在目标数组中是不存在的");
break;
}
}
//老师的代码
int index=0;
for (int i = 0; i < arr.length; i++) {
if (arr[i]==num){
index=i;
break;
}
}
if(index!=0){
System.out.println("你要找的数是："+num+"，在目标数组中的下标是："+index);
}else {
System.out.println("你要找的数是："+num+"，在目标数组中不存在");
}
}
}
二分法查找（折半查找）
（一半一半看）
查找算法：
二分法查找
如果要是用二分法查找数字，前提是这个数字必须有顺序
点击查看代码
import java.util.Scanner;
public class Ch02 {
public static void main(String[] args) {
int []arr=new int[]{1,2,3,4,5,6,7};
Scanner sc = new Scanner(System.in);
System.out.println("请输入数字");
int target = sc.nextInt();
//最左边的下标
int left=0;
//最左边的下标
int right=arr.length-1;
if (target<arr[left]||target>arr[right]){
System.out.println(target+"在目标数组中不存在");
}else {
//用来保存找到的下标的值
int res = -1;
while(left<=right){
//找出中间的下标
int middle = (left+right)/2;
if (arr[middle]==target){
//中间的数恰巧就是我们要找的数
res=middle;
left = arr.length;
}else if(arr[middle]>target){
/*
如果在前半区
维护left和right
left是不需要动的
right应该移位到中间位置
*/
right=middle-1;
}else{
//条件实际上就是arr[middle]<target
/*
说明在后半区
right是不需要动的
需要动的是left，应该向右移位至中间位置
*/
left = arr[middle]+1;
}
}
System.out.println(target+"在目标数组的下标是："+res);
}
}
}
排序算法
比较常见的：
1.冒泡排序
2.快速排序
3.插入排序
4.选择排序
不太常见的
5.希尔排序
6.堆排序
7.归并排序
8.桶排序
冒泡排序(理解)
冒泡排序为从小到大的排序
冒泡排序需要两层循环嵌套：常用for
外层循环控制的是需要各个数之间比较几轮
内层的循环控制的是每个数的真正的比较
点击查看代码
public class Ch03 {
public static void main(String[] args) {
/*
冒泡排序思路分析
1.先拿第一个数和后面的一一比较大小
第一次比较：1和58 58和46（换位） 58和33（换位） 58和10（换位） 58和5（换位） 58和-8（换位）
1 46 33 10 5 -8 58
通过第一次比较，最大的数已经归位（到达最后）
第二次比较：1和46 46和33（换位） 46和10（换位） 46和5（换位） 46和-8（换位）
1 33 10 5 -8 46 58
通过第二次比较，又找到了第二大的数，并且已经归位
第三次比较 1 10 5 -8 33 46 58
第四次比较 1 5 -8 10 33 46 58
第五次比较 1 -8 5 10 33 46 58
第六次比较 -8 1 5 10 33 46 58
比较次数为数组长度-1，因为当倒数第二大的数归位后，最小的数不需要与自己比较
*/
int [] arr = new int[]{1,58,46,33,10,5,-8};
for(int i=0;i<arr.length-1;i++){
//已经控制好了比较的次数
for (int j = 0; j <arr.length-1; j++) {
if (arr[j]>arr[j+1]){
//如果前面的比后面的大，换位
int temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.print("第"+(i+1)+"轮的结果是：");
for (int i1 : arr) {
System.out.print(i1+"、");
}
System.out.println(" ");
}
}
}
排序的简便操作
点击查看代码
import java.util.Arrays;
public class Ch04 {
public static void main(String[] args) {
int [] arr = new int[]{1,58,460,-33,10,5,-8};
// 从小到大排序
Arrays.sort(arr);
//遍历数组
for (int i : arr) {
System.out.println(i);
}
}
}
选择排序(没听懂)
点击查看代码
public class Ch01 {
public static void main(String[] args) {
/*
第一轮
i=0,minIndex=0，里层的for循环int j = 1;j < 7;
if(arr[0] > arr[1]){}。由于if不满足，则继续下一次的比较。
j = 2,if(arr[0] > arr[2]){}。由于if不满足，则继续下一次的比较。
j = 3,if(arr[0] > arr[3]){}。由于if不满足，则继续下一次的比较。
j = 4,if(arr[0] > arr[4]){}。由于if不满足，则继续下一次的比较。
j = 5,if(arr[0] > arr[5]){}。由于if满足条件，执行了minIndex = 5.
j = 6,if(arr[5] > arr[6]){}。由于if不满足，则继续下一次的比较。
j = 7,if(arr[5] > arr[7]){}。由于if不满足，则继续下一次的比较。
到此为止，里层的for循环执行完毕。minIndex = 5。
int temp = arr[5];
arr[5] = arr[0];
arr[0] = temp;
i=0的这次外层循环执行完毕。
数组变成了-8、25、48、12、10、1、127、56
第二轮
i=1,minIndex = 1,
j = 2,if(arr[1] > arr[2]){}。由于if不满足，则继续下一次的比较。
j = 3,if(arr[0] > arr[3]){}。由于if满足，minIndex = 3;
j = 4,if(arr[3] > arr[4]){}。由于if满足，minIndex = 4;
j = 5,if(arr[4] > arr[5]){}。由于if满足，minIndex = 5;
j = 6,if(arr[5] > arr[6]){}。由于if不满足，则继续下一次的比较。
j = 7,if(arr[5] > arr[7]){}。由于if不满足，则继续下一次的比较。
到此为止，里层的for循环执行完毕。minIndex = 5。执行的
int temp = arr[5];
arr[5] = arr[1];
arr[1] = temp;
数组变成了-8、1、48、12、10、25、127、56
第三轮
i=2;
*/
int [] arr = new int[]{1,25,48,12,10,-8,127,56};
for (int i = 0; i < arr.length; i++) {
// 假设最小数的下标
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if(arr[minIndex]>arr[j]){ // 找到了最小值
minIndex = j; //保存最小值的下标
}
}
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
System.out.print("第" + (i+1) + "次比较结果是：");
for (int i1 : arr) {
System.out.print(i1 + "、");
}
System.out.println();
}
// for (int i : arr) {
// System.out.print(i + "、");
// }
}
}
插入排序(没听懂)
点击查看代码
public class Ch02 {
public static void main(String[] args) {
/*
第一轮：
i=0,current=arr[1],int preIndex=0,
while(0 >= 0 && 25 < arr[0]){}不成立，while循环不启动
arr[0+1] = arr[0+1]
第二轮：
i=1,current=arr[2]=48,int preIndex=1
while(1 >= 0&&48<25){}不成立，while循环不启动
arr[1+1] = arr[1+1]
第三轮：
i=2,current=arr[3]=12,int preIndex=2
while(2 >=0 && 12 < 48){
arr[3] = arr[2]
2--;
}
preIndex=1;
while(1 >=0 && 12 < 25){
arr[2] = arr[1];
1--;
}
preIndex = 0;
while(0 >=0 && 12 < 1){}不成立，while完事
arr[1] = 12;
1,12,25,48,10,-8,127,56
第四轮：
i=3,current = arr[4] = 10,int preIndex = 3,
while(3>=0 && 10 < 48){
arr[4] = arr[3];
1,12,25,48,48,-8,127,56
3--;
}
preIndex = 2;
while(2>=0 && 10 < 25){
arr[3] = arr[2];
1,12,25,25,48,-8,127,56
2--;
}
preIndex = 1;
while(1>=0&& 10 < 12){
arr[2] = arr[1];
1,12,12,25,48,-8,127,56
1--;
}
preIndex = 0;
while(0>=0&&10 < 1){}不成立，while完事
arr[1] = current = 10;
1,10,12,25,48,-8,127,56
*/
int [] arr = new int[]{1,25,48,12,10,-8,127,56};
// 定义参照物
int current;
for (int i = 0; i < arr.length - 1; i++) {
current = arr[i + 1];
// 定义上一个元素的下标
int preIndex = i;
// 当上一个数的下标有效不能小于0
// 并且还要保证当前的数比他上一个数小，
// 这时候，才能让当前数向前移位
while(preIndex >= 0 && current < arr[preIndex]){
// 移位
// 前面的数后移一位
arr[preIndex + 1] = arr[preIndex];
//
preIndex--;
}
arr[preIndex + 1] = current;
}
for (int i : arr) {
System.out.print(i + "、");
}
}
}
数组的反转(理解)
思路1：
创建一个等长的数组
把当前数组的每一个元素倒着添加到新数组里
新数组赋值给老数组
int [] newArr = new int[arr.length];
int [] arr = new int[]{1,25,48,12,10,-8,127,56};
int [] newArr = new int[arr.length];
for (int i = arr.length - 1; i >= 0 ; i--) {
newArr[i] = arr[arr.length - 1 - i];
}
// 新数组赋值给老数组
arr = newArr;
for (int i : arr) {
System.out.print(i+"、");
}
思路2：
利用交换的方式
int [] arr = new int[]{1,25,48,12,10,-8,127,56};
for (int i = 0; i < arr.length / 2; i++) {
// temp存储的时最后一位
int temp = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = arr[i];
arr[i] = temp;
}
for (int i : arr) {
System.out.println(i);
}
// Arrays是操作数组的一个工具类
System.out.println(Arrays.toString(arr));
数组的扩容(理解)
package com.jsoft.afternoon;
import java.util.Arrays;
public class Ch04 {
public static void main(String[] args) {
int [] nums = new int[]{3,4,6};
// 定义一个新的临时数组
int [] temp = new int[6];
for (int i = 0; i < nums.length; i++) {
temp[i] = nums[i];
}
System.out.println(Arrays.toString(nums));
}
}
作业
点击查看代码
import java.util.Scanner;
public class ManageSystem {
public static void main(String[] args) {
int i = 0;
int[] number = new int[2];
String[] names = new String[2];
Scanner sc = new Scanner(System.in);
System.out.println("欢迎使用员工管理系统");
first:for (; ; ) {
System.out.println("请选择功能：1、添加员工 2、查询员工 3、修改员工 4、退出");
String flag = sc.next();
switch (flag) {
case "1":
/*
员工信息要保存到数组里。
1.工号（不能输入，自动生成的自动递增的一个数字1001）
2.员工姓名
员工的工号和姓名都是保存到数组里
int[]nos = new int[2];
string []names = new string[2];
要考虑扩容问题
*/
while (true) {
System.out.println("请输入员工姓名");
String name = sc.next();
System.out.println("您的姓名为：" + name);
System.out.println("您的工号为：" + (i+1001));
if (i>=names.length){
String [] temp1 = new String[names.length+2];
for (int j = 0; j < names.length; j++) {
temp1[j] = names[j];
}
names = temp1;
int [] temp2 = new int[number.length+2];
for (int k = 0; k < number.length; k++) {
temp2[k] = number[k];
}
number = temp2;
}
names[i] = name;
number[i] = i + 1001;
i++;
second :for (;;) {
System.out.println("是否继续操作？ 1、是 2、否");
String choose = sc.next();
switch (choose) {
case "1":
continue first;
case "2":
break first;
default:
System.out.println("输入错误，请重新输入");
continue second;
}
}
}
case "2":
/*
根据工号查询
如果有能力的，可以去做根据姓名查询，姓名可以重名（选做）。
*/
//去数组中找，如果找到了，则输出姓名，没找到，员工号有误
/*
排序：根据工号排序，倒序(选做)
*/
third:
for (;;) {
System.out.println("请输入工号：");
int jobNumber1 = sc.nextInt();
for (int l = 0; l < number.length; l++) {
if (number[l] == jobNumber1) {
System.out.println("您输入的工号是：" + jobNumber1 + "，姓名为：" + names[l]);
fourth:
for (; ; ) {
System.out.println("是否继续操作？ 1、是 2、否");
String choose = sc.next();
switch (choose) {
case "1":
continue first;
case "2":
break first;
default:
System.out.println("输入错误，请重新输入");
continue fourth;
}
}
} else if (l == number.length - 1) {
System.out.println("工号输入错误，请从新输入");
continue third;
}
}
}
case "3":
/*
修改两个操作
1、先输入员工号；先查询员工号在不在，若不在，员工号输入有误
如果在，先显示出原有信息，请输入新的名字
修改信息1002 nos[1] nos[1]
*/
fifth:
for(;;) {
System.out.println("请输入工号：");
int jobNumber2 = sc.nextInt();
for (int b = 0; b < number.length; b++) {
if (number[b] == jobNumber2) {
System.out.println("您输入的工号是：" + jobNumber2 + "，姓名为：" + names[b]);
System.out.println("请输入修改后的姓名：");
String rename = sc.next();
names[b]=rename;
System.out.println("您的工号是：" + jobNumber2 + "，修改后的姓名为：" + names[b]);
sixth:
for (;;) {
System.out.println("是否继续操作？ 1、是 2、否");
String choose = sc.next();
switch (choose) {
case "1":
continue first;
case "2":
break first;
default:
System.out.println("输入错误，请重新输入");
continue sixth;
}
}
} else if (b == number.length - 1) {
System.out.println("工号输入错误，请从新输入");
continue fifth;
}
}
}
case "4":
break first;
default:
System.out.print("输入错误,");
seventh:
for (;;) {
System.out.print("是否继续操作？ 1、是 2、否");
System.out.println();
String choose = sc.next();
switch (choose) {
case "1":
continue first;
case "2":
break first;
default:
System.out.println("输入错误，请重新输入");
continue seventh;
}
}
}
}
}
}
标签：10,arr,20220715,int,System,笔记,大禹,println,out 来源： https://www.cnblogs.com/ldydj/p/16483112.html