【排序递归-学习笔记】

冒泡排序

冒泡排序:
1.相邻的数据两两比较,小的放前面,大的放后面
2.第一轮循环结束,最大值已经找到,在数组的最右边
3.第二轮循环只要在剩余的元素找最大值就可以了
4.如果数据中有n个数据,总共我们只要执行n-1轮的代码就可以了

package sortdemo;
public class sortdemo1 {
    public static void main(String[] args) {
        int[] arr = {2,4,5,3,1};
        for(int i = 0; i < arr.length - 1;i++){//轮数
            for(int j = 0;j < arr.length - i - 1;j++){//每一轮中如何比较数据并找到当前的最大值
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

选择排序

从0索引开始,拿着每一个元素跟后面的元素一次比较,小的放前面,大的放后面,以此类推.

package sortdemo;

public class SortDemo2 {
    public static void main(String[] args) {
        int[] arr = {2,4,5,3,1};
        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;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

插入排序

将0索引的元素到N索引的元素看作是有序的,把N+1索引的元素到最后一个当作是无序的.遍历无序的数据,将遍历到的元素插入有序序列中适当的位置,如遇到相同的数据,插在后面

package sortdemo;
public class SortDemo3 {
    public static void main(String[] args) {
        int[] arr = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
        //找到无序的那一组数据是从哪个索引开始的
        int startIndex = -1;
        for(int i = 0;i < arr.length; i++){
            if(arr[i] > arr[i+1]){
                startIndex = i;
                break;
            }
        }
        //遍历startindex开始到最后一个元素,一次得到无序的那一组每一个元素
        for (int i = startIndex; i < arr.length-1; i++) {
             for(int j = i + 1;j > 0;j--){
                 if(arr[j] < arr[j-1]){
                     int temp = arr[j];
                     arr[j] = arr[j - 1];
                     arr[j - 1] = temp;
                 }else if(arr[j] >= arr[j-1]){
                     break;
                 }
             }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

递归算法

递归指的是方法中调用方法本身的现象
**注意:**递归一定要有出口,否则就会出现内存溢出
可以将一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量程序就可以描述出解题过程所需要的多次重复计算.

package sortdemo;

public class RecursionDemo1 {
    public static void main(String[] args) {
        int sum = getSum(100);
        System.out.println(sum);
    }
    public static int getSum(int number){
        if(number == 1){
            return 1;
        }
        return number + getSum(number - 1);
    }
}

package sortdemo;

public class ResursionDemo2 {
    public static void main(String[] args) {
        System.out.println(mulNumber(5));
    }
    public static int mulNumber(int number){
        if(number == 1){
            return 1;
        }
        return number * mulNumber(number - 1);
    }
}

快速排序

第一轮:把0索引的数组作为基准数,确定基准数在数组中正确的位置,比基准数小的全部在左边,比基准数大的全部在右边

package sortdemo;

public class SortDemo4 {
    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(arr[end] < baseNumber || end <= start){
                    break;
                }
                end--;
            }
            //利用start,从前往后找,找比基准数大的数字
            while(true){
                if(arr[start] > baseNumber || end <= start){
                    break;
                }
                start++;
            }
            //把end和start指向的元素进行交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        //当start和end只想同一个元素的时候,那么上面的循环就会结束
        //表示已经找到了基准数在数组中应存入的位置
        //基准数归为
        int temp = arr[start];
        arr[start] = baseNumber;
        arr[i] = temp;
        quickSort(arr,0,start-1);//递归调用
        quickSort(arr,start+1,j);//递归调用
    }
}

Arrays

操作数组的工具类

Lambda表达式

函数式编程

函数式编程是一种思想特点

面型对象先找对象,让对象做事情

Arrays.sort(arr,new Comparator<Integer>(){
	public int compare(Integer o1,Integer o2){
		return o1 - o2;
	}
});

函数式编程忽略面向对象的复杂语法,强调做什么,而不是谁去做.
Lambda表达式就是函数式思想的体现
格式

() -> {
}

1.() 对应着方法的形参
2.-> 固定格式
3.{} 对应方法的方法体

Arrays.sort(arr,(Integer o1,Integer o2)->{
		return o1 - o2;
});

注意点
1.Lambda表达式可以用来简化匿名内部类的书写
2.Lambda表达式只能简化函数式接口的匿名内部类的写法
3.函数式接口:有且只有一个抽象方法的接口叫做函数式接口,接口上方可以加@FunctionalInterface注解

算法题

package test;

import java.util.Arrays;
import java.util.Comparator;

public class Test1 {
    public static void main(String[] args) {
        //定义数组并存储一些女人朋友对象,利用Arrays中的sort方法进行排序
        //要求1:属性有姓名,年龄,身高
        //要求2:按照年龄的大小进行排序,年龄一样,按照身高排序,身高一样按照字母进行排序(姓名中不要有中文或特殊字符,会涉及到后面的知识)
        GirlFriend g1 = new GirlFriend("aa",20,165);
        GirlFriend g2 = new GirlFriend("bb",22,160);
        GirlFriend g3 = new GirlFriend("cc",23,175);

        GirlFriend[] arr = {g1,g2,g3};
        Arrays.sort(arr, new Comparator<GirlFriend>() {
            @Override
            public int compare(GirlFriend o1, GirlFriend o2) {
                int temp = o1.getAge() - o2.getAge();
                temp = temp == 0? o1.getHeight() - o2.getHeight() : temp;
                temp = temp == 0 ? o1.getName().compareTo(o1.getName()) : temp;
                return temp;
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}
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 + "}";
    }
}

package test;

public class Test2 {
    public static void main(String[] args) {
        //有一个很有名的数学逻辑题叫做不死神兔问题,有一对兔子,从出生后第三个月起每个月都生一对兔子
        //小兔子长到第三个月后又每个月生一对兔子,假如兔子都不死,问第十二个月的兔子对数为多少?
        int[] arr = new int[12];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println(sum(12));
    }
    //Fn(12) = Fn(11) + Fn(10);
    //Fn(11) = Fn(10) + Fn(9);
    //...
    //Fn(3) = Fn(2) + Fn(1);
    //Fn(2) = 1;
    //Fn(1) = 1;
    public static int sum(int number){
        if(number == 1 || number == 2){
            return 1;
        }
        return sum(number - 1) + sum(number - 2);
    }
}

package test;

public class Test3 {
    public static void main(String[] args) {
        //有一堆桃子,猴子第一天吃了其中的一半,并多吃了一个.以后每天猴子都吃生剩下来的一半然后再多吃一个
        //第十天的时候(还没吃),发现只剩下一个桃子了,请问,最初总共多少个桃子?
        //day10: 1
        //day9: (day10 + 1) * 2
        //day8: (day9 + 1) * 2

        System.out.println(getSum(1));
    }
    public static int getSum(int sum){
        if(sum == 10){
            return 1;
        }
        return (getSum(sum + 1) + 1) * 2;
    }
}

package test;

public class Test4 {
    public static void main(String[] args) {
        //小明喜欢爬楼梯,他有时候一次爬一个台阶,有的时候是一次爬两个台阶
        //如果这个楼梯有20个台阶,小明一共有多少种爬法呢?
        //运算结果
        //1层台阶 1种爬法
        //2层台阶 2种爬法
        //7层台阶 21种爬法
        System.out.println(getCount(7));
    }
    public static int getCount(int n){
        if(n == 1){
            return 1;
        }
        if(n == 2){
            return 2;
        }
        return getCount(n-1) + getCount(n-2);
    }
}