我猜测你想说的是，Java这种没有“指针”或者“引用”的语言，怎么写C++里面的swap函数：template
void swap(T& a, T& b) {
T tmp(a);
a = b;
b = tmp;
}
Java里面的primitive type(boolean, double, float, int, byte, char, long, etc.)都是pass by value(事实上我个人比较喜欢认为Java只支持pass by value，只不过所有的Object都是pass by value of the reference，所以说你在函数里面修改Object型参数的引用不会影响caller和环境，因为Object reference也是copy的)，所以如果你要交换primitive type的值，不能只用函数和传参，要用一个Wrapper Object。
以下是一个例子，没有任何意义，只是为了展示你可以这么做，但是……可以这么做不代表你应该这么做。public final class SwapExample {
public static void main(String[] args) {
Integer a = 1;
Integer b = 2;
final Swap s = new Swap(a, b);
a = s.getA();
b = s.getB();
System.out.println("a: " + a + ", b: " + b);
}
static class Swap {
private final T a;
private final T b;
public Swap(T a, T b) {
this.a = b;
this.b = a;
}
public T getA() {
return a;
}
public T getB() {
return b;
}
}
}

我们交换两个数字的时候一般这样写：

void swap(int a,int b)
{
	int c;
	c=a;
	a=b;
	b=c;
}

如果不引入第三方变量 c 呢，该怎么写？

C++代码如下：

#include <iostream>
using namespace std;

int main()
{
	int a=1,b=2;
	a^=b;
	b^=a;
	a^=b;
	cout << "交换数据后"<<"a="<<a<<" b="<<b; 
	return 0; 
}

 

数组中只出现1次的2个数
如题所示：
思路
源代码如下：

如题所示：
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字

可以先考虑如果只有1个数字出现1次，其余都2次，怎么找：
思路
•对所有数字异或，由于异或满足结合律交换律，结果就是所要查找的数字

对于存在2个出现1次的数字:

•所有数字异或结果为这两个数字的异或值，如果能将数组分为2部分，每个数字属于其中一部分，则能求出这两个数字。可以找到这两个数字异或结果中第一个为1的位，根据该位将数组分成2个数组
源代码如下：
class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
        int num1xornum2 = 0;
        int sz = data.size();
        
        for(int i = 0;i < sz;i++)
            num1xornum2 ^= data[i];
        
        int idx = 0;
        while(((num1xornum2 & 1) == 0) && (idx < 32)){
            idx++;
            num1xornum2 = num1xornum2 >> 1;
        }
        
        *num1 = 0,*num2 = 0;
        for(int i = 0;i < sz;i++){
            if(isBit(data[i],idx))
                *num1 ^= data[i];
            else
                *num2 ^= data[i];
        } 
    }
    
    bool isBit(int num,int idx){
        while(idx){
            num = num >> 1;
            idx--;
        }
        return (num & 1);
    }
};

算法类：

有那些排序算法？不同排序算法的稳定性和时间复杂度和空间复杂度

写一个排序

快速排序算法 、写代码：快排时间复杂度（平均、最坏）、快排的思想，什么情况下要用什么排序算法、稳定性如何

手写归并排序

讲一下堆排序的过程

了解桶排序吗？讲一下

还有什么排序算法，插入排序如何改进为 nlogn的时间复杂度，什么排序算法效率最高呢

二分查找

二分查找与二叉搜索树

哈夫曼树，以及哈夫曼编码

树的广度优先遍历

广度优先遍历一个图、写一下代码

一致性哈希算法、

hash表与二叉树的区别

红黑树、口胡建树过程

红黑树介绍，加入一个结点时，它应该是红的还是黑的

跳表和红黑树的区别

b+树介绍，使用场景

b树和b+树、B、B+树的区别

分治思想

算法拓展类：

写反转链表

