查找算法
public class day11 {public static void main(String[] args) {//基本查找 / 顺序差宅//核心://从0索引开始挨个往后查找//需求:定义一个方法利用基本查找 查询某个元素是否存在//数据如下:{131,127,147,81,103,23,7,79}int[] arr={131,127,147,81,103,23,7,79};int number=81;System.out.println(basicSearch(arr, number));}public static boolean basicSearch(int[] arr,int number){for (int i = 0; i < arr.length; i++) {if(arr[i]==number){return true;}}return false;}
}import java.util.ArrayList;public class day11 {public static void main(String[] args) {//需求:定义一个方法利用基本查找 查询某个元素在数组中的索引//要求:需要考虑数组中元素有重复的可能性int[] arr={131,127,147,81,103,23,7,79,81};//要返回3 8int number=81;System.out.println(basicSearch(arr, number));//[3, 8]}//心得:如果我们要返回多个数据的话 可以把这些数据放到数组或者集合中.public static ArrayList basicSearch(int[] arr,int number){ArrayList<Integer>list = new ArrayList<>();for (int i = 0; i < arr.length; i++) {if(arr[i]==number){list.add(i);}}return list;}
}
public class day11 {public static void main(String[] args) {int[] arr={7,23,79,81,103,127,131,147};System.out.println(binaryResearch(arr,147));}public static int binaryResearch(int[] arr,int k){int max =arr.length-1;int min =0;while(true){if(min>max){return -1;}int mid =(min+max)/2;if(arr[mid]>k){max=mid-1;}else if(arr[mid]<k){min=mid+1;}else{return mid;}}}}
现实生活中不可能都这样 大部分都是一些有顺序一些无顺序
public class day11 {public static void main(String[] args) {int[] arr = {16, 5, 9, 12, 21, 18,32, 23, 37, 26, 45, 34,50, 48, 61, 52, 73, 66};//1.要把数据进行分块//要分几块 18开根号 4.24块//18/4=4.5//创建三个块的对象Block b1 =new Block(21,0,5);Block b2 =new Block(45,6,11);Block b3 =new Block(73,12,17);//定义数组来管理三个块的对象(索引表)Block[] blockArr={b1,b2,b3};//定义一个变量用来记录要查找的元素int number=37;//调用方法:传递索引表,数组,要查找的元素int index =getIndex(blockArr,arr,number);//打印一下System.out.println(index);}//利用分块查找的原理 查询number的索引//1.确定number在索引标的位置private static int getIndex(Block[] blockArr,int[] arr,int number){int indexBlock = findIndexBlock(blockArr,number);if(indexBlock==-1){//表示number不在数组当中的return -1;}//获取这一块的起始索引和结束索引int startIndex =blockArr[indexBlock].getStartIndex();int endIndex =blockArr[indexBlock].getEndIndex();//遍历for(int i=startIndex;i<=endIndex;i++){if(arr[i]==number){return i;}}return -1;}//定义一个方法 用来确定number在那一块中public static int findIndexBlock(Block[] blockArr,int number){
// Block b1 =new Block(21,0,5);-----0
// Block b2 =new Block(45,6,11);----1
// Block b3 =new Block(73,12,17);---2//从0索引开始遍历blockArr,如果number小于max,那么就表示number就是在这一块当中的for (int i = 0; i < blockArr.length; i++) {if(number<=blockArr[i].getMax()){return i;}}return -1;}
}
class Block {private int max;//最大值private int startIndex;//起始索引private int endIndex;//结束索引public Block() {}public Block(int max, int startIndex, int endIndex) {this.max = max;this.startIndex = startIndex;this.endIndex = endIndex;}/*** 获取* @return max*/public int getMax() {return max;}/*** 设置* @param max*/public void setMax(int max) {this.max = max;}/*** 获取* @return startIndex*/public int getStartIndex() {return startIndex;}/*** 设置* @param startIndex*/public void setStartIndex(int startIndex) {this.startIndex = startIndex;}/*** 获取* @return endIndex*/public int getEndIndex() {return endIndex;}/*** 设置* @param endIndex*/public void setEndIndex(int endIndex) {this.endIndex = endIndex;}public String toString() {return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";}
}
排序算法
public class day11 {public static void main(String[] args) {//冒泡排序//核心思想://相邻的两个元素两两比较 大的放右边,小的放左边//第一轮比较完毕之后,最大值就已经确定了,第二轮可以减少循环一次 后面一次类推//如果数组中有n个数,总共只需要执行n-1次循环就可以了//1.定义数组//2.利用冒泡排序将数组中的数据变成12345//第一轮://结束之后,最大值在数组的最右边 ....5int[] arr={2,4,5,3,1};//i表示数组中每个元素的索引 0 1 2 3 4for(int i=0;i<arr.length-1;i++){//0 1 2 3for(int j=0;j<arr.length-1-i;j++){if(arr[j]>arr[j+1]){int temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}//-1:为了防止索引越界//-i:提升效率 每一轮执行的次数应该比上一轮少一次}}printArr(arr);}public static void printArr(int[] arr){for(int k=0;k<arr.length;k++){System.out.print(arr[k]+" ");}System.out.println();}}
public class day11 {public static void main(String[] args) {//选择排序
// int[] arr={2,4,5,3,1};
// for (int i = 0+1; i < arr.length; i++) {
// if(arr[0]>arr[i]){
// int temp=arr[0];
// arr[0]=arr[i];
// arr[i]=temp;
// }
// }//最终代码int[] arr={2,4,5,3,1};//外循环:几轮//i:表示这一轮中 我拿着那个索引上的数据跟后面的数据进行比较并交换for (int i = 0; i < arr.length-1; i++) {//内循环:每一轮干什么事情//拿着i跟i后面的数据进行交换for (int j = i+1; j < arr.length; j++) {if(arr[i]>arr[j]){int temp=arr[i];arr[i]=arr[j];arr[j]=temp;}}}printArr(arr);}public static void printArr(int[] arr){for(int k=0;k<arr.length;k++){System.out.print(arr[k]+" ");}System.out.println();}}
将无序插入有序
public class day11 {public static void main(String[] args) {//插入排序int[] arr={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};//1.找到无序的那组数据int startIndex=-1;for (int i = 0; i < arr.length; i++) {if(arr[i]>arr[i+1]){//System.out.println(i+1);startIndex=i+1;break;}}//2.遍历从startIndex开始到最后一个元素,依次得到无序的那一组数据中的每一个元素for (int i = startIndex; i < arr.length; i++) {//System.out.println(arr[i]);//问题:如何把遍历到的数据,插入到前面有序的这一组当中//记录当前要插入数据的索引int j=i;while(j>0&&arr[j]<arr[j-1]){int temp=arr[j];arr[j]=arr[j-1];arr[j-1]=temp;j--;}//修改这个索引}printArr(arr);}public static void printArr(int[] arr){for(int k=0;k<arr.length;k++){System.out.print(arr[k]+" ");}System.out.println();}}
public class day11 {public static void main(String[] args) {//递归求和//大问题->小问题//1~100=100+1~99System.out.println(getSum(100));//5050}public static int getSum(int number){if(number==1){return 1;}return number+getSum(number-1);}
}
public class day11 {public static void main(String[] args) {System.out.println(FactorialRecursion(5));}public static int FactorialRecursion(int number){if(number==1){return 1;}//方法再调用时 参数必须更靠近出口return number*FactorialRecursion(number-1);}
}
public class test {public static void main(String[] args) {int[] arr={6,1,2,7,9,3,4,5,10,8};quickSort(arr,0,arr.length-1);for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+" ");}}public static void quickSort(int[] arr,int i,int j){//记录两个变量记录查找的范围int start=i;int end=j;if(start>end){return;//递归的出口}//记录基准数int baseNumber=arr[i];//利用循环找到要交换的数字while(start!=end){//利用end，从后往前开始找，找比基准数小的数字while(true){if(end<=start||arr[end]<baseNumber){break;}end--;}//利用start，从前往后找 ，找比基准数打的数字while(true){if(end<=start||arr[start]>baseNumber){break;}start++;}//把end和start指向的元素进行交换int temp=arr[start];arr[start]=arr[end];arr[end]=temp;}/** 参数一：要排序的数组* 参数二：要排序数组的起始索引* 参数三：要排序数组的结束索引* *///当start和end指向了同一个元素 那么上面的循环就会结束//表示以及找到了基准数在数组中应存入的位置//基准数归位//就算拿着这个范围中的第一个元素 根start指向的元素进行交换int temp=arr[i];arr[i]=arr[start];arr[start]=temp;//确定6左边的范围,重复刚刚的事情quickSort(arr,i,start-1);//右边quickSort(arr,start+1,j);}}
不能先移动start 不然会造成下面的结果
Arrays
数组的工具类
import java.util.Arrays;public class test {public static void main(String[] args) {//toString:将数组变成字符串System.out.println("----------toString-----------");int[] arr={1,2,3,4,5,6,7,8,9,10};System.out.println(Arrays.toString(arr));//binarySearch:二分查找查找元素//细节1:二分查找的前提 数组中的元素必须是有序的 数组中的元素必须是升序的//细节2:如果要查找的元素是存在的 那么返回真实的索引//但是,如果要查找的元素是不存在的,返回的是-插入点-1//为什么-1?//解释:如果此时要查找的数字是0 如果返回-插入点,就会出现问题 因为按照上面的规则返回值是-插入点 也就是-0 -0也是0//为了避免这样的情况 Java就减一System.out.println("----------binarySearch--------");System.out.println(Arrays.binarySearch(arr, 10));System.out.println(Arrays.binarySearch(arr, 2));System.out.println(Arrays.binarySearch(arr, 20));//-11//copyOf:拷贝数组//参数一:老数组//参数二:新数组的长度//方法的底层会根据第二个参数来创建新的数组//新数组小于 部分拷贝//新数组 大于 补上默认初始化值0System.out.println("---------copyOf-------------");int[] newArr1 =Arrays.copyOf(arr,20);System.out.println(Arrays.toString(newArr1));//copyOfRange:拷贝数组(指定范围)//细节:包头不包尾System.out.println("----------copyOfRange---------");int[] newArr2=Arrays.copyOfRange(arr,0,9);System.out.println(Arrays.toString(newArr2));//fill:填充数组System.out.println("------------fill---------------");Arrays.fill(arr,100);System.out.println(Arrays.toString(arr));//sort:排序 默认情况下,给基本数据类型进行升序排序//底层使用的是快速排序.System.out.println("----------sort------------");int[] arr2={10,2,3,5,6,1,7,8,4,9};Arrays.sort(arr2);System.out.println(Arrays.toString(arr2));}
}
import java.util.Arrays;
import java.util.Comparator;public class test {public static void main(String[] args) {/*public static void sort(数组,排列规则) 按照指定的规则排序** 参数一:要排序的数组* 参数二:排序的规则* 细节:* 只能给引用数据类型的数组进行排序* 如果数组是基本数据类型的 ,需要变成其对于的包装类* */Integer[] arr={2,3,1,5,6,7,8,4,9};//第二个参数是一个接口 所以我们在调用方法的时候 需要传递这个接口的实现类对象 作为排序的规则//但是这个实现类 只要使用一次 所以就没有必要单独去写一个类 直接才去匿名内部类的方式就可以了//底层原理://利用插入排序+二分查找到方式进行排序的//默认把0索引的数据当做是有序的序列,1索引到最后当做无序序列//遍历无序的序列得到里面的每一个元素 假设当前遍历得到的元素是A元素//把A往有序序列中进行插入,在插入的时候,是利用二分查找确定A元素的插入点//拿着A元素 跟插入点的元素进行比较 比较的规则就是compare的方法的方法体//如果方法的返回值是负数,拿着A继续跟前面的数据进行比较//如果方法的返回值是正数,拿着A继续跟后面的数据进行比较//如果方法的返回值是0,也拿着A跟后面的数据进行比较//直到能够确定A的最终位置为止//compare方法的心事参数://参数1 o1: 表示在无序序列中 遍历得到的每一个元素//参数2 o2: 有序序列中的元素//返回值://负数:表示当前要插入的元素是小的 放在前面//正数:表示当前要插入的元素是大的 放在后面//0:表示当前要插入的元素跟现在的元素比是一样的 也会放在后面//简单理解://o1-o2:升序排列//o2-o1:降序排列Arrays.sort(arr, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {System.out.println("--------------");System.out.println("o1:"+o1);System.out.println("o2:"+o2);return o1-o2;}});System.out.println(Arrays.toString(arr));}
}Lambda表达式
import java.util.Arrays;public class test {public static void main(String[] args) {//初始Lambda表达式 - 简化匿名内部类的书写Integer[] arr={2,3,1,5,6,7,8,4,9};// Arrays.sort(arr, new Comparator<Integer>() {
// @Override
// public int compare(Integer o1, Integer o2) {
// return o1-o2;
// }
// });Arrays.sort(arr, (Integer o1, Integer o2)-> {return o1-o2;});System.out.println(Arrays.toString(arr));}
}
public class test {public static void main(String[] args) {//1.利用匿名内部类的形式去调用下面的的方法//调用一个方法的时候,如果方法的形参是一个接口,那么我们要传递这个接口的实现类对象//如果实现类对象只要用到一次,就可以用匿名内部类的形式进行书写// method(new Swim() {
// @Override
// public void swimming() {
// System.out.println("正在游泳");
// }
// });//2.利用lambda表达式进行改写method(()->{System.out.println("正在游泳");});}public static void method(Swim s){s.swimming();}
}
@FunctionalInterface
interface Swim{public abstract void swimming();
}
import java.util.Arrays;
import java.util.Comparator;public class test {public static void main(String[] args) {Integer[] arr={2,3,1,5,6,7,8,4,9};Arrays.sort(arr, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1-o2;}});//Lambda完整格式Arrays.sort(arr,(Integer o1, Integer o2)-> {return o1-o2;});//Lambda省略写法Arrays.sort(arr,( o1, o2)-> o1-o2);System.out.println(Arrays.toString(arr));}
}
import java.util.Arrays;public class test {public static void main(String[] args) {String[] arr={"a","aaaa","aaa","aa"};//如果以后我们要把数组中的数据按照指定的方式进行排列 就需要用到sort方法,而且要制定排序的规则
// Arrays.sort(arr, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {//按照字符串长度进行排序return o1.length()-o2.length();}});// Arrays.sort(arr,(String o1, String o2)-> {
// //按照字符串长度进行排序
//
// return o1.length()-o2.length();
// }
// );Arrays.sort(arr,( o1, o2)->o1.length()-o2.length());//打印数组System.out.println(Arrays.toString(arr));}
}
import java.util.Arrays;public class test {public static void main(String[] args) {//前置知识 用compareTo来比较两个字符串
// String s1="a";//97
// String s2="b";//98
// int i=s1.compareTo(s2);
// System.out.println(i);//-1 s1<s2//1.创建三个女朋友的对象GirlFriend gf1 =new GirlFriend("xiaoshishi",18,1.67);GirlFriend gf2 =new GirlFriend("xiaodandan",19,1.72);GirlFriend gf3 =new GirlFriend("xiaohuihui",19,1.78);//2.定义数组存储女朋友信息GirlFriend[] arr={gf1,gf2,gf3};//3.利用Arrays中的sort方法进行排序//匿名内部类 Lambda
// Arrays.sort(arr, new Comparator<GirlFriend>() {
// @Override
// public int compare(GirlFriend o1, GirlFriend o2) {
// double temp = o1.getAge() - o2.getAge();
// temp = temp==0?o1.getHeight()-o2.getHeight():temp;
// temp = temp==0?o1.getName().compareTo(o2.getName()):temp;
// if(temp>0){
// return 1;
// }else if(temp<0){
// return -1;
// }else{
// return 0;
// }
//
// }
// });Arrays.sort(arr, (o1,o2)-> {double temp = o1.getAge() - o2.getAge();temp = temp==0?o1.getHeight()-o2.getHeight():temp;temp = temp==0?o1.getName().compareTo(o2.getName()):temp;if(temp>0){return 1;}else if(temp<0){return -1;}else{return 0;}});//展示一下数组中的内容System.out.println(Arrays.toString(arr));}
}public class GirlFriend {private String name;private int age;private double height;public GirlFriend() {}public GirlFriend(String name, int age, double height) {this.name = name;this.age = age;this.height = height;}/*** 获取* @return name*/public String getName() {return name;}/*** 设置* @param name*/public void setName(String name) {this.name = name;}/*** 获取* @return age*/public int getAge() {return age;}/*** 设置* @param age*/public void setAge(int age) {this.age = age;}/*** 获取* @return height*/public double getHeight() {return height;}/*** 设置* @param height*/public void setHeight(double height) {this.height = height;}public String toString() {return "GirlFriend{name = " + name + ", age = " + age + ", height = " + height + "}";}
} 
public class test {public static void main(String[] args) {
// //方法一:
// //1.创建一个长度为12的数组
// int[] arr=new int[12];
// //2.手动给0索引和1索引的数据进行赋值
// arr[0]=1;
// arr[1]=1;
//
// //3.利用循环给剩余的数据进行赋值
// for(int i=2;i<arr.length;i++){
// arr[i]=arr[i-1]+arr[i-2];
// }
// //1 1 2 3 5 8 13...
//
// //获取最大索引上的数据即可
// System.out.println(arr[11]);//方法二://1.递归出口//2.递归规律System.out.println(getSum(12));}public static int getSum(int month){if(month==1||month==2){return 1;}return getSum(month-1)+getSum(month-2);}
}
public class test {public static void main(String[] args) {/*day10:1day9:(day10+1)*2 =4day8:(day9+1)*2 =10* */System.out.println(getCount(1));}public static int getCount(int day){if(day<=0||day>=11){System.out.println("当前时间错误");return -1;}if(day==10){return 1;}return (getCount(day+1)+1)*2;}
}
