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));
}
}