Java中必须要会的几个算法_java程序员需要的算法-优快云博客

Java中常见的算法

递归
二分查找
快速排序
冒泡排序
选择排序

递归

递归本质：程序调用自身的编程技巧叫做递归。

方法的递归调用指的是一个方法自己调用自己的形式。一般如果要进行方法的递归操作往往都具备有以下的特点：

方法必须有一个递归的结束条件；
方法在每次递归处理的时候一定要做出一些变更；

代码举例如下：

public class Algorithm {
    //递归
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入一个你想求的斐波那契数是:");
        int a = scan.nextInt();
        int ret = Sequence(a);
        System.out.println("你求的第"+a+"个斐波那契数为："+ret);

    }
    public static int  Sequence(int n){
        if(n==1||n==2){
            return 1;
        }
            return Sequence(n-1)+Sequence(n-2);

    }
}

二分查找

a) 前提条件：已排序的数组中查找

b) 二分查找的基本思想是：首先确定该查找区间的中间点位置： int mid = (low+upper) / 2；然后将待查找的值与中间点位置的值比较：若相等，则查找成功并返回此位置。若中间点位置值大于待查值，则新的查找区间是中间点位置的左边区域。若中间点位置值小于待查值，则新的查找区间是中间点位置的右边区域。下一次查找是针对新的查找区间进行的。

代码举例：

public class HalfSearch {
    public static void main(String[] args) {
        int[] nums = {1,3,6,8,9,14,17,19};
        int i = halfSearch(14, nums);
        System.out.println("待查找数所在下标："+i);
    }
    public static int halfSearch(int n , int[] nums){
        int l = 0;
        int h = nums.length-1;
        while (l <= h){
            int m = (l+h) /2;//获取中间位置
            if(n == nums[m]){
                return m;
            }else if(n < nums[m]){
                h = m-1;
            }else if(n > nums[m]){
                l = m +1;
            }
        }
        return -1;
    }
}

快速排序

快速排序的思想

基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

public class QuickkSort {
    public static void main(String[] args) {
            sort(2,4,5,3,1,7,9,8);
            Arrays.sort(new int[]{1,8,6,5,7,4});
    }
    public static void sort(int... nums){
        quickSort(nums,0,nums.length-1);
        System.out.println(Arrays.toString(nums));
    }
    public static void quickSort(int[] nums,int low ,int height){
        //递归出口  分治思想
        if(low < height){
            int m = findIndex(low,height,nums);
            quickSort(nums,low,m-1);
            quickSort(nums,m+1,height);
        }
    }
    //找参照物的位置
    public static int  findIndex(int low , int height , int[] nums){
        int temp = nums[low];//先指定最左侧的数据为基准数据
        int l = low;
        int h = height;
        while(l < h){
            //表示最低位和最高位没有相遇时  一直循环交换目标数值两端的数据
            //从右向左比较  查询小于当前基准数的值
            while(temp < nums[h] && l <h){
                    h--;
            }
            //开始从左向右 找大于基准数据的值
            while (temp > nums[l] && l < h) {
                    l++;
            }
            //交换当前小于参照数和大于参照数的值
            if(l < h){
                int t = nums[h];
                nums[h] = nums[l];
                nums[l] = t;
            }
        }
        if(l == h){
            nums[l] = temp;
        }
        return l;
    }
}

冒泡排序（必须要掌握）

一.冒泡排序简介(从小到大排序）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个，即需要进行length-1次。

举例代码1：

 public static void main(String[] args) {
        int [] rank=new int[]{1,2,4,2,3,8,9,7,6};
        boolean hasAnyExchanged=true;
        //冒泡算法排序的优化
        while (hasAnyExchanged){
            hasAnyExchanged=false;
            for (int i = 0; i < rank.length-1; i++) {
                if (rank[i]>rank[i+1]){
                    int temp=rank[i];
                    rank[i]=rank[i+1];
                    rank[i+1]=temp;
                    hasAnyExchanged=true;
        }
            }
        }
        System.out.println(Arrays.toString(rank));
    }

举例代码2：

public class BubbleSort {
    /*
       排序：
       冒泡算法：每次比较 相邻两元素 依次执行 并将较大的值放置在右端

       当前比较的有n个元素时
       一共需要比较 n-1轮 若当前的轮数为 i
       则当前轮需要比较的额次数为 n-i
     */
    public static void main(String[] args) {
//            bubbleSort(2,5,4,3,7,6,1);
        int[] a = {2,5,4,3,7,6,1};
        Arrays.sort(a);//快速排序  选择排序  递归  查找
        System.out.println(Arrays.toString(a));
    }
    public static void bubbleSort(int... nums){
        for(int i = 0 ; i < nums.length-1;i++){
            //控制的是比较的轮数
            for(int k = 0 ; k < nums.length-1-i;k++){
                //每轮比较的次数
                if(nums[k] > nums[k+1]){
                    //两个数交换  可以使用第三方变量 参与交换
                    //不通过第三方数据  通过 异或进行交换  ^
                    int temp = nums[k];
                    nums[k] = nums[k+1];
                    nums[k+1] = temp;
                }
            }
        }
        System.out.println("排序后的内容："+ Arrays.toString(nums));
    }

}

选择排序

选择排序算法较为稳定，基本上都是O(n2)的时间复杂度，规模越小排序越快，不需要占用额外空间。其实选择排序原理很简单，就是在未排序序列中找到最小（大）的元素然后放到数组前面，然后再从剩下的未排序序列中找到最小（大）的元素放在上一次找到最小（大）元素的后面，以此类推完成排序。

动图演示

代码举例：

/*
选择排序
原理：
每轮比较出一个最小的下标 并和当前轮数的最左侧内容进行交换
优点 交换次数减少
 */
import java.util.Arrays;
public class SelectSort {
    public static void main(String[] args) {

        selectSort(2,4,2,6,8,3,18,1);
    }
    public static void selectSort(int... nums){
        for(int i = 0; i< nums.length-1;i++){
            //控制一共比较多少轮
            int t = i;//获取当前轮数的最小值下标
            for(int k =i+1 ; k < nums.length ;k++){
                //每轮进行大小比较
                if (nums[t] > nums[k])  {
                    t = k;//记录最小下标
                }
            }
            if(t != i){
                int temp = nums[t];
                nums[t] = nums[i];
                nums[i] = temp;
            }
        }
        System.out.println(Arrays.toString(nums));
    }

}