JAVA算法学习初级与进阶

递归复杂度求解

数组求和的递归实现

package cn.algorithm;

public class Numsum {
    //递归实现数组求和
    public static void main(String[] args) {
        int arr[] = {1,4,3,2,4};
        int res= msum(arr,0,arr.length-1);
        System.out.println(res);
    }
    public static int msum(int arr[],int L, int R){
        if (L==R){
            return arr[L];
        }
        int mid = (L+R)/2;
        return msum(arr,L,mid)+msum(arr,mid+1,R);


    }


}

归并排序

归并排序实现

package cn.algorithm;



public class MergeSort {

    public static void main(String[] args) {
        int arr[] = {4,2,8,9,3,4,2,1};
        sortProcess(arr,0,arr.length-1);
        for (int x:
             arr) {
            System.out.printf(x+" ");
            
        }
    }
    
    
    public static void sortProcess(int arr[],int L,int R){
        if (L==R)
            return;

        int mid = L + ((R-L)>>1);
        sortProcess(arr,L,mid); //递归
        sortProcess(arr,mid+1,R);
        merge(arr,L,mid,R); //进行一次归并排序


    }
    public static void merge(int arr[],int L, int mid, int R){
        int [] help = new int[R-L+1];
        int i = 0;
        int p = L;
        int q = mid+1;
        while (p<=mid && q<=R){
            help[i++] = arr[p] < arr[q] ? arr[p++] : arr[q++]; //比较大小，填充
        }
        while (p<=mid){
            help[i++] = arr[p++];
        }

        while(q<=R){
            help[i++] = arr[q++];
        }

        for (i=0;i<help.length;i++){
            arr[L+i] = help[i];      //将每次排序好的数据复制给原数组
        }
    }



}

小和问题

在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和，求一个数组的小和

---

此处使用归并排序，在 merge 时，由于左右两部分都已经有序，可以确定一侧的数都大于正在比较的数，例如：

归并 2 4 5 | 1 3 7 两个部分时，2 比 3 小，此时可以确定后面的数都大于 2，此时便可以一次性计算小和 2 * 2(两个数大于 2)，而不用一个个遍历。

package cn.algorithm;



public class smallSum {

    public static void main(String[] args) {
        int arr[] = {4,2,8,9,3,4,2,1};
        int  res = sortProcess(arr,0,arr.length-1);
        System.out.println(res);
    }


    public static int  sortProcess(int arr[],int L,int R){
        if (L==R)
            return 0;

        int mid = L + ((R-L)>>1); //防止溢出，位操作，>> 1 除2
        return sortProcess(arr,L,mid) +sortProcess(arr,mid+1,R) + merge(arr,L,mid,R);
    }
    public static int merge(int arr[],int L, int mid, int R){
        int [] help = new int[R-L+1];
        int i = 0;
        int p = L;
        int q = mid+1;
        int res = 0;
        while (p<=mid && q<=R){
            res  += arr[p] < arr[q] ? (R - q + 1)*arr[p] : 0; //计算每个数的小和
            help[i++] = arr[p] < arr[q] ? arr[p++] : arr[q++];
        }
        while (p<=mid){
            help[i++] = arr[p++];
        }

        while(q<=R){
            help[i++] = arr[q++];
        }

        for (i=0;i<help.length;i++){
            arr[L+i] = help[i];
        }

        return res;
    }



}

逆序对问题

在一个数组中，左边的数如果比右边的数大，则折成两个数构成逆序对，请打印所有逆序个数。（和小和问题一样解决）

package cn.algorithm;

public class InverseSort {

    public static void main(String[] args) {
        int num [] = {1,5,3,6};
        int res = sortProcess(num,0,num.length-1);
        System.out.println(res);
    }


