본문 바로가기
1 Day 1 Algorithms

[2019.01.15] More Linked Lists

by 곰돌찌 2019. 1. 15.

Problem


Objective 
Check out the Tutorial tab for learning materials and an instructional video!

Task 
A Node class is provided for you in the editor. A Node object has an integer data field, , and a Node instance pointer, , pointing to another node (i.e.: the next node in a list).

A removeDuplicates function is declared in your editor, which takes a pointer to the  node of a linked list as a parameter. Complete removeDuplicates so that it deletes any duplicate nodes from the list and returns the head of the updated list.

Note: The  pointer may be null, indicating that the list is empty. Be sure to reset your  pointer when performing deletions to avoid breaking the list.

Input Format

You do not need to read any input from stdin. The following input is handled by the locked stub code and passed to the removeDuplicates function: 
The first line contains an integer, , the number of nodes to be inserted. 
The  subsequent lines each contain an integer describing the  value of a node being inserted at the list's tail.

Constraints

  • The data elements of the linked list argument will always be in non-decreasing order.

Output Format

Your removeDuplicates function should return the head of the updated linked list. The locked stub code in your editor will print the returned list to stdout.

Sample Input

6
1
2
2
3
3
4

Sample Output

1 2 3 4 

Explanation

, and our non-decreasing list is . The values  and  both occur twice in the list, so we remove the two duplicate nodes. We then return our updated (ascending) list, which is .


How I solved the problem


#Linked List의 node개념을 잘 알기..!

#Linked List의 삭제는 nextNode의 보는 방향을 바꿔줌으로써 삭제가 가능함.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import java.io.*;
import java.util.*;
class Node{
    int data;
    Node next;
    Node(int d){
        data=d;
        next=null;
    }
    
}
class Solution
{
 
    public static Node removeDuplicates(Node head) {
      //Write your code here
 
      if (head == null) {
          return head;  // node가 없으면 들어왔던 head값 return 
      }
 
      Node node = head;
 
      while(node.next != null) { //다음 node가 없을 때 까지
          if (node.next.data == node.data) { // 현재의 다음 노드의 데이터와 현재의 데이터가 같을 때
              node.next = node.next.next; //현재 노드의 next를 현재의 다음의 다음 노드(현재의 다음 노드를 건너뜀..)로 입력
          } else{
              node = node.next; //그게 아니라면 node를 다음 node로 지정함.
          }
      }
 
      return head;
    }
 
     public static  Node insert(Node head,int data)
     {
        Node p=new Node(data);            
        if(head==null)
            head=p;
        else if(head.next==null)
            head.next=p;
        else
        {
            Node start=head;
            while(start.next!=null)
                start=start.next;
            start.next=p;
 
        }
        return head;
    }
    public static void display(Node head)
        {
              Node start=head;
              while(start!=null)
              {
                  System.out.print(start.data+" ");
                  start=start.next;
              }
        }
        public static void main(String args[])
        {
              Scanner sc=new Scanner(System.in);
              Node head=null;
              int T=sc.nextInt();
              while(T-->0){
                  int ele=sc.nextInt();
                  head=insert(head,ele);
              }
              head=removeDuplicates(head);
              display(head);
 
       }
    }
cs


[출처 : https://www.hackerrank.com ]


'1 Day 1 Algorithms' 카테고리의 다른 글

[2019.01.17] Nested Logic  (0) 2019.01.17
[2019.01.16] Running Time and Complexity  (0) 2019.01.16
[2019.01.14] BST Level-Order Traversal  (0) 2019.01.14
[2019.01.11] Binary Search Trees  (0) 2019.01.11
[2019.01.10] Generics  (0) 2019.01.10

댓글