编写代码，移除未排序的链表中的重复节点

时间 2019-11-17

标签编写代码移除排序链表重复节点繁體版

原文原文链接

解法一：若是不得使用临时缓冲区，该怎么解决？java

要想移除链表中的重复节点，咱们须要设法记录有哪些是重复的。这里只须要使用到一个简单的散列表。node

在下面的解法中，咱们会直接迭代访问整个链表，将每一个节点加入到散列表。若发现有重复的元素，将该节点从链表中移除，而后继续迭代。这个题目使用了链表，所以只须要扫描一次就能搞定。app

deleteDups()的时间复杂度为O(N)，其中N为链表节点数目。this

解法二：不使用缓冲区指针

如不借助额外的缓冲区，能够用两个指针来迭代：current迭代访问整个链表，runner用于检查后续的节点是否重复code

上述代码中的deleteDups2()get

该代码的空间复杂度为O(1)，时间复杂度为O(N2)io

package cglib;
import java.util.Hashtable; table

class LinkedListNode<T> {
public LinkedListNode<T> next;
public T data;class

   public LinkedListNode(Object object, int data2, Object object2) {

   }

   }

public class StringNumber {
   private LinkedListNode<Integer> head;
    private LinkedListNode<Integer> tail;
    private int size;

     // 尾部插入
    public boolean addTail(int data) {
        if (this.head == null) {
            this.head = new LinkedListNode<Integer>(null, data, null);
            this.tail = this.head;
        } else {
            LinkedListNode<Integer> newnode = new LinkedListNode<Integer>(this.tail, data, null);
            this.tail.next = newnode;
            this.tail = newnode;
        }
        this.size++;

        return true;
    }
    public String toString() {
        if (this.isEmpty())
            return "[]";
        else {
            StringBuffer st = new StringBuffer("[");
            for (LinkedListNode<Integer> curent = this.head; curent != null; curent = curent.next)
                st.append(curent.data.toString() + " ,");
            st.append("]");
            return st.toString();
        }
    }
    public boolean isEmpty() {
        return this.size == 0;
    }

    public void deleteDups(LinkedListNode<Integer> n){
        Hashtable<Integer, Boolean> table = new Hashtable<Integer, Boolean>();
        LinkedListNode<Integer> previous = null;
        while(n != null){
            if(table.containsKey(n.data)){
                previous.next = n.next;
            }else{
                table.put(n.data, true);
                previous = n;
            }
            n =n.next;
        }
        while(head!=null){
            System.out.println(head.data.toString());
            head= head.next;
        }
    }
    public void deleteDups2(LinkedListNode<Integer> head){
        if(head == null)
            return;
        LinkedListNode<Integer> current = head;
        while(current != null){
            //移除后续值相同的全部节点
            LinkedListNode<Integer> runner = current;
            while(runner.next != null){
                if(runner.next.data == current.data){
                    runner.next = runner.next.next;
                }else{
                    runner = runner.next;
                }
            }
            current= current.next;
        }
        while(head!=null){
            System.out.println(head.data.toString());
            head= head.next;
        }
    }
    public static void main(String[] args){

       StringNumber test = new StringNumber();
        test.addTail(1);
        test.addTail(2);
        test.addTail(3);
        test.addTail(3);
        test.addTail(4);
        test.addTail(1);

        test.deleteDups2(test.head);

    }

}

public static void deleteDups(LinkListNode n) {
LinkListNode previous = null;
Hashtable table = new Hashtable();
while(n != null){
if (table.containsKeys(n.data)) {
preious.next = n.next;
}
else {
table.put(n.data, true);
previous = n;
}
n = n.next;
}
}

public static void deleteDupsNew(LinkListNode head) {
if (head == null) return;
LinkListNode current = head;
while(current != null){
LinkListNode runner = current;
while (runner.next != null){
if(runner.next.data == current.data){
runner.next = runner.next.next;
}
else{
runner = runner.next;
}
}
current = current.next;
}
}

或者：

public class ListNote {

    private  ListNote NextNote;
    private int value;
    public ListNote(){  
    }
    public ListNote(int value){
        this.value=value;
    }  
    public  ListNote getNext(){     
        return NextNote;            
    }
    public void setNext(ListNote next){
        this.NextNote=next; 
    }   
    public int getValue(){
        return value;   
    }
    public void setValue(int value){
        this.value=value;
    }
}

public static void deleteDuplication(ListNote root){
        if(root==null){
            return;
        }
        ListNote preNode=null;//前结点
        ListNote node=root;//当前结点
        while(node!=null){
            ListNote nextNode=node.getNext();//下一个结点
            boolean needDelete=false;
//判断当前结点和下一个结点值是否相等 
    if(nextNode!=null&&nextNode.getValue()==node.getValue())
                needDelete=true;
          if(!needDelete){//不相等，向前移动
              preNode=node;
              node=node.getNext();            
          }
          else{//相等，删除该结点
              int value=node.getValue();
              ListNote toBeDel=node;
              while(toBeDel!=null&&toBeDel.getValue()==value){
                  nextNode=toBeDel.getNext();//删除该结点
                  toBeDel=nextNode;
              }  
              if(preNode==null){//头结点删除时
                  root=nextNode;
              }
              else{
                  //即删除了重复结点
                  preNode.setNext(nextNode);
              }
              node=nextNode;
          }
        }
    }