【剑指offer】18、删除链表中重复的节点

题目

        在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5，处理后为 1->2->5。

解题思路

        这道题目的意思是，只要遇到重复的节点，就把它们都删除掉，而不是保留重复的中的一个再与后面相连！！！

        如果当前节点curNode的值与下一个节点的值相同，那么它们就是重复的节点，这些节点们都可以被删除。

        为了保证删除之后的链表不断裂，我们要把当前节点的前一个节点 和 后面的值比当前节点的值大的节点相连。

        设置当前节点的前一个节点为preNode；

        设置布尔变量needDelete，如果当前节点和后一个节点的值相同（dupVal），needDelete的值为真。

        当needDelete为真时，通过循环找到往后第一个不为dupVa的节点，把该节点设置为当前节点，并让该节点的前一个节点指向该节点。

        当needDelete为假的时候，就把当前节点和前一个节点往后都挪一位即可。

测试情况：  

       1.功能测试（重复结点位于链表头部、中部、尾部，无重复结点）

　　2.特殊测试（null，所有结点均重复）

代码

package swordOffer;

/*
 * 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，
 * 重复的结点不保留，返回链表头指针。
 * 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
 * */
public class deleteDuplication {
	public static class ListNode{
		int val;
		ListNode next;
		
		public ListNode(int val, ListNode next) {
			this.val = val;
			this.next = next;
		}
	}
	
	public static ListNode deleteDuplication(ListNode pHead){
		if(pHead == null || pHead.next == null) {
			return pHead;
		}
		
		ListNode preNode = null;
		ListNode curNode = pHead;
		
		while(curNode != null) {
			boolean needDelete=false;
			
			if(curNode.next !=null && curNode.val == curNode.next.val) {
				needDelete = true;
			}
			
			if(!needDelete) {//当前节点不重复，就把preNode和curNode往后挪一位
				preNode = curNode;
				curNode = curNode.next;
			}else {//当前节点重复，通过循环找到往后第一个不为dupVa的节点，
				   //把该节点设置为当前节点，并让该节点的前一个节点指向该节点。
				int dupValue = curNode.val;//把当前指针指向的数保存下来，记为dupValue。
				ListNode toBeDel = curNode;//设置一个新指针，指向当前节点
				while(toBeDel != null && toBeDel.val == dupValue) {//用一个指针toBeDel来遍历，如果这个值和curNode的值一样，就一直往后遍历
					toBeDel = toBeDel.next;
				}
				if(preNode == null) {//如果preNode为空，则pHead就是toBeDel
					pHead=toBeDel;
				}else {
					preNode.next=toBeDel;//让preNode指向现在的toBeDel指针指向的数，这样就完成了删除
				}
				curNode = toBeDel;
			}
			
		}
		
		return pHead;
    }
	
	public static void test(ListNode pHead) {
		System.out.println("----");
		System.out.println("The original list is:");//原始的list
		ListNode cur = pHead;
		if(cur != null) {//当前节点不为空时才会执行以下的步骤。遍历所有的节点，并打印。
			while(cur.next != null) {
				System.out.print(cur.val + ",");
				cur = cur.next;
			}
			System.out.println(cur.val);//next已经为空的时候，打印当前节点
		}else {
			System.out.println();//如果当前节点为空，就什么都不打印
		}
		
		
		pHead = deleteDuplication(pHead);//调用删除节点的函数
		System.out.println("The result is : ");//打印出最后的结果
		cur = pHead;//将当前节点赋值给cur，cur作为一个指针遍历整个链表
		if(cur != null) {//当cur不为空时，遍历链表，逐个打印
			while(cur.next != null) {
				System.out.print(cur.val + " ");
				cur = cur.next;
			}
			System.out.println(cur.val);//打印当前cur的值
		}else {
			System.out.println();//打印空行
		}
		System.out.println("------");
	}
	
	/**
     * 重复结点位于链表头部
     */
	public static void test1() {
		ListNode p4 = new ListNode(3, null);
		ListNode p3 = new ListNode(2, p4);
		ListNode p2 = new ListNode(1, p3);
		ListNode p1 = new ListNode(1, p2);
		test(p1);
	}
	
	/**
     * 重复结点位于链表尾部
     */
	public static void test2() {
		ListNode p4 = new ListNode(3, null);
		ListNode p3 = new ListNode(3, p4);
		ListNode p2 = new ListNode(2, p3);
		ListNode p1 = new ListNode(1, p2);
		test(p1);
	}
	
	/**
     * 重复结点位于链表中部
     */
	public static void test3() {
        ListNode p4=new ListNode(3, null);
        ListNode p3=new ListNode(2, p4);
        ListNode p2=new ListNode(2, p3);
        ListNode p1=new ListNode(1, p2);
        test(p1);
    }
     
    /**
     * 连续出现重复结点
     */
    public static void test4() {
        ListNode p6=new ListNode(3, null);
        ListNode p5=new ListNode(3, p6);
        ListNode p4=new ListNode(2, p5);
        ListNode p3=new ListNode(2, p4);
        ListNode p2=new ListNode(1, p3);
        ListNode p1=new ListNode(1, p2);
        test(p1);
    }
     
    /**
     * 多个重复结点
     */
    public static void test5() {
        ListNode p6=new ListNode(3, null);
        ListNode p5=new ListNode(3, p6);
        ListNode p4=new ListNode(3, p5);
        ListNode p3=new ListNode(2, p4);
        ListNode p2=new ListNode(1, p3);
        ListNode p1=new ListNode(1, p2);
        test(p1);
    }
     
    /**
     * 无重复结点
     */
    public static void test6() {
        ListNode p6=new ListNode(6, null);
        ListNode p5=new ListNode(5, p6);
        ListNode p4=new ListNode(4, p5);
        ListNode p3=new ListNode(3, p4);
        ListNode p2=new ListNode(2, p3);
        ListNode p1=new ListNode(1, p2);
        test(p1);
    }
     
    /**
     * 单个结点
     */
    public static void test7() {
        ListNode p1=new ListNode(6, null);
        test(p1);
    }
    
    /**
     * null
     */
    public static void test8() {
        ListNode p1=null;
        test(p1);
    }
	
	public static void main(String[] args) {
		test1();
		test2();
		test3();
		test4();
		test5();
		test6();
		test7();
		test8();
	}
}