1.冒泡排序
冒泡排序(Bubble Sort)也是一种简单直观的排序算法。
它重复的遍历过要排序的数列,一次比较相邻的两个元素,如果他们的顺序错误就把他们交换过来。
这个算法的名字由来是因为越大的元素会经由交换慢慢"浮"到最后面。
当然,大家可以按照从大到小的方式进行排列。
### 1.1 算法步骤
1. 相邻的元素两两比较,大的放右边,小的放左边
2. 第一轮比较完毕之后,最大值就已经确定,第二轮可以少循环一次,后面以此类推
3. 如果数组中有n个数据,总共我们只要执行n-1轮的代码就可以
package date11;
public class text5 {
public static void main(String[] args) {
int[] arr={2,5,3,4,9,7,8,6,1,10};
int temn=0;
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1; j++) {
if(arr[j]>arr[j+1]){
temn=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temn;
}
}
}
for (int i1 = 0; i1 < arr.length; i1++) {
int i2 = arr[i1];
System.out.print(i2+" ");
}
}
}
2. 选择排序
2.1 算法步骤
1. 从0索引开始,跟后面的元素一一比较
2. 小的放前面,大的放后面
3. 第一次循环结束后,最小的数据已经确定
4. 第二次循环从1索引开始以此类推
5. 第三轮循环从2索引开始以此类推
6. 第四轮循环从3索引开始以此类推。
package date11;
public class text6 {
public static void main(String[] args) {
int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1};
int temn = 0;
for (int j = 0; j < arr.length - 1; j++) {
for (int i = j+1; i < arr.length; i++) {
if(arr[j]>arr[i]){
temn=arr[j];
arr[j]=arr[i];
arr[i]=temn;
}
}
} for (int i1 = 0; i1 < arr.length; i1++) {
int i2 = arr[i1];
System.out.print(i2+" ");
}
}}
3.插入排序
插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴,但它的原理应该是最容易理解的了,因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法,它的工作原理是通过创建有序序列和无序序列,然后再遍历无序序列得到里面每一个数字,把每一个数字插入到有序序列中正确的位置。 插入排序在插入的时候,有优化算法,在遍历有序序列找正确位置时,可以采取二分查找 ### 3.1 算法步骤 将0索引的元素到N索引的元素看做是有序的,把N+1索引的元素到最后一个当成是无序的。 遍历无序的数据,将遍历到的元素插入有序序列中适当的位置,如遇到相同数据,插在后面。
package com.itheima.mysort;
public class A03_InsertDemo {
public static void main(String[] args) {
/*
插入排序:
将0索引的元素到N索引的元素看做是有序的,把N+1索引的元素到最后一个当成是无序的。
遍历无序的数据,将遍历到的元素插入有序序列中适当的位置,如遇到相同数据,插在后面。
N的范围:0~最大索引
*/
int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
//1.找到无序的哪一组数组是从哪个索引开始的。 2
int startIndex = -1;
for (int i = 0; i < arr.length; i++) {
if(arr[i] > arr[i + 1]){
startIndex = i + 1;
break;
}
}
//2.遍历从startIndex开始到最后一个元素,依次得到无序的哪一组数据中的每一个元素
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) {
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
4.快速排序
1. 从数列中挑出一个元素,一般都是左边第一个数字,称为 "基准数";
2. 创建两个指针,一个从前往后走,一个从后往前走。
3. 先执行后面的指针,找出第一个比基准数小的数字
4. 再执行前面的指针,找出第一个比基准数大的数字
5. 交换两个指针指向的数字
6. 直到两个指针相遇
7. 将基准数跟指针指向位置的数字交换位置,称之为:基准数归位。
8. 第一轮结束之后,基准数左边的数字都是比基准数小的,基准数右边的数字都是比基准数大的。
9. 把基准数左边看做一个序列,把基准数右边看做一个序列,按照刚刚的规则递归排序
package date11;
public class text7 {
public static void main(String[] args) {
int[] arr={1,6,9,4,12,33,56,2,7,34,56,76,88,99,77,66,55,44,90};
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){
while (true){
if(end<=start||arr[end]<basenumber){
break;
}end--;
}
while (true){
if(end<=start||arr[start]>basenumber){
break;
}start++;
}
int time=arr[end];
arr[end]=arr[start];
arr[start]=time;
}
int temp=arr[i];
arr[i]=arr[start];
arr[start]=temp;
quickSort(arr,0,start-1);
quickSort(arr,start+1,j);
}
}
5、Arrays
静态方法点类名直接调用
方法名 | 说明 |
public static String toString(数组) | 把数组拼接成一个字符串 |
public static int binarySearch(数组,查找的元素) | 二分查找法查找元素 |
public static int] copyOf(原数组,新数组长度) | 拷贝数组 |
public static int] copyOfRange(原数组,起始索引,结束索引) | 拷贝数组(指定范围) |
public static void fill(数组,元素) | 填充数组 |
public static void sort(数组) | 按照默认方式进行数组排序 |
public static void sort(数组,排序规则) | 按照指定的规则排序 |
public static void sort(数组,排序规则) 的运用
package date11;
import java.util.Arrays;
import java.util.Comparator;
public class text8 {
public static void main(String[] args) {
nvpy n1=new nvpy("xiaoshishi",18,178);
nvpy n2=new nvpy("xiaodandan",19,172);
nvpy n3=new nvpy("xiaohuihui",19,178);
nvpy[] arr={n1,n2,n3};
Arrays.sort(arr, new Comparator<nvpy>() {
@Override
public int compare(nvpy o1, nvpy o2) {
double time = o1.getAge() - o2.getAge();
time = time == 0 ? o1.getHigte() - o2.getHigte() : time;
time = time == 0 ? o1.getName().compareTo(o2.getName()) : time;
if (time > 0) {
return 1;
} else if (time < 0) {
return -1;
} else {
return 0;
}
}
});
System.out.println(Arrays.toString(arr));
}
static class nvpy {
private String name;
private int age;
private double higte;
public nvpy() {
}
public nvpy(String name, int age, double higte) {
this.name = name;
this.age = age;
this.higte = higte;
}
/**
* 获取
* @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 higte
*/
public double getHigte() {
return higte;
}
/**
* 设置
* @param higte
*/
public void setHigte(double higte) {
this.higte = higte;
}
public String toString() {
return "nvpy{name = " + name + ", age = " + age + ", higte = " + higte + "}";
}
}
}
6.Lambda表达式和他的省略写法
省略核心:可推导,可省略
参数类型可以省略不写。
如果只有一个参数,参数类型可以省略,同时()也可以省略。
如果Lambda表达式的方法体只有一行,大括号,分号,return可以省略不写,需要同时省略。
、Lambda表达式的基本作用?
简化函数式接口的匿名内部类的写法。
2、Lambda表达式有什么使用前提?
必须是接口的匿名内部类,接口中只能有一个抽象方法
3、Lambda的好处?
Lambda是一个匿名函数,我们可以把Lambda表达式理解为是一段可以传递的代码,它可以写出更简洁、更灵活的代码,作为一种更紧凑的代码风格,使ava语言表达能力得到了提升。