删除链表的重复数据

分析:

• 遍历链表，用Hashtable或者HashMap，判断值是否已经存在。

• 双重循环遍历，不需要额外存储空间，时间复杂度较高。外循环为P，内循环遍历时，删除所有与P相同的值。支持一个值具有多个相同的值。

  代码实现：

import java.util.Hashtable;

class Node{
    public int data;
    public Node next;
    public Node(int data){
        this.data = data;
        this.next = null;
    }
}

public class MyLinkedList {
    Node head = null;

    //add new node
    public void addNode(int data){
        Node newNode = new Node(data);
        if (head==null) {
            head = newNode;
            return;
        }
        Node tmp = head;
        while(tmp.next!=null) {
            tmp = tmp.next;
        }
        tmp.next = newNode;
    }

    //delete ith
    public boolean deleteNode(int index){
        if (index<1 || index>length()) {
            return false;
        }
        if (index==1) {
            head = head.next;
            return true;
        }
        int i=1;
        Node preNode = head;
        Node curNode = preNode.next;
        while (curNode!=null) {
            if (i==index) {
                preNode.next = curNode.next;
                return true;
            }
            preNode = curNode;
            curNode = curNode.next;
            i++;
        }
        return true;
    }


    //return LinkedList length value
    private int length() {
        // TODO Auto-generated method stub
        int length = 0;
        Node tmp = head;
        while (tmp!=null) {
            length++;
            tmp = tmp.next;
        }
        return length;
    }

    //sort and return head
    public Node orderList(){
        Node curNode = head;
        Node nextNode = null;
        int tmp = 0;
        while(curNode.next!=null) {
            nextNode = curNode.next;
            while (nextNode!=null) {
                if (curNode.data>nextNode.data) {
                    tmp = curNode.data;
                    curNode.data = nextNode.data;
                    nextNode.data = tmp;
                }
                nextNode = nextNode.next;
            }
            curNode = curNode.next;
        }
        return head;
    }

    //print list
    public void printList(){
        Node tmp =  head;
        while(tmp!=null){
            System.out.print(tmp.data+" ");
            tmp = tmp.next;
        }
    }

    //delete the same Node
    public Node deleteDuplecate(){
        Node curNode = head;
        Node preNode = null;
        Hashtable<Integer, Integer> hashtable = new Hashtable<>();
        while(curNode!=null){
            if (hashtable.containsKey(curNode.data)) {
                preNode.next = curNode.next;
            }else {
                hashtable.put(curNode.data, 1);
                preNode = curNode;
            }
            curNode = curNode.next;
        }
        return head;
    }

    //no extra storage
    public Node deleteDuplecate2(){
        Node pNode = head;
        Node qNode = null;
        while (pNode!=null) {
            qNode = pNode;
            while (qNode.next!=null) {
                if (pNode.data==qNode.next.data) {
                    qNode.next = qNode.next.next;
                }else {
                    qNode = qNode.next;
                }
            }
            pNode = pNode.next;
        }
        return head;
    }

    public static void main(String[] args){
        MyLinkedList list = new MyLinkedList();
        list.addNode(5);
        list.addNode(3);
        list.addNode(1);
        list.addNode(3);
        list.addNode(4);
        list.addNode(3);
        System.out.println("List length is: "+list.length());
        System.out.println("before is: ");
        list.printList();
        System.out.println();
        System.out.println("after order is: ");
        list.orderList();
        list.printList();
        System.out.println();
        System.out.println("delete duplecate is: ");
        //list.deleteDuplecate();
        list.deleteDuplecate2();
        list.printList();
        System.out.println();
    }
}

运行结果：

List length is: 6
before is:
5 3 1 3 4 3
after order is:
1 3 3 3 4 5
delete duplecate is:
1 3 4 5