删除重复节点

题目：传入一个排序数字链表，删除其中重复的元素 

package com.example.demo;


import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Iterator;
import java.util.LinkedList;

/**
 *
 */

@SpringBootTest
public class DeleteDuplicatedNode {
    private static final Logger LOGGER = LoggerFactory.getLogger(DeleteDuplicatedNode.class);

    /**
     * 题目：传入一个排序数字链表，删除其中重复的元素
     * 思路：只保留不重复的链表元素。由于链表已经排序，若不重复则前后元素肯定不同。
     * 用标志位判断上个元素是否重复，若没有则加入到新的链表中
     * 返回新链表
     *
     * @param sortedLinkedList ：排序的链表
     * @return
     */
    public static LinkedList<Integer> deleteDuplicateNode(LinkedList<Integer> sortedLinkedList) {
        //入参校验
        if (sortedLinkedList == null || sortedLinkedList.size() <= 0) return sortedLinkedList;
        LinkedList<Integer> resLinkedList = new LinkedList<>();//结果LinkedList
        Integer lastNode = sortedLinkedList.pollFirst();
        boolean nodeDuplicated = false;//标记节点是否重复，默认节点不重复
        while (lastNode != null) {
            Integer currentNode = sortedLinkedList.pollFirst();
            if (!lastNode.equals(currentNode)) {//上个节点和当前节点不同，且上个节点不是重复节点，则把上个节点加入结果链表
                if (!nodeDuplicated)
                    resLinkedList.addLast(new Integer(lastNode));
                lastNode = currentNode;
                nodeDuplicated = false;//当前节点默认为不重复
            } else {
                nodeDuplicated = true;
            }
        }
        return resLinkedList;
    }

    /**
     * 思路：对排序链表进行遍历，发现重复元素就移除，返回本链表
     *
     * @param sortedLinkedList
     * @return
     */
    public static LinkedList<Integer> deleteDuplicateNodeReturnSelf(LinkedList<Integer> sortedLinkedList) {
        if (sortedLinkedList == null || sortedLinkedList.size() <= 0) return sortedLinkedList;
        Integer lastNode = sortedLinkedList.peekFirst();
        boolean nodeDuplicated = false;
        for (int i = 1; i < sortedLinkedList.size(); i++) {
            Integer node = sortedLinkedList.get(i);
            if (!lastNode.equals(node)) {
                if (nodeDuplicated) {
                    sortedLinkedList.remove(lastNode);
                    i--;
                }
                lastNode = node;
                nodeDuplicated = false;//新节点默认为不重复
            } else {
                sortedLinkedList.remove(lastNode);
                if (i - 1 >= 0) i--;
                nodeDuplicated = true;
            }
        }
        return sortedLinkedList;
    }

    @Test
    public void testDeleteDuplicateNode() {
        LinkedList<Integer> linkedNodes = new LinkedList<>();
        for (int i = -1; i < 10; i++) {
            linkedNodes.add(i);
            if (i % 5 == 0) continue;
            linkedNodes.add(i);
            if (i % 2 == 0) continue;
            linkedNodes.add(i);

            linkedNodes.add(i);
        }
        LOGGER.info("原始数据： " + linkedNodes);
        long startTime = System.currentTimeMillis();
        LOGGER.info("执行结果： " + deleteDuplicateNode(linkedNodes));
//        deleteDuplicateNode(linkedNodes);
        LOGGER.info("总时间消耗：" + (System.currentTimeMillis() - startTime));

    }

    @Test
    public void testDeleteDuplicateNodeReturnSelf() {
        LinkedList<Integer> linkedNodes = new LinkedList<>();
        for (int i = -1; i < 10; i++) {
            linkedNodes.add(i);
            if (i % 5 == 0) continue;
            linkedNodes.add(i);
            linkedNodes.add(i);
        }
        LOGGER.info("原始数据： " + linkedNodes);
        long startTime = System.currentTimeMillis();
        LOGGER.info("执行结果： " + deleteDuplicateNodeReturnSelf(linkedNodes));
        LOGGER.info("总时间消耗：" + (System.currentTimeMillis() - startTime));
    }

    public static void main(String[] args) {
        LinkedList<Integer> linkedNodes = new LinkedList<>();
        for (int i = -1; i < 1000000; i++) {
            linkedNodes.add(i);
            if (i<0||i % 5 == 0 || i % 2 == 0 || i % 3 == 0) continue;
            linkedNodes.add(i);
            linkedNodes.add(i);
            linkedNodes.add(i);
        }
//        System.out.println(linkedNodes);
        long startTime = System.currentTimeMillis();
        System.out.println(deleteDuplicateNode(linkedNodes));
//        System.out.println(deleteDuplicateNodeReturnSelf(linkedNodes));
        System.out.println("总时间消耗：" + (System.currentTimeMillis() - startTime));
    }

}