java用数组实现一个顺序栈
代码如下：
package stack;

public class ArrayStack {

    private String[] data;
    private int count;
    private int size;

    public ArrayStack(int n) {
        this.data = new String[n];
        this.count = 0;
        this.size = n;
    }
    
    public boolean push(String value) {
        if (count == size) {
            return false;
        } else {
            data[count] = value;
            count++;
            return true;
        }
    }

    public String pop() {
        if (count == 0) {
            return null;
        } else {
            count--;
            return data[count];
        }
    }
}

1. 编程实现斐波那契数列求值 f(n)=f(n-1)+f(n-2）
public class Fibonacci {
    public static int fib(int n) {
        if (n <= 0) {
            return 0;
        }
        if (n == 1) {
            return 1;
        }

        return fib(n-1) + fib(n-2);
    }
}

2. Climbing Stairs（爬楼梯）
public class ClimbStairs {
    public int climbFloor(int n) {
        if (n == 1 || n == 2) {
            return n;
        }

        return climbFloor(n - 1) + climbFloor(n - 2);
    }

    public int climbFloorIter(int n) {
        if (n == 1 || n == 2) {
            return n;
        }

        int jump1 = 1;
        int jump2 = 2;
        int jumpN = 0;

        for (int i = 3; i <= n; i++) {
            jumpN = jump1 + jump2;

            jump1 = jump2;
            jump2 = jumpN;
        }

        return jumpN;
    }
}

3. Sliding Window Maximum（滑动窗口最大值)
import java.util.ArrayList;
import java.util.LinkedList;

public class MaxNumOfSlidingWindow {
    public ArrayList<Integer> maxInWindows(int [] num, int size)
    {
        ArrayList<Integer> res = new ArrayList<>();

        if (num == null || num.length <= 0 || size <= 0 || size > num.length) {
            return res;
        }

        LinkedList<Integer> qMax = new LinkedList<>(); // 双端队列：左端更新max,右端添加数据

        int left = 0;

        for (int right = 0; right < num.length; right++) {
            // 更新右端数据
            while (!qMax.isEmpty() && num[qMax.peekLast()] <= num[right]) {
                qMax.pollLast();
            }

            qMax.addLast(right);

            // 更新max：如果max的索引不在窗口内,则更新
            if (qMax.peekFirst() == right - size) {
                qMax.pollFirst();
            }

            // 待窗口达到size，输出max
            if (right >= size-1) {
                res.add(num[qMax.peekFirst()]);
                left++;
            }
        }

        return res;
    }
}

java用链表实现一个链式栈
代码如下：
package stack;

public class LinkedStack {
    
    private Node top = null;
    
    public static class Node {
        
        private String data;
        private Node next;
        
        public Node(String data, Node next) {
            this.data = data;
            this.next = next;
        }
        
        public String getData() {
            return data;
        }
    }
    
    public void push(String item) {
        Node newNode = new Node(item, null);
        if (top == null) {
            top = newNode;
        } else {
            newNode.next = top;
            top = newNode;
        }
    }
    
    public String pop() {
        if (top == null) {
            return null;
        }
        String value = top.data;
        top = top.next;
        return value;
    }
    
    public void printAll() {
        Node pNode = top;
        while (pNode != null) {
            System.out.print(pNode.data + " ");
            pNode = pNode.next;
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        LinkedStack linkedStack = new LinkedStack();
        linkedStack.push("haha");
        linkedStack.push("nihao");
        linkedStack.printAll();
    }
}

java用递归实现斐波那契数列
代码如下：
package recursion;

public class Fib {

    public long calFib(long n) {
        if (n == 0 || n == 1) {
            return 1;
        } else {
            return calFib(n - 1) + calFib(n - 2);
        }
    }
    
    public static void main(String[] args) {
        Fib fib = new Fib();
        long result = fib.calFib(5);
        System.out.println(result);
    }
}

java用递归实现求解n!
代码如下：
package recursion;

public class Fac {