node *reverse(node *head)//链表的逆置
{
    node *next;
    node *prev = NULL;
    while (head != NULL)
    {
        next = head->next;
        head->next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

合并两个有序链表

已知一个节点，怎么在O(1)时间内将该节点从链表中删除（答了将它后面的节点的值赋给他，然后将它后面的节点删除）

怎么将一个二叉排序树转换成双链表

判断单链表中是否有环

bool IsLoop(node *head, node **start)//判断链表是否存在环形链表，start为回环开始节点的地址
{
    node *p1 = head, *p2 = head;
    if (head == NULL || head->next == NULL)//head为NULL或者链表为空时返回false
    {
        return false;
    }
    do
    {
        p1 = p1->next;//p1走一步
        p2 = p2->next->next;//p2走两步
    } while (p2 && p2->next && p1 != p2);
    if (p1 == p2)
    {
        *start = p1;//p1为回环开始节点
        return true;
    }
    else
    {
        return false;
    }
}

单次遍历删除链表倒数第n个节点

public static LNode findLastkNode(LNode head,int k){
    if (head==null||head.next==null) return head;
    //定义两个指针
    LNode slow,fast;
    slow=fast=head.next;
    int i;
    //求出第fast指向的节点
    for ( i = 0; i <k&&fast!=null ; i++) {
        fast=fast.next;
    }
    if (i<k){
        return null;
    }
    while (fast!=null){
        slow=slow.next;
        fast=fast.next;
    }
    return slow;
​
}

复杂链表的复制

给你一个链表1->2->3->4…将链表变为奇数在前面，偶数在后面，并保持奇偶数有序

找到数组中出现次数大于一半的那个数字 、

一个有正有负的数组，求数组的最大子数组的和

给你两个有序数组，求这两个数组的交集

两个栈实现一个队列

public class TwoStackImplQueue {
 
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    /*
     * 队列的数据压入过程
     */
    public void push(Integer element){
        stack1.push(element);
    }
    
    /*
     * 队列的数据弹出过程
     */
    public Integer pop(){
        if(stack2.size() <= 0){ //第二个栈为空
            while(stack1.size() > 0){   //第一个栈不为空
                stack2.push(stack1.pop());  //将其第一个栈的数据压入第二个栈中
            }
        }
        if(stack2.isEmpty()){
            try{
                throw new Exception("queue is empty");
            }catch(Exception e){
                //e.printStackTrace();
            }
        }
        Integer head = stack2.pop();
        return head;
    }
    
    public static void main(String[] args) {
        TwoStackImplQueue sq = new TwoStackImplQueue();
        sq.push(1);
        sq.push(3);
        sq.push(5);
        sq.push(4);
        sq.push(2);
        
        System.out.println(sq.pop());
        System.out.println(sq.pop());
        
        sq.push(7);
        System.out.println(sq.pop());
    }
}

两个队列实现栈、

public class TwoQueueImplStack {
    Queue<Integer> queue1 = new ArrayDeque<Integer>();
    Queue<Integer> queue2 = new ArrayDeque<Integer>();
    
    /*
     * 向栈中压入数据
     */
    public void push(Integer element){
        //两个队列都为空时，优先考虑 queue1
        if(queue1.isEmpty() && queue2.isEmpty()){
            queue1.add(element);
            return;
        }
        
        //如果queue1为空，queue2有数据，直接放入queue2
        if(queue1.isEmpty()){
            queue2.add(element);
            return;
        }
        
        //如果queue2为空，queue1有数据，直接放入queue1中
        if(queue2.isEmpty()){
            queue1.add(element);
            return;
        }
    }
    
    /*
     * 从栈中弹出一个数据
     */
    public Integer pop(){
        //如果两个栈都为空，则没有元素可以弹出，异常
        if(queue1.isEmpty() && queue2.isEmpty()){
            try{
                throw new Exception("satck is empty!");
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        
        //如果queue1中没有元素，queue2中有元素，将其queue2中的元素依次放入queue1中，直到最后一个元素，弹出即可
        if(queue1.isEmpty()){
            while(queue2.size() > 1){
                queue1.add(queue2.poll());
            }
            return queue2.poll();
        }
        
        //如果queue2中没有元素，queue1中有元素，将其queue1中的元素依次放入queue2中，直到最后一个元素，弹出即可
        if(queue2.isEmpty()){
            while(queue1.size() > 1){
                queue2.add(queue1.poll());
            }
            return queue1.poll();
        }
        
        return (Integer)null;
    }
    
    public static void main(String[] args) {
        TwoQueueImplStack qs = new TwoQueueImplStack();
        qs.push(2);
        qs.push(4);
        qs.push(7);
        qs.push(5);
        System.out.println(qs.pop());
        System.out.println(qs.pop());
        
        qs.push(1);
        System.out.println(qs.pop());
    }
}

给定整型数组，求最长递增子序列长度

最长子序列问题,找出最长连续序列长度，比如【8 5 4 1 2 3 7】子序列为12345，长度为5（使用set）

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length == 0) return 0;
        int[] dp = new int[nums.length];
        int res = 0;
        Arrays.fill(dp, 1);
        for(int i = 0; i < nums.length; i++) {
            for(int j = 0; j < i; j++) {
                if(nums[j] < nums[i]) dp[i] = Math.max(dp[i], dp[j] + 1);
            }
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        if(nums.length <= 1)
            return nums.length;
        int ans = 1;
        int count = 1;
        for(int i=0;i<nums.length-1;i++) {
            if(nums[i+1] > nums[i]) {
                count++;
            } else {  
                count = 1;
            }
            ans = count > ans ? count : ans;
        }
        return ans;
    }
}

将数组里面非0的元素移到前面，0元素移到后面（不改变相对位置）

字符串反转

最短子序列问题

找中位数、两个有序数组求中位数

如何在很大的数组中快速找出第K大的元素？(TOPK问题)

栈实现表达式计算

n层台阶，只能走一层或两层，有几种走法？（剑指offer原题）

一个二维矩阵，右边的数比左边的大，下边的数比上边的大，如何判断某个数是否在矩阵中？时间复杂度？（剑指offer原题）

二分查找找出有序数组第一次出现的位置

交换二叉树的父子结点

求根节点到叶子节点之间和为x的路径 输出路径， 求根节点到叶子节点之间和为x的路径 输出路径，

分层打印二叉树

遍历list找出下标奇数的值，如果是 LinkedList 应该怎么优化；

一个数组，只有一个数出现1次，其他都出现三次，求这个数：hash散列，求得没碰撞的数，o（n）

设计模式：

用过什么设计模式

观察者模式

手撕算法：写一个线程安全的单例模式 、手撕单例模式 、手撕单例模式

手写单例模式的饿汉式，要求线程安全的双检锁模式

工厂模式的作用

写一个死锁程序。

设计一个LRU，写一下代码、LRU算法理解与特定场景的改进

智力题

烧绳子的智力题 一根1h 求15分钟的