java算法整理

冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class bubble {
    public static void main(String[] args) {
        int[] values = {3,1,6,2,9,0,7,4,5,8,8,10,14,12};
        bubbleSort(values);
        System.out.println(Arrays.toString(values));
    }
    public static void bubbleSort(int[] values){
        int temp = 0;
        for(int i=0;i<values.length-1;i++){//每一轮排序都会找到一个最大值，每一轮比较次数都比上一轮少一次
            for(int j=0;j<values.length-1-i;j++){
                if(values[j]>values[j+1]){
                  temp = values[j];
                  values[j]=values[j+1];
                  values[j+1]=temp;
                }
            }
        }
    }
}
//优化
public static void bubbleSort(int[] values){
        int temp = 0;
        for(int i=0;i<values.length-1;i++){
            boolean flag = true;//判断没有发生交换，表明已经排好，不需要再排了
            for(int j=0;j<values.length-1-i;j++){
                if(values[j]>values[j+1]){
                  temp = values[j];
                  values[j]=values[j+1];
                  values[j+1]=temp;
                  flag = false;
                }
            }
            if(flag){
                break;
            }
        }
    }

快速排序

二分法查找

前提：数组必须有序

import java.util.Arrays;
public class binarry {
    public static void main(String[] args) {
        int[] arr = {30,20,50,10,80,9,7,12,100,40,8};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(binarrySearch(arr,7));
    }
    public static int binarrySearch(int[] arr,int value){
        int low = 0;
        int high = arr.length-1;
        while(low<high){
            int mid = (low+high)/2;
            if(value==arr[mid]){
                return mid;
            }
            if (value>arr[mid]){
                low = mid+1;
            }
            if(value<arr[mid]){
                high = mid-1;
            }
        }
        return -1;
    }
}

案例

递归：计算n！

注意：任何能用递归解决的问题也能使用迭代解决
在高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存

//递归
public class digui821 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        System.out.println(factorial(num));   
    }
    //递归
    static long factorial(int n){
        if(n == 1){//递归头
            return 1;
        }else{//递归体
            return n*factorial(n-1);
        }
    }
    //循环
    static long factorialLoop(int a){
    	long result = 1;
    	while(a>1){
		result=result*a*(a-1);
		a=a-2;
		}
		return result;
    }
}

输入一个数n，输出一个数m，这个数满足h=m*4是m到倒序数，例如m=2178，且h，m小于n

public static void main(String[] args) {

        for(int i=1;i<1000000;i++){
            int num=i;
            int obj=4*i;
            String numStr=""+num;
            String objStr=""+obj;
            if(numStr.length()==objStr.length()){
                int len = numStr.length();
                int gc = 0;
                for(int j=0;j<len;j++){
                    if(numStr.charAt(j)==objStr.charAt(len-j-1)){
                        gc = gc+1;
                    }
                    if(gc == len){
                        System.out.println(num);
                        break;
                    }
                }
            }
        }
    }

从一个数组中找到两个数的和等于目标数

import java.util.Arrays;

public class text1 {
    public static void main(String[] args) {
        int target = 9;
        int[] list = {2,7,11,15,6,1,5,4};
        twoSum(list,target);
    }
    public static void twoSum(int[] nums, int target) {
        int[] obj=nums;
        int len = nums.length;
        for (int i=0 ;i < len;i++){
            for(int j=0;j<len;j++){
                if(i<j && obj[i]+obj[j]==target){ //&&可以去重防止[2,7][7,2]出现
                    int[] re=new int[]{obj[i],obj[j]};
                    System.out.println(Arrays.toString(re));
                }
            }
        }
    }
}