链表面试题--逆置、删除指定val

逆置/反转

1. 依次遍历每个结点**
     ListNode cur = head;
     while(cur ! = null){ cur = cur . next ; }
2. 把遍历的结点头插到一个新链表上
     1. 什么是新链表（链表第一开始是空链表）
       ListNode newList = null ;
     2. 如何头插 cur 到新链表 newList
       cur.next = newList ;
       newList = cur ;
3. 附加 ：三个引用的理解

删除指定val
其中一个方法

1. 定义一个新链表（一开始为空） ListNode newList = null ;
2. 依次遍历原链表每一个结点，如果 cur.val != val; 把cur 尾插到新链表上
    子问题（cur 尾插到 newList ）
       1. newList 为空链表
        头插
      2. newList 不为空链表
        1. 找到 newList 最后一个结点
        2. 最后一个结点的 next = cur ;
        3. 记录新最后一个结点 cur
3. 保证newList 链表最后一个结点的next = null

代码如下

class ListNode{
 int val;
 ListNode next;
 ListNode(int x){
  val=x;
 }
}
class Solution{
 public ListNode reverseList(ListNode head){
  /*依次遍历原链表的每个结点，头插一个新的链表中*/
  ListNode newList=null;
  //newList有两层含义，新链表的第一个结点，代表整个链表
  
  ListNode cur=head;
  while(cur!=null){
   //因一会 cur.next 会变化，需提前保存值
   ListNode next=cur.next;
   //头插到新链表
   cur.next=newList;
   newList=cur;
   //cur向后遍历
   cur=next;
  }
  return newList;
 }
 
 public ListNode reverseList0(ListNode head){
  ListNode n1=null;
  ListNode n2=head;
  while(n2!=null){
   ListNode n3=n2.next;
   n2.next=n1;
   n1=n2;
   n2=n3;
  }
  return n1;
 }
 public ListNode reverseList1(ListNode head){
  if(head==null){
   return null;
  }
  ListNode n1=null;
  ListNode n2=head;
  ListNode n3=head.next;
  
  while(n2!=null){
   n2.next=n1;
   n1=n2;
   n2=n3;
   n3=n3.next;
  }
  return n1;
 }
 /*遍历每个结点，如果结点的值是要删除的值，则删除该结点*/
 public ListNode removeElements(ListNode head,int val){
  if(head==null){
   return null;
  }
  ListNode cur=head.next;
  ListNode prev=head;
  while(cur!=null){
   if(cur.val==val){
    prev.next=cur.next;
   }else{
    prev=cur;
   }
   
   cur=cur.next;
  }
  if(head.val==val){
   head=head.next;
  }
  return head;
 }
 public ListNode removeElements1(ListNode head,int val){
  ListNode fakeHead=new ListNode(0);//val是多少不重要
  fakeHead.next=head;
  
  ListNode prev=fakeHead;
  ListNode cur=head;
  while(cur!=null){
   if(cur.val==val){
    prev.next=cur.next;
   }else{
    prev=cur;
   }
   cur=cur.next;
  }
  return fakeHead.next;
 }
 
 public ListNode removeElements2(ListNode head,int val){
  ListNode newList=null;
  ListNode last=null;//用来记录 newList 链表最后一个结点
  ListNode cur=head;
  while(cur!=null){
   ListNode next=cur.next;
   if(cur.val!=val){
    //把cur 尾插到 newList 
    if(newList==null){
     cur.next=null;
     newList=cur;
    }else{
     last.next=cur;
    }
    
    last=cur;
   }
   cur=next;
  }
  if(last!=null){
   last.next=null;  //保证最后一个结点的next = null
  }
  return newList;
 }
 
}
public class Situation{
 public static void display(ListNode head){
  for(ListNode n=head;n!=null;n=n.next){
   System.out.printf("(%d)-->",n.val);
  }
  System.out.println("null");
 }
 public static void testReverseList(){
  System.out.println("测试反转链表");
   
  ListNode n1=new ListNode(1);
  ListNode n2=new ListNode(2);
  ListNode n3=new ListNode(3);
  ListNode n4=new ListNode(4);
  ListNode n5=new ListNode(5);
  n1.next=n2;
  n2.next=n3;
  n3.next=n4;
  n4.next=n5;
  n5.next=null;
   
  Solution s=new Solution();
  ListNode result=s.reverseList(n1);
  //打印result
  display(result);
 }
 public static void testRemoveElements(){
  System.out.println("测试删除元素");
   
  ListNode n1=new ListNode(1);
  ListNode n2=new ListNode(2);
  ListNode n3=new ListNode(1);
  ListNode n4=new ListNode(4);
  ListNode n5=new ListNode(6);
  n1.next=n2;
  n2.next=n3;
  n3.next=n4;
  n4.next=n5;
  n5.next=null;
   
  Solution s=new Solution();
  ListNode result=s.removeElements(n1,1);
   //打印result
   display(result); 
 }
 public static void main(String[] args){
  testReverseList();
  testRemoveElements();
 }
}

结果如下

D:\JavaCode>java Situation
测试反转链表
(5)-->(4)-->(3)-->(2)-->(1)-->null
测试删除元素
(2)-->(4)-->(6)-->null

---