    public long calFac(long n) {
        if (n == 0) {
            return 1;
        }
        return calFac(n - 1) * n;
    }

    public static void main(String[] args) {
        Fac fac = new Fac();
        long result = fac.calFac(10);
        System.out.println(result);
    }
}

java用数组实现一个顺序队列
代码如下：
package queue;

public class ArrayQueue {
    
    private String[] data;
    private int size;
    private int head;
    private int tail;
    
    public ArrayQueue(int capacity) {
        data = new String[capacity];
        size = capacity;
        head = 0;
        tail = 0;
    }
    
    public boolean enqueue(String value) {
        if (tail == size) {
            return false;
        }
        data[tail] = value;
        tail++;
        return true;
    }

    public String dequeue() {
        if (tail == 0) {
            return null;
        }
        String value = data[head];
        head++;
        return value;
    }
}

import java.util.Arrays;

/**
 *
 *Stack 1 solution
 */
public class StackArray {

    public Object[] arr = new Object[10];
    public int count;

    public void push(Object ele) {
        if (count == arr.length) { // expand size
            arr = Arrays.copyOf(arr, arr.length * 2);
        }
        arr[count] = ele;
        count++;
    }

    public Object pop() {
        if (count == 0)
            return null;
        if (count < arr.length / 2) {
            arr = Arrays.copyOf(arr, arr.length / 2);
        }
        return arr[--count];

    }
}

/**
 *
 *Stack 2 solution
 */
class StackLinked {
    Node head;
    Node tail;

    public void push(Object ele) {

        if (head == null) {
            head = new Node(ele);
            tail = head;
        } else {
            Node node = new Node(ele);
            tail.next = node;
            node.prev = tail;
            tail = node;
        }
    }

    public Object pop() {
        if (tail == null)
            return null;
        Node node = tail;
        if (tail == head) {
            head = null;
            tail = null;
        } else
            tail = tail.prev;
        return node;

    }
}
class Node {
    Node prev;
    Node next;
    Object value;

    public Node(Object ele) {
        value = ele;
    }
}

用数组实现一个顺序队列
/**
 * @author hepei
 * @date 2020/1/3 17:12
 **/
public class ArrayQueue {

    private int[] data;
    private int head;
    private int tail;

    public ArrayQueue(int[] data) {
        this.data = data;
    }

    
    public void enqueue(int v) {
        if (tail == data.length && head == 0) {
            return;
        }
        if (tail == data.length && head > 0) {
            for (int i = 0; i < tail - head; i++) {
                data[i] = data[i + head];
            }
            tail = tail - head;
            head = 0;
        }
        data[tail] = v;
        tail++;
    }

    public int dequeue() {
        if (tail == 0||head==tail) {
            return -1;
        }
        int r = data[head];
        head++;
        return r;
    }

    public void display() {
        for (int i = head; i < tail; i++) {
            System.out.print( data[i] + " " );
        }
    }

    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue( new int[5] );
        queue.enqueue( 1 );
        queue.enqueue( 2 );
        queue.enqueue( 3 );
        queue.enqueue( 4 );
        queue.enqueue( 5 );
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.enqueue( 6 );
        queue.enqueue( 7 );
        queue.display();
    }

}

再做Climbing Stairs这个题目的时候，提交了两个版本的代码。理论上来说内存应该是有区别的，但是LeetCode给的结果，内存大小却没有什么区别。请帮忙看看。
/**
     * 动态规划
     * @param n
     * @return
     */
    public int climbStairsV3(int n) {
        if(n==1) return 1;
        int[] dp = new int[n+1];
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }

    /**
     * 节省内存的动态规划，但实际LeetCode反馈出来的内存并不少
     * @param n
     * @return
     */
    public int climbStairsV4(int n) {
        if(n==1) return 1;
        int num1 =1;
        int num2 =2;
        int num3=0;
        for(int i=3;i<=n;i++){
            num3=num1+num2;
            num1=num2;
            num2=num3;
        }
        return num2;
    }

