Java常见算法整理

  • 兔子问题(斐波那契数列规律)
  • 台阶问题 (兔子问题变种,递归规律)
  • 素数问题(判断素数、质数方式)
  • 水仙花数问题(数字分解)
  • 查找算法(二分查找)
  • 排序算法(选择排序,冒泡排序,快速排序)

 

 

兔子问题,重点是找到规律

斐波那契数列 1、1、2、3、5、8、13、21、34、55

规律为:F(n)=F(n-1)+F(n-2)(n>2,n∈N*)

    public static void main(String[] args) {for (int i = 1; i <= 20; i++)
            System.out.println("第" + i + "个月:" + function(i));
    }

    private static int function(int x) {
        if (x == 1 || x == 2)
            return 1;
        else
            return function(x - 1) + function(x - 2);
    }

台阶问题:有n步台阶,一次只能上1步或2步,共有多少种走法?

规律为:F(n)=F(n-1)+F(n-2)

    public static void main(String[] args) {
        System.out.println(function(10));
    }

    private static int function(int n) {
        if (n <= 2) {
            return n;
        }
        return function(n - 1) + function(n - 2);

    }

 

 

判断素数(质数),重点是记住判断方式。

判断number是否是素数有这么几种方法:
(1)用2至number-1之间的所有数去整除number,如果有一个能被整除,说明number是非素数;除非所有的数都不能被整除,才说明number是素数.
(2)用2至number/2之间的所有数去整除number,如果有一个能被整除,说明number是非素数;除非所有的数都不能被整除,才说明number是素数.
(3)用2至number的平方根之间的所有数去整除number,如果有一个能被整除,说明number是非素数;除非所有的数都不能被整除,才说明number是素数.

    public static void main(String[] args) {
        for (int i = 1; i <= 200; i++) {
            if (function(i)) {
                System.out.println("素数:" + i);
            }
        }
    }

    private static boolean function(int x) {

        for (int i = 2; i <= x / 2; i++) {
            if (x % i == 0) {
                return false;
            }
        }
        return true;
    }

 

水仙花数,重点是分解百位、十位、个位。

public static void main(String[] args) {
        for (int i = 1; i <= 999; i++) {
            if (function(i)) {
                System.out.println("水仙花数:" + i);
            }
        }
    }

    private static boolean function(int x) {

        int i = 0, j = 0, k = 0;

        i = x / 100;

        j = (x % 100) / 10;

        k = x % 10;

        if (x == i * i * i + j * j * j + k * k * k)

            return true;

        else

            return false;
    }

 

查找算法(二分查找)

对于二分查找算法要求, 查找前的数据必须是已经排好序的, 然后得到数组的开始位置start和结束位置end, 取中间位置mid的数据a[mid]跟待查找数据key进行比较, 若 a[mid] > key, 则取end = mid - 1; 若 a[mid] < key, 则取start = mid + 1; 若 a[mid] = key 则直接返回当前mid为查找到的位置. 依次遍历直到找到数据或者最终没有该条数据.

    public static void main(String[] args) {

        int[] nums = new int[] { 1, 3, 5, 7, 9, 11, 13, 17 };

        System.out.println(function(nums, 5));
    }

    private static int function(int[] nums, int key) {

        int start = 0;
        int end = nums.length - 1;
        int mid = -1;
        while (start <= end) {
            mid = (start + end) / 2;
            if (nums[mid] == key) {
                return mid;// 已经查到返回!
            } else if (nums[mid] > key) {
                end = mid - 1;
            } else if (nums[mid] < key) {
                start = mid + 1;
            }
        }
        return -1;
    }

 

选择排序,冒泡排序,快速排序

public static void main(String[] args) {

        int[] nums = new int[] { 6, 3, 8, 2, 9, 1 };

        bubbleSort(nums);

        System.out.println("bubbleSort:" + Arrays.toString(nums));

        //

        nums = new int[] { 6, 3, 8, 2, 9, 1 };

        QuickSort(nums, 0, nums.length - 1);

        System.out.println("QuickSort:" + Arrays.toString(nums));
        
        //

        nums = new int[] { 6, 3, 8, 2, 9, 1 };

        ChoiceSort(nums);

        System.out.println("ChoiceSort:" + Arrays.toString(nums));

    }

    // 冒泡排序
    public static void bubbleSort(int[] a) {
        int len = a.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    swap(a, j + 1, j);
                }
            }
        }

    }

    // 快速排序
    public static void QuickSort(int a[], int low, int hight) {
        int i, j, index;
        if (low > hight) {
            return;
        }
        i = low;
        j = hight;
        index = a[i]; // 用子表的第一个记录做基准
        while (i < j) { // 从表的两端交替向中间扫描
            while (i < j && a[j] >= index)
                j--;
            if (i < j)
                a[i++] = a[j];// 用比基准小的记录替换低位记录
            while (i < j && a[i] < index)
                i++;
            if (i < j) // 用比基准大的记录替换高位记录
                a[j--] = a[i];
        }
        a[i] = index;// 将基准数值替换回 a[i]
        QuickSort(a, low, i - 1); // 对低子表进行递归排序
        QuickSort(a, i + 1, hight); // 对高子表进行递归排序

    }

    // 选择排序
    public static void ChoiceSort(int[] a) {
        for (int i = 0; i < a.length; i++) {
            int min = i;

            for (int j = i + 1; j < a.length; j++) {
                if (a[min] > a[j]) {
                    min = j;
                }
            }
            if (i != min) {
                int tmp = a[min];
                a[min] = a[i];
                a[i] = tmp;
            }
        }
    }

    // 交换元素
    private static void swap(int[] a, int i, int j) {
        int tmp;
        tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

 

posted on 2017-08-11 14:01  懂技术爱生活  阅读(1474)  评论(0编辑  收藏  举报

导航