常见的算法题

冒泡排序

private static int[] queryArr(int[] arr1) {

int len = arr1.length;

if (len == 0 || len == 1){

return arr1;

}

        for (int i = 0; i < len; i++) {

            for (int j = 0,lenArr = len - 1 - i; j < lenArr; j++) {

                if (arr1[j + 1] < arr1[j]){

                int b = arr1[j + 1];

                arr1[j + 1] = arr1[j];

                arr1[j] = b;

            }

        }

    }

    return arr1;

}

插入排序

public static void insertionSort(int[] arr) {

    for (int i = 1; i < arr.length; i++) {

        int current = arr[i];

        int j = i - 1;

        // 将当前元素与已排序序列的元素进行比较，如果当前元素较小，则将已排序序列的元素向后移动

        while (j >= 0 && arr[j] > current) {

            arr[j + 1] = arr[j];

            j--;

        }

        // 将当前元素插入到正确的位置

        arr[j + 1] = current;

    }

}

二分查找

private static int getArrIndex(int[] arr, int key) {

        int low = 0;

        int high = arr.length - 1;

        int middle = 0;

        if (key < arr[low] || key > arr[high] || low > high){

            return -1;

        }

        while (low <= high){

            middle = (low + high) / 2;

            if (arr[middle] > key){

                high = middle - 1;

            }else if (arr[middle] < key){

                low = middle + 1;

            }else {

                return middle;

            }

        }

        return -1;

    }

链表反转

/**

 * 节点类

 */

public class Node {

    public final int data; // 数据域

    public Node next; // 引用域

    public Node(int data) {

        this.data = data;

        this.next = null; // 引用类型，默认null

    }

    public Node getNext() {

        return next;

    }

    public void setNext(Node next) {

        this.next = next;

    }

}

//测试类

public static Node head;

    public static void main(String[] args) {

        //创建链表

        Node node1 = new Node(13);

        Node node2 = new Node(2);

        Node node3 = new Node(5);

        node1.next = node2;

        node2.next = node3;

        head = node1;

        // 链表创建后, 打印链表

        printLinkList(head);

        System.out.printf("开始反转链表");

        Node reverserNode = reverserLinkedList(head);

        //打印反转的

        printLinkList(reverserNode);

    }

    // 打印链表

    public static void printLinkList(Node node) {

        System.out.println("开始打印head");

        while (node != null) {

            System.out.println(node.data + "");

            node = node.next;

        }

    }

    /**

     * 递归反转链表

     * 这个递归,返回值只是为了控制返回的是最后一个节点

     * 然后通过递归, 通过栈的特性, 这里就是让它可以从最后一个节点开始把自己的子节点的子节点改成自己

     * 自己子节点改成null

     * @param node

     * @return

     */

    public static Node reverserLinkedList(Node node) {

        if (node == null || node.getNext() == null) {

            return node;

        }

        Node nextNode = reverserLinkedList(node.getNext());

        node.getNext().setNext(node);

        node.setNext(null);

        return nextNode;

}

青蛙跳台阶

public static int numWays(int n) {

        if (n <= 1) {

            return 1;

        }

        // dp[i] 表示跳到第 i 个台阶的方法数

        int[] dp = new int[n + 1];

        dp[0] = 1; // 第0个台阶只有1种跳法

        dp[1] = 1; // 第1个台阶也只有1种跳法

        for (int i = 2; i <= n; i++) {

            // 从第i-1个台阶跳1个台阶或者从第i-2个台阶跳2个台阶到达第i个台阶

            dp[i] = dp[i - 1] + dp[i - 2];

       }

     return dp[n];

}