常见算法

二分查找算法

public class Test {
    public static void main(String[] args) {
        int[] array=new int[]{1,2,3,4,5,6,7,10};
        int index=binarySearch(array,0,array.length-1,10);
        System.out.println("输出"+index);
    }

   public static int binarySearch(int[] array,int low,int high,int target){
        if (low>high) return -1;
        int mid=low+(high-low)/2;
        if (array[mid]==target) return mid;
        if (array[mid]>target) return binarySearch(array,low,mid-1,target);
        if (array[mid]<target) return binarySearch(array,mid+1,high,target);
        return -1;
   }
}

快速排序算法

public class Test {
    public static void main(String[] args) {
        int[] array=new int[]{5,3,8,6,4};
        quickSort(array,0,array.length-1);
    }

    public static int partition(int[] array,int left, int right){
        int pivokey=array[left];
        int i=left;
        int j=right;
        while (i<j){
            while (i<j&&array[j]>=pivokey) j--;
            while (i<j&&array[i]<=pivokey) i++;
            if (i<j){
                int temp=array[j];
                array[j]=array[i];
                array[i]=temp;
            }
        }
        array[left]=array[i];
        array[i]=pivokey;
        return i;
    }

    public static  void quickSort(int[] array,int left,int right){
        if (left>right) return;
        int position=partition(array,left,right);
        quickSort(array,left,position-1);
        quickSort(array,position+1,right);
    }
}

链表相关

class ListNode {
    public ListNode next;
    int val;

    public ListNode(int val) {
        this.val = val;
    }

    public ListNode getNext() {
        return next;
    }

    public void setNext(ListNode next) {
        this.next = next;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }
}

链表反转

   private static ListNode reverseLinkedList(ListNode head) {
        ListNode pre = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode tempNode = curr.next;
            curr.next = pre;
            pre = curr;
            curr = tempNode;
        }
        return pre;
    }

2个有序链表合并

    public static ListNode mergeList(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);
        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }
        prev.next = l1 == null ? l2 : l1;
        return prehead.next;
    }

树的按层遍历

 public static List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) return result;
        Queue<TreeNode> listQueue = new LinkedList<>();
        listQueue.offer(root);

        while (!listQueue.isEmpty()) {
            int levelNum = listQueue.size();
            List<Integer> currentLevel = new ArrayList<>();
            for (int i = 0; i < levelNum; i++) {
                TreeNode currentTreeNode = listQueue.poll();
                currentLevel.add(currentTreeNode.val);
                if (currentTreeNode.left != null)
                    listQueue.offer(currentTreeNode.left);

                if (currentTreeNode.right != null)
                    listQueue.offer(currentTreeNode.right);

            }
            result.add(currentLevel);
        }
        return result;
    }