×

Suggest a Topic

Select a Category

Iterative approach for removing middle points in a linked list of line segements

This post explains the iterative approach of this problem.
We maintain two pointers, prev and temp. If these two have either x or y same, we move forward till the equality holds and keep deleting the nodes in between. The node from which the equality started, we adjust the next pointer of that node.

C++

// C++ program to remove intermediate  
// points in a linked list that represents 
// horizontal and vertical line segments 
#include <iostream> 
using namespace std; 
  
// Node has 3 fields including x, y 
// coordinates and a pointer to next node 
struct Node { 
    int x, y; 
    struct Node *next; 
}; 
  
/* Function to insert a node at the beginning */
void push(struct Node **head_ref, int x, int y) 
{ 
    struct Node *new_node = new Node;    
    new_node->x = x; 
    new_node->y = y; 
    new_node->next = (*head_ref); 
    (*head_ref) = new_node; 
} 
  
/* Utility function to print a singly linked list */
void printList(struct Node *head) 
{ 
    struct Node *temp = head;     
    while (temp != NULL) { 
        printf("(%d, %d)-> ", temp->x, temp->y);         
        temp = temp->next; 
    }     
    printf("\n"); 
} 
  
// This function deletes middle nodes in a  
// sequence of horizontal and vertical line  
// segments represented by linked list. 
void delete_Middle_Nodes(Node *head)  
{     
    Node *temp = head->next, *prev = head;   
    
    while (temp) { 
          
        // checking equlity of point x 
        if (temp->x == prev->x)  
        { 
            Node *curr = prev; 
            prev = temp; 
            temp = temp->next;         
              
            // removing vertical points of line  
            // segment from linked list 
            while (temp && temp->x == prev->x)  
            { 
                curr->next = temp; 
                free(prev); 
                prev = temp; 
                temp = temp->next; 
            } 
        } 
  
        // checking equlity of point y 
        else if (temp->y == prev->y)  
        { 
            Node *curr = prev; 
            prev = temp; 
            temp = temp->next; 
              
            // removing horizontal points of line  
            // segment from linked list 
            while (temp && temp->y == prev->y) 
            { 
                curr->next = temp; 
                free(prev); 
                prev = temp; 
                temp = temp->next; 
            } 
        } else { 
            prev = temp; 
            temp = temp->next; 
        } 
    } 
} 
  
// Driver program to test above functions 
int main() { 
    struct Node *head = NULL; 
      
    push(&head, 40,5); 
    push(&head, 20,5); 
    push(&head, 10,5); 
    push(&head, 10,8); 
    push(&head, 10,10); 
    push(&head, 3,10); 
    push(&head, 1,10); 
    push(&head, 0,10); 
      
    printf("Given Linked List: \n"); 
    printList(head); 
      
    delete_Middle_Nodes(head); 
      
    printf("Modified Linked List: \n"); 
    printList(head); 
      
    return 0; 
} 

Java

class LinkedList 
{ 
    Node head; // head of list 
  
    /* Linked list Node*/
    class Node 
    { 
        int x,y; 
        Node next; 
        Node(int x, int y) 
        { 
            this.x = x; 
            this.y = y; 
            next = null; 
        } 
    } 
  
    // This function deletes middle nodes in a sequence of 
    // horizontal and vertical line segments represented 
    // by linked list. 
    private void delete_Middle_Nodes(Node head) 
    { 
        Node prev = head; 
        Node temp = head.next; 
  
        while (temp != null) 
        { 
  
            // checking equlity of point x 
            if (temp.x == prev.x) 
            { 
                Node curr = prev; 
                prev = temp; 
                temp = temp.next; 
  
                // removing vertical points of line  
                // segment from linked list 
                while (temp != null && temp.x == prev.x) 
                { 
                    curr.next = temp; 
                    prev.next = null; 
                    prev = temp; 
                    temp = temp.next; 
                } 
            } 
  
            // checking equlity of point y  
            else if (temp.y == prev.y) 
            { 
                Node curr = prev; 
                prev = temp; 
                temp = temp.next; 
  
                // removing horizontal points of line  
                // segment from linked list 
                while (temp != null && temp.y == prev.y) 
                { 
                    curr.next = temp; 
                    prev.next = null; 
                    prev = temp; 
                    temp = temp.next; 
                } 
            }  
            else
            { 
                prev =temp; 
                temp = temp.next; 
            } 
        } 
    } 
  
    /* Given a reference (pointer to pointer) to the head 
        of a list and an int, push a new node on the front 
        of the list. */
    void push(int x, int y) 
    { 
        /* 1 & 2: Allocate the Node & 
                Put in the data*/
        Node new_node = new Node(x,y); 
  
        /* 3. Make next of new Node as head */
        new_node.next = head; 
  
        /* 4. Move the head to point to new Node */
        head = new_node; 
    } 
  
  
    void printList() 
    { 
        Node temp = head; 
        while (temp != null) 
        { 
            System.out.print("(" + temp.x + "," + temp.y + ")->"); 
            temp = temp.next; 
        } 
        System.out.println(); 
    } 
  
  
    /* Driver code */
    public static void main(String args[]) 
    { 
        LinkedList llist = new LinkedList(); 
  
        llist.push(40,5); 
        llist.push(20,5); 
        llist.push(10,5); 
        llist.push(10,8); 
        llist.push(10,10); 
        llist.push(3,10); 
        llist.push(1,10); 
        llist.push(0,10); 
  
        System.out.println("Given list"); 
        llist.printList(); 
  
        llist.delete_Middle_Nodes(llist.head); 
  
        System.out.println("Modified Linked List is"); 
        llist.printList(); 
    } 
} 
  
// This code is contributed by shubham96301. 

Python3

