Given a linked list of line segments, remove middle points

#include 
#include 
 
struct Node
{
    int x, y;
    struct Node *next;
};
 
void push(struct Node ** head_ref, int x,int y)
{
    struct Node* new_node =
           (struct Node*) malloc(sizeof(struct Node));
    new_node->x  = x;
    new_node->y  = y;
    new_node->next = (*head_ref);
    (*head_ref)  = new_node;
}
 
void printList(struct Node *head)
{
    struct Node *temp = head;
    while (temp != NULL)
    {
        printf("(%d,%d)-> ", temp->x,temp->y);
        temp = temp->next;
    }
    printf("\n");
 
}
 
void deleteNode(struct Node *head, struct Node *Next)
{
    head->next = Next->next;
    Next->next = NULL;
    free(Next);
}
 
struct Node* deleteMiddle(struct Node *head)
{
    // If only one node or no node...Return back
    if (head==NULL || head->next ==NULL || head->next->next==NULL)
        return head;
 
    struct Node* Next = head->next;
    struct Node *NextNext = Next->next ;
 
    // Check if this is a vertical line or horizontal line
    if (head->x == Next->x)
    {
        // Find middle nodes with same x value, and delete them
        while (NextNext !=NULL && Next->x==NextNext->x)
        {
            deleteNode(head, Next);
 
            // Update Next and NextNext for next iteration
            Next = NextNext;
            NextNext = NextNext->next;
        }
    }
    else if (head->y==Next->y) // If horizontal line
    {
        // Find middle nodes with same y value, and delete them
        while (NextNext !=NULL && Next->y==NextNext->y)
        {
            deleteNode(head, Next);
 
            // Update Next and NextNext for next iteration
            Next = NextNext;
            NextNext = NextNext->next;
        }
    }
    else  // Adjacent points must have either same x or same y
    {
        puts("Given linked list is not valid");
        return NULL;
    }
 
    // Recur for next segment
    deleteMiddle(head->next);
 
    return head;
}
 
// 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);
 
    if (deleteMiddle(head) != NULL);
    {
        printf("Modified Linked List: \n");
        printList(head);
    }
    return 0;
}

class LineSegment
{
	Node head; 
	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. */
	Node deleteMiddle()
	{
		// If only one node or no node...Return back
		if (head == null || head.next == null ||
			head.next.next == null)
			return head;

		Node Next = head.next;
		Node NextNext = Next.next;

		// check if this is vertical or horizontal line
		if (head.x == Next.x)
		{
			// Find middle nodes with same value as x and
			// delete them.
			while (NextNext != null && Next.x == NextNext.x)
			{
				head.next = Next.next;
				Next.next = null;

				// Update NextNext for the next iteration
				Next = NextNext;
				NextNext = NextNext.next;
			}
		}

		// if horizontal
		else if (head.y == Next.y)
		{
			// find middle nodes with same value as y and
			// delete them
			while (NextNext != null && Next.y == NextNext.y)
			{
				head.next = Next.next;
				Next.next = null;

				// Update NextNext for the next iteration
				Next = NextNext;
				NextNext = NextNext.next;
			}
		}
		// Adjacent points should have same x or same y
		else
		{
			System.out.println("Given list is not valid");
			return null;
        }
		// temporarily store the head and move head forward.
		Node temp = head;
		head = head.next;

		// call deleteMiddle() for next segment
		this.deleteMiddle();

		// restore head
		head = temp;
		return head;
	}
	void push(int x, int y)
	{
		Node new_node = new Node(x,y);
		new_node.next = head;
		head = new_node;
	}
	void printList()
	{
		Node temp = head;
		while (temp != null)
		{
			System.out.print("("+temp.x+","+temp.y+")->");
			temp = temp.next;
		}
		System.out.println("NULL");
	}


	/* Driver program to test above functions */
	public static void main(String args[])
	{
		LineSegment llist = new LineSegment();

		llist.push(4,3);
		llist.push(7,3);
		llist.push(10,3);
		llist.push(10,4);
		llist.push(10,7);
		llist.push(10,8);
		
		System.out.println("Given list");
		llist.printList();

		if (llist.deleteMiddle() != null)
		{
			System.out.println("Modified Linked List is");
			llist.printList();
		}
	}
} 

class LinkedList(object):
	def __init__(self):
		self.head = None

	class Node(object):
		def __init__(self, x, y):
			self.x = x
			self.y = y
			self.next = None

	def deleteMiddle(self):
		curr = self.head.next
		prev = self.head
		while curr:

			if curr.x == prev.x:

				start = prev
				prev = curr
				curr = curr.next

				while curr and curr.x == prev.x:
					start.next = curr
					del prev
					prev = curr
					curr = curr.next

			elif curr.y == prev.y:

				start = prev
				prev = curr
				curr = curr.next

				while curr and curr.y == prev.y:
					start.next = curr
					del prev
					prev = curr
					curr = curr.next

			else:
				prev = curr
				curr = curr.next



	def push(self, x, y):

		new_node = self.Node(x, y)
		new_node.next = self.head
		self.head = new_node

	def printList(self):
		temp = self.head
		while temp != None:
			print ("(" + str(temp.x) + "," + str(temp.y) + ")->",end=" ")
			temp = temp.next
		print ("Null")

# Driver program
llist = LinkedList()
llist.push(10,8)
llist.push(10,7)
llist.push(10,4)
llist.push(10,3)
llist.push(7,3)
llist.push(4,3)

print ("Given list")
llist.printList()

llist.deleteMiddle()
print ("Modified Linked List is")
llist.printList()