今日重点:
目录
写程序的思路小tip:整理好思路再敲代码! 1.先完成需要要求的功能 2.根据程序运行的结果进行优化处理 3.代码重构 4.提升效率(研究算法)
一、数据结构(大概去了解)
数据结构是指数据在计算机内存空间中或磁盘中的组织形式,算法是完成特定任务的过程,数据类型是指一组值和一组对这些值得操作的集合。
Java有常见的八种数据结构
二、数组中的算法应用
数组是最基本的数据结构,是一张线性表(数据元素之间是一对一),连续都空间存储相同类型的数据---除了第一个和最后一个元素,其余的元素都是首尾连接。
(1)查找算法
①线性查找
要求:
找出一个数在数组中的位置
在数组中是否存在,如果存在,返回下标,如果不存在,返回-1
如果找到了,则把下标i保存起来,显示的你要找的数是xx,在目标数组中的下标是xxx
如果没找到,则显示你要找的数是xx,在目标数组中是不存在的。
package com.jr.morning;
import java.util.Scanner;
// 查找算法--线性查找:简单,便于理解
public class y1 {
public static void main(String[] args) {
/* 要求:
找出一个数在数组中的位置
在数组中是否存在,如果存在,返回下标,如果不存在,返回-1
如果找到了,则把下标i保存起来,显示的你要找的数是xx,在目标数组中的下标是xxx
如果没找到,则显示你要找的数是xx,在目标数组中是不存在的。
*/
int [] arr =new int[]{23,34,45,78,99,68,85};
Scanner sc =new Scanner(System.in);
System.out.println("请输入一个数:");
int num = sc.nextInt();
//定义一个布尔标志
boolean flag =false;//此处可以注销
int index=-1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
flag=true;//此处可以注销
index =i;
break;
}
}
if (flag){//注销上面两行代码之后,此处改成if(index != -1){}
System.out.println("你要找的数是:"+ num+",在目标数组中的下标是:"+index);
} else {
System.out.println("你要找的数是:"+ num+",在目标数组中不存在:"+index);
}
}
}
1. Boolean flag= true / false ;
2.if(flag)等价于if(flag=true)
3.if(f1ag)等价于if(flag-=true)
if(无论什么样子的booleanQ语句==true) 无论什么样式的boolean语句,仅当只有这个语句等于true时,才能执行if下面的{}中的语句,这个语句等于false时,执行的是else下面的(}中的语句.
②折半查找(二分法查找)
package com.jr.morning;
import java.util.Scanner;
//查找算法--折半查找(二分法查找):比线性查找更节省时间
//如果要使用二分法查找找数字,前提是这个数组必须有顺序
public class y2 {
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;
break;
}else if(arr[middle] > target){
// 说明我们要找的数在数组的前半区
/*
如果在前半区
维护left和right
left是不需要动的
right应该移位到中间位置
*/
right = middle - 1;
}else {
// 条件实际上就是arr[middle]<target
/*
说明在后半区
right是不需要动的
left应该向右移位到中间位置
*/
left = middle + 1;
}
}
System.out.println(target + "在目标数组中的下标是:" + res);
}
}
}
(2)排序算法
1.冒泡排序
2.快速排序
3.插入排序
4.选择排序
5.希尔排序
6.堆排序
7.归并排序
①冒泡排序
要求: 从小到大排序
冒泡排序思路分析:我先拿第一个数和后面的数一一比较大小
冒泡排序需要两层循环嵌套:for外层for循环控制的是需要各个数之间比较几轮
内层的for循环控制的是每个数的真正的比较
package com.jr.morning;
//排序算法--冒泡排序
public class y3 {
public static void main(String[] args) {
int[]arr=new int[]{1,58,46,33,10,5,-8};
/*要求:从小到大排序
冒泡排序过程
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和3333和10 33和5 33和-8
1 10 5- 8 33 46 58
1和10 10和5 10和-8
1 5 -8 10 33 46 58
1和5 5和-8
1 -8 5 10 33 46 58
-8 1 5 10 33 46 58
*/
for (int i = 0; i < arr.length -1; i++) {
//已经控制好了比较的次数
//比较的次数 = 数组的长度 -1
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();
}
}
}
冒泡排序的简便操作
package com.jr.morning;
import java.util.Arrays;
public class y4 {
//冒泡排序的简便操作
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);
}
}
}
②选择排序
package com.jr.morning;
//选择排序
public class y5 {
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();
}
}
}
③插入排序
package com.jr.morning;
//插入排序
public class y6 {
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;
//不能让它出负数,所以用一个循环来约束
//while的定义范围:
/*当上一个数的下标有效不能小于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 + "、");
}
}
}
三、数组的反转
package com.jsoft.afternoon;
import java.util.Arrays;
/**
* 数组的反转
*/
public class Ch03 {
public static void main(String[] args) {
// int [] arr = new int[]{1,25,48,12,10,-8,127,56};
// for (int i = arr.length - 1; i >= 0 ; i--) {
// System.out.println(arr[i]);
// }
/*
思路1:
创建一个等长的数组
把当前数组的每一个元素倒着添加到新数组里
新数组赋值给老数组
int [] newArr = new int[arr.lenth];
*/
// 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.println(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];
}
nums = temp;
System.out.println(Arrays.toString(nums));
}
}
总结:
综合运用所学知识完成员工管理系统,查找,排序,switch语句....没成功,没能消化掉,有点挫败。