题目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数字并进行累加
* <p>
* 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数字并进行累加
* <p>
* 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<Integer, Integer> 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();
}
}
网友评论