全排列js
//9.一组数据集合的全排列 回溯（暴力枚举）
let count = 1

function permutation(nums, result = []) {
  if (nums.length == 0) {
    console.log(`${count}:${result}`)
    count++
    return
  }
  for (let i = 0; i < nums.length; i++) {
    permutation(nums.filter((value, index) => index != i), [...result, nums[i]])
  }
}

#一组数据集合的全排列
def f(start , b):
    a = list(b)
    if start==len(a):
        print(b)
    else:
        for i in range(start , len(a)):
            a[start] , a[i] = a[i] , a[start]
            c = tuple(a)
            f(start+1 , c)
            a[start] , a[i] = a[i] , a[start]

#实现快速排序、归并排序
#---------快排(三数取中)---------
def QuickSort():
    array = Array(10000)
    qsort(0 , len(array)-1 , array)
    return array
def qsort(start , end , array):
    if start < end:
        key = partation(array , start , end)
        qsort(start , key-1 , array)
        qsort(key+1 , end , array)
def swap(array , start , end):
    temp = array[start]
    array[start] = array[end]
    array[end] = temp
def change(array , start , mid , end):
    if array[start] > array[mid]:
        swap(array , start , mid)
    if array[start]>array[end]:
        swap(array , start , end)
    if array[mid] > array[end]:
        swap(array , mid , end)
    swap(array , mid , start)
def partation(array , start , end):
    #mid = int((start+end)/2)
    #change(array , start , mid , end)
    temp = array[start]
    while start < end :
        while start<end and array[end]<=temp:
            end-=1
        swap(array , start , end)
        while start<end and array[start]>=temp:
            start+=1
        swap(array , start , end)
    return start
#---------------归并------------
def merge(a , b):
    c = []
    i = 0
    j = 0
    while i<len(a) and j<len(b):
        if a[i] > b[j]:
            c.append(a[i])
            i+=1
        else:
            c.append(b[j])
            j+=1
    if i>=len(a):
        for k in range(j , len(b)):
            c.append(b[k])
    if j>=len(b):
        for k in range(i , len(a)):
            c.append(a[k])
    return c
def devide(array):
    if len(array) == 1:
        return array
    else:
        mid = int((0 + len(array)) / 2)
        leftArray = devide(array[0:mid])
        rightArray = devide(array[mid:len(array)])
        return merge(leftArray , rightArray)
def mergesort():
    array = Array(100)
    m = devide(array)
    return m

#冒泡、选择、插入排序
import random
import time
def Array(n):
    a = []
    for i in range(n):
        a.append(random.randint(0 , n))
    return a
#插入排序
def insert():
    array = Array(100)
    time_start=time.time()
    for i in range(1 , len(array)):
        for j in range(i , 0 , -1):
            if array[j] > array[j-1]:
                temp = array[j]
                array[j] = array[j-1]
                array[j-1] = temp
            else:
                break
    time_end=time.time()
    print(array)
    print('totally cost',time_end-time_start)
def select():
    array = Array(100)
    time_start=time.time()
    for i in range(len(array)):
        for j in range(i+1 , len(array)):
            if array[j] > array[i]:
                temp = array[j]
                array[j] = array[i]
                array[i] = temp
    time_end=time.time()
    print(array)
    print('totally cost',time_end-time_start)
def bubble():
    array = Array(100)
    time_start=time.time()
    for i in range(len(array)-1 , 0 , -1):
        flag = False
        for j in range(i):
            if array[j] > array[j+1]:
                temp = array[j]
                array[j] = array[j+1]
                array[j+1] = temp
                flag = True
        if not flag:
            break
    time_end=time.time()
    print(array)
    print('totally cost',time_end-time_start)

//阶乘n!
def f(n):
    if(n<=1):
        return 1
    else:
        return f(n-1)*n

//斐波那契数列
def f(n):
    if(n<=0):
        return 0
    elif(n==1):
        return 1
    else:
        return f(n-1)+f(n-2)