阿里巴巴在线编程测验 java_阿里巴巴在线编程题

题目1、编写代码，实现：自定义一个链表数据结构(可以是单链表或双向链表)，然后初始化一个链表数据，

//并对该链表实现两两翻转(是翻转整个节点，而不是仅交换节点的值)，然后输出翻转之后的结果。

//比如构造的链表是：1->2->3->4->5，翻转之后，输出：2->1->4->3->5.

/**

* @Description: 实现单链表两两反转

* @author renyuanwei

* @create 2019-07-18 20:35

*/

public class AlibabaBole {

public static class ListNode {

int val;

ListNode next;

ListNode(int val) {

this.val = val;

}

}

/**

* 单链表两两反转

* 已知一个链表：1->2->3->4->5

* 每两个元素进行反转：2->1->4->3->5

*/

public static ListNode reversePairedList(ListNode head){

if(head == null){

return null;

}

//当前节点A

ListNode a = head;

//下个节点B

ListNode b = head.next;

//下下个节点C

ListNode temp;

//上一组的尾指针，在下一组反转后需要改变

ListNode previous = null;

ListNode newHead = b == null ? a : b;

while(b != null){

// 记录C节点

temp = b.next;

// a->b 反向

b.next = a;

a.next = temp;

if(previous != null){

previous.next = b;

}

if(temp == null){

break;

}

previous = a;

//移动到下一组

a = temp;

b = temp.next;

}

return newHead;

}

/**

* main方法测试

* @param args

*/

public static void main(String[] args) {

ListNode a1 = new ListNode(1);

ListNode a2 = new ListNode(2);

ListNode a3 = new ListNode(3);

ListNode a4 = new ListNode(4);

ListNode a5 = new ListNode(5);

a1.next = a2;

a2.next = a3;

a3.next = a4;

a4.next = a5;

//两两反转单链表

ListNode node = reversePairedList(a1);

//打印输出结果

while (node != null){

System.out.print(node.val);

node = node.next;

System.out.print(node != null ? "->" : "");

}

}

}

题目2: 线程A负责实时往Map里put 1-100的数字，线程B负责实时从这个map中get数字并进行累加

A放入MAP一个值后，B取出来,然后A继续放，B继续取，以此循环一直到A放完100，B取完100,结束)，

B实时打印当前时刻累加的结果。

/**

* @author renyuanwei

* @Description: 线程A负责实时往Map里put 1-100的数字，线程B负责实时从这个map中get数字并进行累加

*

* 1、A放入MAP一个值后，B取出来,然后A继续放，B继续取，以此循环一直到A放完100，B取完100,结束)，

* 2、B实时打印当前时刻累加的结果。

* @create 2019-07-18 20:55

*/

package com.example.demo.solution;

import java.util.HashMap;

import java.util.Map;

/**

* @author renyuanwei

* @Description: 线程A负责实时往Map里put 1-100的数字，线程B负责实时从这个map中get数字并进行累加

*

* 1、A放入MAP一个值后，B取出来,然后A继续放，B继续取，以此循环一直到A放完100，B取完100,结束)，

* 2、B实时打印当前时刻累加的结果。

* @create 2019-07-18 20:55

*/

public class AlibabaBoleMultithreading {

private boolean Lock;

public boolean isLock() {

return Lock;

}

public String setLock(boolean lock) {

Lock = lock;

return null;

}

public static void main(String[] args) {

Map map = new HashMap(100);

final AlibabaBoleMultithreading bole = new AlibabaBoleMultithreading();

Object lock = new Object();

bole.setLock(false);

Thread threadA = new Thread(new Runnable() {

@Override

public void run() {

int i = 0;

while (i < 100) {

synchronized (lock) {

if (bole.isLock()) {

try {

lock.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

} else {

i++;

map.put(i, i);

bole.setLock(true);

lock.notifyAll();

}

}

}

}

});

Thread threadB = new Thread(new Runnable() {

@Override

public void run() {

int i = 0;

int num = 0;

while (i < 100) {

synchronized (lock) {

if (bole.isLock()) {

i++;

num = num + map.get(i);

System.out.println("累加：" + num);

bole.setLock(false);

lock.notifyAll();

} else {

try {

lock.wait();

} catch (Exception e) {

}

}

}

}

}

});

threadA.start();

threadB.start();

}

}