Java的常见算法和Lambda表达式

基本查找

package search.code;public class code1 {public static void main(String[] args) {//基本查找//核心//从0索引开始，一直往后查找，直到找到为止//需求：定义一个方法利用基本查找，查询某个元素是否存在//数据如下：{131, 127, 147, 81, 103, 23, 7, 79, 81}int[] arr = {131, 127, 147, 81, 103, 23, 7, 79, 81};int num = 81;//调用方法System.out.println(basicSearch(arr,num));}public static boolean basicSearch(int[] arr,int num){//利用基本查找，查询某个元素是否存在for (int i = 0; i < arr.length; i++) {if (arr[i]==num){return true;}}return false;}
}
运行结果：
true

顺序查找：

package search.code;import java.util.ArrayList;
import java.util.List;public class code2 {public static void main(String[] args) {//需求：定义一个方法利用基本查找，查询某个元素在数组中的索引//不需要考虑数组中元素是否重复int[] arr = {131, 127, 147, 81, 103, 23, 7, 79, 81, 81};int num = 81;//调用方法System.out.println(returnindex(arr, num));//需求：定义一个方法利用基本查找，查询某个元素在数组中的索引//需要考虑数组中元素是否重复}public static List<Integer> returnindex(int[] arr, int num) {List<Integer> indexs = new ArrayList<>();for (int i = 0; i < arr.length; i++) {if (arr[i] == num) {indexs.add(i);}}return indexs;}
}

运行结果：
[3, 8, 9]
二分查找/折半查找

二分查找/折半查找

二分查找/折半查找的实验代码：

package search.code;public class code3 {public static void main(String[] args) {//定义一个数组int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};//定义一个要查找的元素//调用方法int searchnum = search(arr, 10);System.out.println(searchnum);}public static int search(int[] arr, int num) {//定义两个变量去找查找要的数据int min = 0;int max = arr.length - 1;while (true) {//定义一个中间变量//进行判断if (min > max) {return -1;}//查找min和max的中间位置值int mid = (min + max) / 2;//拿着mid和要查找的元素再次进行判断//mid在要查找元素的左边//mid在要查找元素的右边//mid在要查找元素指向一个元素if (arr[mid] > num) {max = mid - 1;} else if (arr[mid] < num) {min = mid + 1;}else {return mid;}}}
}

运行结果：
9
二分查找总结：

二分查找改进与提升效率
插值查找
要求（数据分布比较均匀，不然反而会降低效率）

斐波那契查找：

三种查找方式的总结：

分块查找：

核心思路：先确定要查找的元素在哪一块，然后在块内挨个查找
分块查找的模式图：

总结

冒泡排序

冒泡排序

package search.code;public class Bubbledemo1 {public static void main(String[] args) {//定义数组int[] arr = {2, 1, 4, 3, 5};//利用冒泡排序进行排序//外循环for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - j; j++) {if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}//遍历数组printArr(arr);}private static void printArr(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}}
}

运行结果：
1 2 3 4 5

选择排序


选择排序：

package search.code;public class Selectiondemo1 {public static void main(String[] args) {//定义数组int[] arr = {2, 1, 4, 3, 5};//利用选择排序进行排序for (int i = 0; i < arr.length - 1; 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);}private static void printArr(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}}
}

运行结果：
1 2 3 4 5
插入排序：

插入排序：

package search.code;public class Insertdemo1 {public static void main(String[] args) {//定义数组int[] arr = {2, 3, 4553187, 67, 561, 32, 90, 14, 3, 215, 23, 413131, 9, 5354, 1, 2};int startIndex = -1;for (int i = startIndex; i < arr.length; 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);}private static void printArr(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}}
}

运行结果：
1 2 2 3 3 9 14 23 32 67 90 215 561 5354 413131 4553187

快速算法

递归的作用：

书写递归的两个核心：

求1-100之间的和

package search.code;public class Sumdemo1 {public static void main(String[] args) {int sum = getSum(100);System.out.println(sum);}private static int getSum(int i) {if (i == 1){return 1;}return i + getSum(i - 1);}
}

运行结果：
5050
递归求阶乘

package search.code;public class Recursiondemo1 {public static void main(String[] args) {//调用方法int result = getFactorialRecursion(5);System.out.println(result);}//递归求阶乘//5！ = 5 * 4 * 3 * 2 * 1private static int getFactorialRecursion(int i) {if (i == 1){return 1;}return i * getFactorialRecursion(i -1);}
}

运行结果：
120
递归的内存图

快速排序

package search.code;public class QuickSortdemo1 {public static void main(String[] args) {int[] arr = {4, 6, 7, 12, 1, 68, 89, 9, 23};quickSort(arr, 0, arr.length - 1);printArr(arr);}private static void quickSort(int[] arr, int i, int j) {//定义两个变量记录要查找的范围int startNum = i;int endNum = j;if (startNum > endNum){return;}//记录基准数int baseNum = arr[i];//使用循环找到要交换的数字//利用endNum从后往前找，找到比基准数小的数字while(startNum != endNum) {while (true) {if (endNum <= startNum || arr[endNum] < baseNum) {break;}endNum--;}//利用startNum从前往后找，找到比基准数小的数字while (true) {if (endNum <= startNum || arr[startNum] > baseNum) {break;}startNum++;}int temp = arr[startNum];arr[startNum] = arr[endNum];arr[endNum] = temp;}//当startNum和endNum指向同一个元素时，完成第一轮排序//把基准数归位int temp = arr[i];arr[i] = arr[startNum];arr[startNum] = temp;quickSort(arr,i,startNum - 1);quickSort(arr,startNum + 1,j);}private static void printArr(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}}
}

运行结果：
1 4 6 7 9 12 23 68 89
快速排序的使用时间

package search.code;import java.util.Random;public class QuickSortdemo1 {public static void main(String[] args) {printTime();}private static void getRandomArr() {int[] arr = new int[10000];Random r = new Random();for (int i = 0; i < arr.length; i++) {arr[i] = r.nextInt();}}private static void printTime() {long start = System.currentTimeMillis();getRandomArr();long end = System.currentTimeMillis();System.out.println(end - start);}private static void quickSort(int[] arr, int i, int j) {//定义两个变量记录要查找的范围int startNum = i;int endNum = j;if (startNum > endNum){return;}//记录基准数int baseNum = arr[i];//使用循环找到要交换的数字//利用endNum从后往前找，找到比基准数小的数字while(startNum != endNum) {while (true) {if (endNum <= startNum || arr[endNum] < baseNum) {break;}endNum--;}//利用startNum从前往后找，找到比基准数小的数字while (true) {if (endNum <= startNum || arr[startNum] > baseNum) {break;}startNum++;}int temp = arr[startNum];arr[startNum] = arr[endNum];arr[endNum] = temp;}//当startNum和endNum指向同一个元素时，完成第一轮排序//把基准数归位int temp = arr[i];arr[i] = arr[startNum];arr[startNum] = temp;quickSort(arr,i,startNum - 1);quickSort(arr,startNum + 1,j);}private static void printArr(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}}
}

运行时间：
1
Lambda表达式

package search.code;import java.util.Arrays;public class Lambdademo1 {public static void main(String[] args) {//初始Lambda表达式Integer[] arr = {1,12,32,2,4,3,7};Arrays.sort(arr,(a,b)->{return a - b;             //升序// return b - a;          //降序});System.out.println(Arrays.toString(arr));}
}

运行结果：
[1, 2, 3, 4, 7, 12, 32]
Lambda表达式的标准格式

JDK8以后的一种新的语法形式

注意点：

必须是函数式接口才能用Lambda表达式简写
总结：

省略核心：
可推导可省略
Lambda表达式规则：

Lambda表达式的完全省略式

package search.code;import java.util.Arrays;public class Lambdademo1 {public static void main(String[] args) {//初始Lambda表达式Integer[] arr = {1,12,32,2,4,3,7};Arrays.sort(arr,(a,b)->a-b);System.out.println(Arrays.toString(arr));}
}

运行结果：
[1, 2, 3, 4, 7, 12, 32]

package search.code;import java.util.Arrays;public class Lambdademo2 {public static void main(String[] args) {String[] arr = {"aa","a","aaaaaaaaaa","aa","aaa","aaaa"};//Lambda表达式Arrays.sort(arr,(String o1, String o2) ->o1.length() - o2.length());System.out.println(Arrays.toString(arr));}
}

运行结果：
[a, aa, aa, aaa, aaaa, aaaaaaaaaa]

练习.按照要求排序

Test

package search.code;import java.util.Arrays;public class GirlFriendTest {public static void main(String[] args) {GirlFriend gf1 = new GirlFriend("xx",18,160);GirlFriend gf2 = new GirlFriend("xy",19,165);GirlFriend gf3 = new GirlFriend("xss",20,168);GirlFriend[] arr = {gf1,gf2,gf3};Arrays.sort(arr,(o1,o2)->(o1.getAge()-o2.getAge()));System.out.println(Arrays.toString(arr));}
}

Javabean：

package search.code;public class GirlFriend {private String name;private int age;private int height;public GirlFriend(){}public GirlFriend(String name,int age ,int 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 int getHeight() {return height;}/*** 设置* @param height*/public void setHeight(int height) {this.height = height;}public String toString() {return "GirlFriend{name = " + name + ", age = " + age + ", height = " + height + "}";}
}

运行结果：
[GirlFriend{name = xx, age = 18, height = 160},
GirlFriend{name = xy, age = 19, height = 165},
GirlFriend{name = xss, age = 20, height = 168}]

递归的方法：

package kl003.Test6;public class Rabbit1 {public static void main(String[] args) {int sum = getSum(12);System.out.println(sum);}private static int getSum(int month) {if (month == 1 || month == 2){return  1;}else {return getSum(month -1) + getSum(month - 2);}}
}

赋值法：

package kl003.Test6;public class Rabbit1 {public static void main(String[] args) {int sum = getSum(12);System.out.println(sum);}private static int getSum(int month) {if (month == 1 || month == 2){return  1;}else {return getSum(month -1) + getSum(month - 2);}}
}

运行结果：
144

递归方法

package kl003.Test6;public class Monkey {public static void main(String[] args) {int sum = getSum(9);System.out.println(sum);}private static int getSum(int day) {if (day < 0 || day > 10){return -1;}if (day == 10){return 1;}else {return (getSum(day + 1) + 1) * 2;}}
}

运行结果：1534

package kl003.Test6;public class Floor {public static void main(String[] args) {int cnt  = getCnt(20);System.out.println(cnt);}private static int getCnt(int floor) {if (floor == 1){return 1;}if (floor == 2){return 2;}return getCnt(floor - 1) + getCnt(floor - 2);}
}

运行结果：
10946
谢谢观看！