    public static int  sortProcess(int arr[],int L,int R){
        if (L==R)
            return 0;

        int mid = L + ((R-L)>>1);
        return sortProcess(arr,L,mid) +sortProcess(arr,mid+1,R) + merge(arr,L,mid,R);
    }
    public static int merge(int arr[],int L, int mid, int R){
        int [] help = new int[R-L+1];
        int i = 0;
        int p = L;
        int q = mid+1;
        int res = 0;
        while (p<=mid && q<=R){
            res  += arr[p] > arr[q] ? (R - q + 1) : 0;
            help[i++] = arr[p] > arr[q] ? arr[p++] : arr[q++];
        }
        while (p<=mid){
            help[i++] = arr[p++];
        }

        while(q<=R){
            help[i++] = arr[q++];
        }

        for (i=0;i<help.length;i++){
            arr[L+i] = help[i];
        }

        return res;
    }



}

快速排序

荷兰国旗问题：

给定一个数组arr,和一个数num,请把小于num的数放在左边，大于num的数放在右边，等于num的数放在中间

要求时间复杂度为O(N),空间复杂度为O(1)

package cn.algorithm;

public class NeitherlandsFlg {

    public static void main(String[] args) {
        int arr[]= {5,4,3,5,9,1,5,6,7,2};
        partition(arr,0,arr.length-1,5);
        for (int i:
             arr) {
            System.out.printf(i+" ");

        }
    }
    public static void partition(int arr[],int L, int R, int num){
        int left = L-1;
        int more = R+1;
        while (L< more){
            if (arr[L] < num){
                swap(arr,L++,++left);
            }
            else if (arr[L] > num){
                swap(arr,L,--more);
            }
            else {
                L++;
            }
        }


    }

    public static void swap(int arr[], int i, int j){
        int temp = arr[i];
        arr[i]  = arr[j];
        arr[j] = temp;
    }


}

快速排序实现

时间复杂度O(N*logN),最差O(N^2),空间复杂度O(logN)

package cn.algorithm;

//递归实现
public class QuickSort {
    public static void main(String[] args) {
        int nums[] = {3,9,1,5,2,7,5,10,0};
        QuickSort quickSort = new QuickSort();
        quickSort.quickSort(nums);
        for (int num:nums
        ) {
            System.out.printf(num+" ");
        }
    }

    public void quickSort(int nums[]){
        if(nums == null || nums.length==0)return;
        qSort(nums,0,nums.length-1);
    }

    public void qSort(int nums[],int low,int high){
        if(low>=high)return;
        while (low<high){
            int privot = partition(nums,low,high);
            qSort(nums,0,privot-1);
            low = privot+1;
        }
    }

    public int partition(int nums[],int low,int high){
        int privotValue = nums[low];
        while (low<high){
            while (low<high && nums[high]>=privotValue)high--;
            swap(nums,low,high);
            while (low<high && nums[low]<=privotValue)low++;
            swap(nums,low,high);
        }
        return low;
    }

