输入一个链表，从尾到头打印链表每个节点的值。
/**
ArrayList<Integer>
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> list=new ArrayList<Integer>();
ArrayList<Integer> result=new ArrayList<Integer>();
ListNode p=listNode;
while(p!=null){
list.add(p.val);
p=p.next;
}
for(int i=list.size()-1;i>=0;i--){
result.add(list.get(i));
System.out.println(list.get(i));
}
return result;
}
}
/*
输入一个链表，输出该链表中倒数第k个结点。
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
import java.util.*;
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
ArrayList<ListNode>list= new ArrayList<ListNode>();
ListNode p=head;
while(p!=null){
list.add(p);//这里不是p.val,是listnode,不是integer
p=p.next;
}
if(k<=0||k>list.size()){
return null;
}
else{
p=list.get(list.size()-k);
return p;
}
}
}
/*
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
ListNode head=null;
if(list1==null){
return list2;
}
if(list2==null){
return list1;
}
if(list1.val<list2.val){
head=list1;
head.next=Merge(list1.next,list2);
}
else{
head=list2;
head.next=Merge(list1,list2.next);
}
return head;
}
}
/*
输入一个链表，反转链表后，输出新链表的表头。
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode ReverseList(ListNode head) {
/* while (head!=0){
list.add(p.val);
p=p.next;
}*/
ListNode newHead=null;
ListNode pNode=head;
ListNode pPre=null;
while(pNode!=null){
ListNode pNext=pNode.next;
if(pNext==null)
newHead=pNode;
pNode.next=pPre;//这一步没有实际地址的变化
pPre=pNode;
pNode=pNext;
}
return newHead;
}
}