面试蚂蚁的笔试题，算法题三道，和大家分享，早日财富自由

1 写一个函数将一个单向链表进行反向。要求自行编写反向的过程和设计数据结构，不要外部包和辅助函数来处理。

/**
* 这道题主要考察的是对数据结构的理解
*/
public class Node {

	private int data;
	private Node next;
 
	public int getData() {
		return data;
	}
	public void setData(int data) {
		this.data = data;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	public void reverseLinkList_Stack() {  //借助栈来实现逆序输出
		Stack<Node> stack = new Stack<Node>();
		Node node = head.getNext();
		while (node != null) {
			stack.push(node);
			node = node.getNext();
		}
		while (stack.size() > 0) {
			node = stack.pop();
			System.out.print(node.getData() + "--->");
		}
		System.out.println("null"); // 在最后添加上null作为结束标志
	}

}

2 有三个线程ID分别是A、B、C,请用多线编程实现，在屏幕上循环打印10次ABC

/**
*	这个题主要考察的是锁的概念  公平锁
*	并发用的关键字 volatile 
*/
public class TestLock {
	//利用队列来实现公平锁
	private Queue<String> threadQueue=new ArrayDeque<>();
	//使用volatile 修饰 确保线程调用前数据被更新了，记录当前拿到锁的线程
	private volatile String turn;
	
	//排队
	public void addQueue(Thread thread){
		threadQueue.offer(thread.getName());
	}
	
	//拿锁方法
	public void lock(){
		Thread currentThread = Thread.currentThread(); //获取当前线程的引用
		turn=threadQueue.peek();//获取排在第一个
		
		while(!turn.equals(currentThread.getName()));//如果当前线程不是排在第一个的线程  循环阻塞
		
	}
	
	public void unLock(){
		threadQueue.poll(); //删除第一个
		turn=threadQueue.peek(); //更新第一个
	}
	
	
	public static void main(String[] args) {
		TestLock lock=new TestLock();
		//循环10次
		for(int i=0;i<10;i++){
			
			//创建ABC三个线程
			Thread A=new Thread(()->{
				lock.lock();
				System.out.print("A");
				lock.unLock();
			});
			Thread B=new Thread(()->{
				lock.lock();
				System.out.print("B");
				lock.unLock();
			});
			Thread C=new Thread(()->{
				lock.lock();
				System.out.println("C");
				lock.unLock();
			});
			//按顺序加入队列
			lock.addQueue(A);
			lock.addQueue(B);
			lock.addQueue(C);
			
			A.start();
			B.start();
			C.start();
		
		}
		
	}
	
}

3.某客户在银行借了多笔贷款，系统每天将发起系统扣款，扣款成功后需要按照特定的顺序对各笔贷款进行销账：

a) 逾期天数（整数型）越大优先处理；
b) 用户逾期利率（浮点型）越高，优先处理；
c) 支用日（Date类型）越早，优先处理；
d) 所有条件一致时，默认按id排列，id越小，优先处理；
一笔贷款的数据结构大致如下：

public class Loan{
 private String id;
 private Integer ovdDays;
 private BigDecimal rate;
 private Date startDate;
 private BigDecimal amount;
 // 其他字段…
}

请用熟悉语言写一个函数，对客户N笔贷款（作为输入）按照上述诉求进行排序，要求排序算法是Stable的；

/**
* 蚂蚁的题目的目的就是考察对 对象的排序算法
*/
public class TestSort {
	
	private int num;
	private double money;
	private Date time;
	//优先按日期排序  日期相同按money 排序 最后是num
	public TestSort(int num, double money, Date time) {
		super();
		this.num = num;
		this.money = money;
		this.time = time;
	}
	@Override
	public String toString() {
		return "[num=" + num + ", money=" + money + ", time=" + time.getTime() + "]";
	}

	public static void main(String[] args) {
		List<TestSort> list=new ArrayList();
		Random r = new Random(1);
		for(int i=0;i<100000;i++){
			list.add(new TestSort(r.nextInt(100), r.nextDouble(), new Date(System.currentTimeMillis())));
			
		}
		long starTime=System.currentTimeMillis();
		//排序 内部使用的 Timsort(二叉插排 与归并排序 结合的 号称最强排序算法)
		// 重点是重写Comparator 比较器
		Collections.sort(list,new Comparator<TestSort>(){
			@Override
			public int compare(TestSort o1, TestSort o2) {
				// TODO Auto-generated method stub
				if(o1.time.getTime() == o2.time.getTime()){
					if(o1.money == o2.money){
						if(o1.num == o2.num){
							return 0;
						}else{
							return o1.num - o2.num>0?1:-1;
						}
						
					}else{
						return o1.money - o2.money>0?1:-1;
					}
					
				}else{
					return o1.time.getTime()-o2.time.getTime()>0?1:-1;
				}
			}
			});
//		System.out.println(list);
		System.out.println("耗时："+(System.currentTimeMillis()-starTime));
	}
	
}