    public void swap(int nums[],int i,int j){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

package cn.algorithm;

import java.util.Stack;
//非递归实现
public class QuickSort2 {
    public static void main(String[] args) {
        int nums[] = {3,6,1,8,3,9,2,7,4,0};
        QuickSort quickSort = new QuickSort();
        quickSort.quickSort(nums);
        for (int num:nums
             ) {
            System.out.printf(num+" ");
        }
    }

    void quickSort(int nums[]){
        if(nums==null || nums.length==0)return;
        qSort(nums,0,nums.length-1);
    }
    void qSort(int nums[],int low,int high){
        if(low>=high)return;
        Stack<Integer> stack = new Stack<>();
        stack.push(low);
        stack.push(high);
        while(low<high){
            high = stack.pop();
            low = stack.pop();
            int privot = partition(nums,low,high);
            stack.push(low);
            stack.push(privot-1);
            stack.push(privot+1);
            stack.push(high);
        }
    }

    int partition(int nums[],int low,int high){
        int privot = nums[low];
        while(low<high){
            while (low<high && nums[high]>=privot)high--;
            swap(nums,low,high);
            while (low<high && nums[low]<=privot)low++;
            swap(nums,low,high);
        }
        return low;
    }
    void swap(int nums[],int i,int j){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = nums[i];
    }

}

堆排序

时间复杂度O(N*logN) ,额外空间复杂度O(1)

package cn.algorithm;

public class Heapsort {

    public static void main(String[] args) {
        int arr[]= {5,4,3,5,9,1,5,6,7,2};
        heapsort(arr);
        for (int num:
             arr) {
            System.out.printf(num + " ");

        }
    }

    public static void heapsort(int arr[]){

        if (arr == null || arr.length<2)
            return;
        // 建立大根堆
        for (int i=0;i<arr.length;i++){
            heapinsert(arr,i);
        }

        //堆排序
        int heapsize = arr.length;
        swap(arr,0,--heapsize);
        while (heapsize>0){
            heapify(arr,0,heapsize);
            swap(arr,0,--heapsize);
        }

    }
    //建立大根堆
    public static void heapinsert(int arr[], int index){
        while (arr[index] > arr[(index-1)/2]){
            swap(arr,index,(index-1)/2);
            index = (index-1)/2;
        }
    }
    // 排最大值
    public static void heapify(int arr[],int index, int heapsize){
        int left = index*2 + 1;
        while (left<heapsize){
            int largest = (left+1) < heapsize && arr[left+1] > arr[left] ? left+1 : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if (largest == index)
                break;
            swap(arr,largest,index);
            index = largest;
            left = largest*2+1;
        }
    }
    public static void swap(int arr[], int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

相邻最大差值：

给定一个数组，求如果排序之后，相邻两个数的最大差值，要求时间复杂度为O(N),且要求不能用非基于比较的的排序。

package cn.algorithm;
/*
1.找出最大值，最小值
2.定义N+1个桶，每个桶有最大值 最小值 与有无数据布尔值
3.每个数插入对应桶 并更新最大值 最小值 与有无数据布尔值
4.非空桶最小值减去最近前非空桶最大值
即为排序后的最大值
 */

public class MaxDiffer {

    public static void main(String[] args) {
        int arr[] = {4,2,8,9,3,4,2,1};
        int res = maxdiff(arr);
        System.out.println(res);
    }

    public static int maxdiff(int []arr){
        if (arr==null || arr.length<2)
            return 0;
        int len = arr.length;
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int i=0;i<len;i++){
            min = Math.min(min,arr[i]);
            max = Math.max(max,arr[i]);
        }
        if (min==max)
            return 0;
        boolean []hasnum = new boolean[len+1];
        int [] mins = new int[len+1];
        int [] maxs = new int[len+1];
        int bid = 0;
        for (int i=0;i<len;i++){
            bid = buket(arr[i],len,min,max);
            mins[bid] = hasnum[bid] ? Math.min(arr[i],mins[bid]) : arr[i];
            maxs[bid] = hasnum[bid] ? Math.max(arr[i],maxs[bid]) : arr[i];
            hasnum[bid] = true;
        }

        int res = 0;
        int lastmax = maxs[0];
        int i=1;
        for (;i<=len;i++){
            if (hasnum[i]){
                res = Math.max(res,mins[i]-lastmax);
                lastmax = maxs[i];
            }
        }
        return res;

    }
    public static int buket(int num,int len,int min,int max){
        return (int)((num-min)*len/(max-min));

    }
}

用数组结构实现大小固定的栈和队列

package cn.structure;

import org.w3c.dom.css.CSSImportRule;

public class stackqueue {
    public static void main(String[] args) {
        Arraystack arraystack = new Arraystack(5);
        arraystack.push(5);
        System.out.println(arraystack.pop());

    }

}

class Arraystack{
    private  Integer[] arr;
    private  Integer index;
    public Arraystack(int initsize){
        if (initsize<0){
            throw new IllegalArgumentException("The init siza is less than 0");
        }
        arr = new Integer[initsize];
        index = 0;
    }
    public Integer peek(){
        if (index==0) {
            return null;
        }
        return arr[index-1];
    }


    public void push(int obj){
        if (index==arr.length){
            throw new ArrayIndexOutOfBoundsException("The stack is full");
        }
        arr[index++] = obj;
    }

    public Integer pop(){
        if (index ==0 ){
            throw new ArrayIndexOutOfBoundsException("The stack is empty");
        }
        return arr[--index];
    }

        }

class ArrayQueue{
    private Integer [] arr;
    private Integer start;
    private Integer end;
    private Integer size;
    public ArrayQueue(int initsize){
        if (initsize<0){
            throw new IllegalArgumentException("The init size is less than 0");
        }
        arr = new Integer[initsize];
        start = 0;
        end = 0;
        size = 0;
    }

    public Integer peek(){
        if (size==0){
            throw new ArrayIndexOutOfBoundsException("The stack is empty");
        }
        return arr[start];
    }

    public void push(Integer obj){
        if (size == arr.length){
            throw new ArrayIndexOutOfBoundsException("The queue is full")
        }
        arr[end] = obj;
        end = nextindex(arr.length,end);
        size++;
    }

    public Integer poll(){
        if (size==0){
            throw new ArrayIndexOutOfBoundsException("The stack is empty");
        }
        size--;
        int tmp = start;
        start = nextindex(arr.length,start);
        return arr[tmp];
    }

    public Integer nextindex(int size, int index){
        return  index==size-1 ? 0:index+1;
    }


}

---

实现一个特殊的栈，要求实现栈的基本功能的基础上，再能实现返回栈中最小的元素。

要求：

pop,push，getMin操作的时间复杂度可以是O(1).

可以使用现成的栈类型结构

---

package cn.structure;
/*
1、建立一个最小值栈
2、stackData加数据和出数据时，保持stackMin同步压入 压出，（压入value比stackMin小，直接压入stackMin,比stackMin大，压入stackMin和stackMin当前相同最小值）
3.stackData,stackMin同时pop
 */
import java.util.Stack;

public class minstack {
    private Stack<Integer> stackData;
    private Stack<Integer> stackMin;
    public minstack(){
        stackData = new Stack<Integer>();
        stackMin = new Stack<Integer>();
    }
    public void push(int obj){
        if (this.stackMin.isEmpty()){
            this.stackMin.push(obj);
        }else if (obj < this.stackMin.peek()){
            this.stackMin.push(obj);
        }else {
            int getmin = this.stackMin.peek();
            this.stackMin.push(getmin);
        }
        this.stackData.push(obj);
    }

    public int pop(){
        if (this.stackData.isEmpty()){
            throw new RuntimeException("the stackdata is empty");
        }
        this.stackMin.pop();
        return this.stackData.pop();
    }

    public int getMin(){
        if (this.stackMin.isEmpty()){
            throw new RuntimeException("this stackmin is empty");
        }
        return this.stackMin.peek();
    }

}

package cn.structure;

import java.util.Stack;
/*
1、建立一个最小值栈
2、stackData加数据和出数据时，保持stackMin同步压入 压出，（压入value比stackMin小，直接压入stackMin,比stackMin大，压入stackMin和stackMin当前相同最小值）
3.stackData,stackMin同时pop
)下面简化版本
压入value比stackMin当前大，就不压入，节省空间
 */
public class minstack {
    private Stack<Integer> stackData;
    private Stack<Integer> stackMin;
    public minstack(){
        stackData = new Stack<Integer>();
        stackMin = new Stack<Integer>();
    }
    public void push(int obj){
        if (this.stackMin.isEmpty()){
            this.stackMin.push(obj);
        }
        else if (obj < this.stackMin.peek()){
            this.stackMin.push(obj);
        }
        this.stackData.push(obj);

    }

    public int pop(){
        if (this.stackData.isEmpty()){
            throw new RuntimeException("the stackdata is empty");
        }
        if (this.stackMin.peek()==this.stackData.peek()){
            this.stackMin.pop();
        }
        return this.stackData.pop();

    }

    public int getMin(){
        if (this.stackMin.isEmpty()){
            throw new RuntimeException("this stackmin is empty");
        }
        return this.stackMin.peek();
    }

}

---

如何仅使用栈结构实现队列

如何仅使用队列结构实现栈（应用：使用队列实现图的深度优先遍历）

---

package cn.structure;

import java.util.LinkedList;
import java.util.Queue;

/*
两个队列实现栈结构
 */
public class twoqueuestack {

    private Queue<Integer> queue;
    private Queue<Integer> help;
    public twoqueuestack(){
        queue = new LinkedList<Integer>();
        help =  new LinkedList<Integer>();
    }

    public void push(int obj){
        queue.add(obj);
    }
    public int peek(){
        if (queue.isEmpty()){
            throw new RuntimeException("the queue is empty");
        }

        while (queue.size()>1){
            help.add(queue.poll());
        }
        int res = queue.poll();
        help.add(res);
        swap();
        return res;
    }
    public int poll(){
        if (queue.isEmpty()){
            throw new RuntimeException("the queue is empty");
        }

        while (queue.size()>1){
            help.add(queue.poll());
        }
        int res = queue.poll();
        swap();
        return res;
    }

    public void swap(){
        Queue<Integer> tmp = queue;
        queue = help;
        help = queue;
    }
}

package cn.structure;

import java.util.Stack;
/*
两原则：
1.stackPop为空时，stackPush栈才能往stackPop导数据
2.stackPush往stackPop导数据，导全部数据
 */
public class twostackqueue {
    private Stack<Integer> stackPush;
    private Stack<Integer> stackPop;

    public twostackqueue(){
        stackPop = new Stack<Integer>();
        stackPush = new Stack<Integer>();
    }

    public void push(int obj){
        stackPush.push(obj);
    }
    public int poll(){
        if (stackPop.isEmpty()&&stackPush.isEmpty()){
            throw new RuntimeException("the queue is empty");
        }
        if (stackPop.isEmpty()){
            while (!stackPush.isEmpty()){
                stackPop.push(stackPush.pop());
            }

        }
        int res = stackPop.pop();
        return res;
    }

    public int peek(){
        if (stackPush.empty() && stackPop.empty()){
            throw new RuntimeException("the queue is empty");
        }
        return stackPop.peek();

    }

}

队列的最大值

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

class MaxQueue {
    Queue<Integer> q;
    Deque<Integer> d;
    
    public MaxQueue() {
        q = new LinkedList<>();
        d = new LinkedList<>();
    }
    
    public int max_value() {
        if(q.isEmpty()){
            return -1;
        }
        return d.peekFirst();
        
    }

    //和滑动窗口类似
    public void push_back(int value) {
        while(!d.isEmpty() && d.peekLast()<value){
            d.pollLast();
        }
        d.addLast(value);
        q.add(value);  
    }
    
    public int pop_front() {
        if(q.isEmpty()){
            return -1;
        }
        int ans = q.poll();
        if(ans == d.peekFirst()){
            d.pollFirst();
        }
        return ans;
        
    }
}

哈希表

package cn.structure;

import java.util.HashMap;

/*
题目：
设计一种结构，在该结构中有如下三种功能
insert(key):将某个key 加入该结构中，做到不重复加入
delete(key): 将原本在结构中得某个key移除
getRandom():等概率得返回结构中得任何一个key
要求：
insert,delete,getRandom方法的时间复杂度为O(1)
 */
public class RandomPool {
    private    HashMap<String,Integer> map1 = new HashMap<>();
    private    HashMap<Integer,String> map2 = new HashMap<>();
    private int size=0;

    public void insert(String str){
        if (!map1.containsKey(str)){
            map1.put(str,size);
            map2.put(size++,str);
        }
    }
    public void delete(String str){
        if (map1.containsKey(str)){
            int delindex = map1.get(str);
            int lastindex = map1.size()-1;
            String ss = map2.get(lastindex);
            map1.put(ss,delindex);
            map2.put(delindex,ss);
            map1.remove(str);
            map2.remove(lastindex);
            size--;
        }
    }
    public String getRandom(){
        int num = map1.size();
        if (num==0){
            return null;
        }
        return map2.get((int)(Math.random()*size));
    }
  
}

链表

public class LinkList {
    //添加节点
    public void insertList(ListNode head, int value){
        ListNode listNode = new ListNode(value);
        if (head == null){
            head = listNode;
        }else {
            ListNode p = head;
            while (p.next!=null){
                p = p.next;
            }
            p.next = listNode;
        }
    }
    //删除节点
    public void deleteList(ListNode head, int value){
        if (head==null)return;
        if (head.val == value){
            head = head.next;
        }else {
            ListNode p = head;
            while (p.next != null && p.val != value){
                p = p.next;
            }
            if (p.next!=null) {
                p.next = p.next.next;
            }
        }

    }
    //从尾到头打印链表
    public void printList(ListNode head){
        Stack<ListNode> stack = new Stack<>();
        ListNode p = head;
        while (p!=null){
            stack.push(p);
            p = p.next;
        }
        while (!stack.isEmpty()){
            p = stack.pop();
            System.out.printf(p.val+" ");
        }
    }

    //反转链表
    public void reverseList(ListNode head){
        ListNode newhead = null;
        ListNode node;

        while (head!=null){
            //先做头删
            node = head;
            head =head.next;

            //新链表做头插
            node.next = newhead;
            newhead= node;
        }
    }

}

二叉树

class BinaryTreeNode{
    int val;
    BinaryTreeNode left;
    BinaryTreeNode right;
    public BinaryTreeNode(int val){
        this.val = val;
    }
}


public class BinaryTree {
    //前序 递归
    public void preOrderRec(BinaryTreeNode head){
        if (head==null){
            return;
        }
        System.out.printf(head.val+" ");
        preOrderRec(head.left);
        preOrderRec(head.right);

    }



    //中序 递归
    public void inOrderRec(BinaryTreeNode head){
        if (head==null){
            return;
        }
        inOrderRec(head.left);
        System.out.printf(head.val+" ");
        inOrderRec(head.right);
    }

    //后序 递归
    public void posOrderRec(BinaryTreeNode head){
        if (head==null){return;}
        posOrderRec(head.left);
        posOrderRec(head.right);
        System.out.printf(head.val+" ");
    }

    public void preOrderUn(BinaryTreeNode head){
        if (head == null){
            return;
        }
        Stack<BinaryTreeNode> stack = new Stack<>();
        stack.push(head);
        while (!stack.isEmpty()){
            head = stack.pop();

            System.out.printf(head.val+" ");
            if (head.right!=null){
                stack.push(head.right);
            }
            if (head.left!=null){
                stack.push(head.left);
            }
        }
    }


    // 中序 非递归
    //
    public void inOrderUn(BinaryTreeNode head){
        if (head == null){
            return;
        }
        Stack<BinaryTreeNode> stack = new Stack<>();

        while (!stack.isEmpty() || head!=null){
            if (head!=null){
                stack.push(head);
                head = head.left;
            }else {
                head = stack.pop();
                System.out.printf(head.val+" ");
                head = head.right;

            }


        }


    }
    //非递归 后序
    // 1） 弹，固定cur
    // 2) cur放入收栈
    // 3）先压左节点，再压右节点

    public void posOrderUn(BinaryTreeNode head){
        if (head==null){
            return;
        }
        Stack<BinaryTreeNode> stack1 = new Stack<>();
        Stack<BinaryTreeNode> stack2 = new Stack<>();
        stack1.push(head);
        while (!stack1.isEmpty()){
            head = stack1.pop();
            stack2.push(head);
            if (head.left!=null){
                stack1.push(head.left);
            }
            if (head.right!=null){
                stack1.push(head.right);
            }

        }
        while (!stack2.isEmpty()){
            head = stack2.pop();
            System.out.printf(head.val+" ");
        }
    }

}

平衡二叉树

/*输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
*/
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        if(root==null)return true;

        return Math.abs(depth(root.left)-depth(root.right))<=1 && isBalanced(root.left) && isBalanced(root.right); 

    }

    public int depth(TreeNode root){
        if(root==null)return 0;
        return Math.max(depth(root.left),depth(root.right))+1;
    }
}

Double类型不能用==判断是否相等

boolean Equal(double num1, double num2){
    if((num1-num2 >-0.0000001) && (num1-num2 < 0.0000001)){
        return true;
    }
    else{
        return false;
    }
}

字符全部子序列

子序列可以删除元素也可以不删除元素，但顺序不变

package alorithm;

import java.util.ArrayList;
import java.util.List;

public class StringProcess {
    public List<String> subs(String s){
        char[] str = s.toCharArray();
        String path = "";
        List<String> ans = new ArrayList<>();
        process(str,0,ans,path);
        return ans;
    }