# Python3 program to remove intermediate  
# points in a linked list that represents 
# horizontal and vertical line segments 
import math 
  
# Node has 3 fields including x, y 
# coordinates and a pointer to next node 
class Node:  
    def __init__(self, x, y):  
        self.x = x 
        self.y = y 
        self.next = None
  
# Function to insert a node at the beginning  
def push(head_ref, x, y): 
    new_node = Node(x, y)  
    new_node.x = x 
    new_node.y = y 
    new_node.next = head_ref 
    head_ref = new_node 
    return head_ref 
  
# Utility function to print  
# a singly linked list  
def printList(head): 
    temp = head  
    while (temp != None): 
        print("(", temp.x, ",", 
                   temp.y, ")", end = "->",)      
        temp = temp.next
          
    print() 
  
# This function deletes middle nodes in a  
# sequence of horizontal and vertical line  
# segments represented by linked list. 
def delete_Middle_Nodes(head):  
    temp = head.next
    prev = head  
      
    while (temp): 
          
        # checking equlity of point x 
        if (temp.x == prev.x): 
            curr = prev 
            prev = temp 
            temp = temp.next    
              
            # removing vertical points of line  
            # segment from linked list 
            while (temp != None and temp.x == prev.x): 
                curr.next = temp 
                  
                #free(prev) 
                prev = temp 
                temp = temp.next
              
        # checking equlity of point y 
        elif (temp.y == prev.y): 
            curr = prev 
            prev = temp 
            temp = temp.next
              
            # removing horizontal points of line  
            # segment from linked list 
            while (temp != None and temp.y == prev.y): 
                curr.next = temp 
                #free(prev) 
                prev = temp 
                temp = temp.next
              
        else: 
            prev = temp 
            temp = temp.next
          
# Driver Code 
if __name__=='__main__':  
    head = None
      
    head = push(head, 40, 5) 
    head = push(head, 20, 5) 
    head = push(head, 10, 5) 
    head = push(head, 10, 8) 
    head = push(head, 10, 10) 
    head = push(head, 3, 10) 
    head = push(head, 1, 10) 
    head = push(head, 0, 10) 
      
    print("Given Linked List: \n", end = "") 
    printList(head) 
      
    delete_Middle_Nodes(head) 
      
    print("Modified Linked List: \n", end = "") 
    printList(head) 
      
# This code is contributed by AbhiThakur 

C#

// C# program to remove intermediate  
// points in a linked list that represents 
// horizontal and vertical line segments 
using System; 
      
public class LinkedList 
{ 
    public Node head; // head of list 
  
    /* Linked list Node*/
    public class Node 
    { 
        public int x,y; 
        public Node next; 
        public Node(int x, int y) 
        { 
            this.x = x; 
            this.y = y; 
            next = null; 
        } 
    } 
  
    // This function deletes middle nodes in a sequence of 
    // horizontal and vertical line segments represented 
    // by linked list. 
    private void delete_Middle_Nodes(Node head) 
    { 
        Node prev = head; 
        Node temp = head.next; 
  
        while (temp != null) 
        { 
  
            // checking equlity of point x 
            if (temp.x == prev.x) 
            { 
                Node curr = prev; 
                prev = temp; 
                temp = temp.next; 
  
                // removing vertical points of line  
                // segment from linked list 
                while (temp != null && temp.x == prev.x) 
                { 
                    curr.next = temp; 
                    prev.next = null; 
                    prev = temp; 
                    temp = temp.next; 
                } 
            } 
  
            // checking equlity of point y  
            else if (temp.y == prev.y) 
            { 
                Node curr = prev; 
                prev = temp; 
                temp = temp.next; 
  
                // removing horizontal points of line  
                // segment from linked list 
                while (temp != null && temp.y == prev.y) 
                { 
                    curr.next = temp; 
                    prev.next = null; 
                    prev = temp; 
                    temp = temp.next; 
                } 
            }  
            else
            { 
                prev =temp; 
                temp = temp.next; 
            } 
        } 
    } 
  
    /* Given a reference (pointer to pointer) to the head 
        of a list and an int, push a new node on the front 
        of the list. */
    void push(int x, int y) 
    { 
        /* 1 & 2: Allocate the Node & 
                Put in the data*/
        Node new_node = new Node(x,y); 
  
        /* 3. Make next of new Node as head */
        new_node.next = head; 
  
        /* 4. Move the head to point to new Node */
        head = new_node; 
    } 
  
  
    void printList() 
    { 
        Node temp = head; 
        while (temp != null) 
        { 
            Console.Write("(" + temp.x + "," + temp.y + ")->"); 
            temp = temp.next; 
        } 
        Console.WriteLine(); 
    } 
  
  
    /* Driver code */
    public static void Main(String []args) 
    { 
        LinkedList llist = new LinkedList(); 
  
        llist.push(40,5); 
        llist.push(20,5); 
        llist.push(10,5); 
        llist.push(10,8); 
        llist.push(10,10); 
        llist.push(3,10); 
        llist.push(1,10); 
        llist.push(0,10); 
  
        Console.WriteLine("Given list"); 
        llist.printList(); 
  
        llist.delete_Middle_Nodes(llist.head); 
  
        Console.WriteLine("Modified Linked List is"); 
        llist.printList(); 
    } 
} 
  
/* This code contributed by PrinciRaj1992 */

Output:

 
Given Linked List: 
(0, 10)-> (1, 10)-> (3, 10)-> (10, 10)-> (10, 8)-> (10, 5)-> (20, 5)-> (40, 5)-> 
Modified Linked List: 
(0, 10)-> (10, 10)-> (10, 5)-> (40, 5)->

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes

Recommended Posts:

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : nobody_cares, princiraj1992, abhaysingh290895

Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.

✍
Write a Testimonial