    public void process(char [] str, int index, List<String> ans, String path){
        if(index == str.length){
            ans.add(path); //如果index来到str终止位置，把沿途路径形成一个答案，放到ans中
            return;
        }
        String no= path;
        //index 此时来到的位置，要 or 不要

        //不添加
        process(str,index+1,ans,no);
        String yes = path+String.valueOf(str[index]);
        //添加
        process(str,index+1,ans,yes);
    }
}

字符全部子序列,去掉重复的子序列

package alorithm;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

public class StringProcess {
    public List<String> subs(String s){
        char[] str = s.toCharArray();
        String path = "";
        HashSet<String> set = new HashSet<>();
        List<String> ans = new ArrayList<>();
        process(str,0,set,path);
        for(String cur : set){
            ans.add(cur);
        }
        return ans;
    }

    public void process(char [] str, int index, HashSet<String> set, String path){
        if(index == str.length){
            set.add(path); //如果index来到str终止位置，把沿途路径形成一个答案，放到ans中
            return;
        }
        String no= path;
        //index 此时来到的位置，要 or 不要

        //不添加
        process(str,index+1,set,no);
        String yes = path+String.valueOf(str[index]);
        //添加
        process(str,index+1,set,yes);
    }
}

字符串全排列，去除重复排列

class Solution {
    List<String> ans = new LinkedList<>();
    char [] str;
    public String[] permutation(String s) {
        str = s.toCharArray();

        dfs(0);
        return ans.toArray(new String[ans.size()]);
    }
     //str[0...i-1]已经做好决定的
    //str[i...]都有机会来到i位置
    void dfs(int x){
        if(x == str.length-1){
            ans.add(String.valueOf(str));
        }
        HashSet<Character> set = new HashSet<>();
        for(int i=x;i<str.length;i++){
            if(set.contains(str[i]))continue; //重复数字交换还是一样的，剪枝
            set.add(str[i]);
            swap(str,x,i);
            dfs(x+1);
            swap(str,x,i);//恢复现场， 一步一步的退回去，回溯
        }
    }
    void swap(char [] str,int i,int j){
        char tmp = str[i];
        str[i] = str[j];
        str[j] = tmp;
    }
}

最长不含重复字符的子字符串

class Solution {
    public int lengthOfLongestSubstring(String s) {
        //动态规划
        Map<Character,Integer> map = new HashMap<>();
        int res = 0;
        int tmp = 0;
        for(int i=0;i<s.length();i++){
            int n = map.getOrDefault(s.charAt(i),-1);
            map.put(s.charAt(i),i);
            tmp = tmp<i-n ? tmp+1 : i-n;
            res = Math.max(res,tmp);
        }
        return res;

    }
}

手写死锁

两个线程各自持一把锁，然后申请对方持有的锁

package com;

public class DeadLock {

    //创建资源
    private static Object resourceA = new Object();
    private static Object resourceB = new Object();

    public static void main(String[] args) {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceA) {
                    System.out.println(Thread.currentThread() + "获得A");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread()+"等待B");
                    synchronized (resourceB) {
                        System.out.println(Thread.currentThread()+"获得B");
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceB) {
                    System.out.println(Thread.currentThread() + "获得B");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread()+"等待A");
                    synchronized (resourceA) {
                        System.out.println(Thread.currentThread()+"获得A");
                    }
                }
            }
        });

        threadA.start();
        threadB.start();
    }
}

生产者消费者模式

package com;


import cn.algorithm.ThreadPool;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

import static java.lang.Thread.sleep;


public class ProducerAndConsumer {
    public static void main(String[] args) {
        MessageQueue messageQueue = new MessageQueue(2);



        for (int i=0;i<3;i++){
            int id = i;
            new Thread(()->{
                try {
                    messageQueue.put(new Message(id,"值"+id));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"生产者"+i).start();
        }

        new Thread(()->{
            try {
                while (true){
                    sleep(1);
                    Message message =  messageQueue.take();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"消费者").start();
    }

}

class MessageQueue{
    private LinkedList<Message> list = new LinkedList<>();
    private int capacity;
    public MessageQueue(int capacity){
        this.capacity = capacity;
    }

    public Message take() throws InterruptedException {
        //检查队列是否为空
        synchronized (list) {
            while (list.isEmpty()) {
                System.out.println("队列为空，消费者线程等待");
                list.wait();
            }
            Message message = list.removeFirst();
            System.out.println("已消费消息"+message);
            list.notifyAll();
            return message;
        }
    }

    public void put(Message message) throws InterruptedException {

        //检查队列是否已满
        synchronized (list){
            while (list.size()==capacity){
                System.out.println("队列已满，生产者线程等待");
                list.wait();
            }
            list.addLast(message);
            System.out.println("已生产消息"+message);
            list.notifyAll();
        }

    }
}


final class Message{
    private int id;
    private Object value;

    public Message(int id, Object value) {
        this.id = id;
        this.value = value;
    }

    public int getId() {
        return id;
    }

    public Object getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", value=" + value +
                '}';
    }
}

手写线程池提交任务

package cn.algorithm;

import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class ThreadPool {
    public static void main(String[] args) {
        String [] s = new String[1];
        ExecutorService service = Executors.newFixedThreadPool(10);
        Random r = new Random();
        service.submit(()->{
            for(int i=0;i<=100;i++){
                try {
                    Thread.sleep(r.nextInt(100));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                s[0] = i+"%";
                System.out.print("\r"+Arrays.toString(s));
            }
        });
    }
}

多线程交替打印输出

package cn.algorithm;

public class OneByOne {
    public static void main(String[] args) {
        WaitNotify wn = new WaitNotify(1,5);
        new Thread(()->{
            try {
                wn.print("a",1,2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            try {
                wn.print("b",2,3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                wn.print("c",3,1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

    }
}

class WaitNotify{

    //打印输出
    public void print(String str,int waitFlag,int nextFlag) throws InterruptedException {
        for(int i=0;i<loopNumber;i++) {
            synchronized (this) {
                while (flag != waitFlag) {
                    this.wait();
                }
                System.out.printf(str);
                flag = nextFlag;
                this.notifyAll();
            }
        }
    }

    private int flag;
    private int loopNumber;

    public WaitNotify(int flag, int loopNumber) {
        this.flag = flag;
        this.loopNumber = loopNumber;
    }

    @Override
    public String toString() {
        return "WaitNotify{" +
                "flag=" + flag +
                ", loopNumber=" + loopNumber +
                '}';
    }
}