#include "pch.h"
#include <iostream>


struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(nullptr) {}
};

int listSize(ListNode* head) {
	ListNode* curr = head;
	int counter = 1;
	while (curr->next != nullptr)
	{
		curr = curr->next;
		counter++;
	}
	return counter;
}

class Solution {
public:

	ListNode* deleteDuplicates(ListNode* head) {
		ListNode*holder = head;
		ListNode*curr = head;
		ListNode* prev = head;
		ListNode*temp = nullptr;
		bool flag = false;

		while (holder->next != nullptr)
		{
			while (curr->next->next != nullptr)
			{
				if (holder->val == curr->next->val)
				{
					flag = true;
					temp = curr->next;
					curr->next = curr->next->next;
					temp = nullptr;
					delete temp;
				}
				else
				{
					curr = curr->next;
				}
			}

			if (flag = true)
			{
				if (head == holder)
				{
					removeFirstNode(head);
					holder = head;
					prev = head;
					flag = false;
				}
				else
				{
					temp = holder;
					holder = holder->next;
					prev->next = holder;
					temp = nullptr;
					delete temp;
					flag = false;
				}
			}

			prev = holder;
			holder = holder->next;
			curr = holder;
		}
		return head;
	}
	ListNode* removeNthFromEnd(ListNode* head, int n) {

		if (head == nullptr) return nullptr;

		ListNode* prev = nullptr;
		ListNode* curr = head;
		ListNode* temp = nullptr;
		int length = listSize(head) - n;

		while (length > 0) {
			prev = curr;
			curr = curr->next;
			length--;
		}

		if (curr == head) {
			removeFirstNode(head);
		}

		else {
			temp = curr;
			curr = curr->next;
			prev->next = curr;
			temp = nullptr;
			delete temp;
		}

		return head;
	}

	ListNode* removeFirstNode(struct ListNode* head)
	{
		if (head == nullptr)
			return nullptr;

		ListNode* temp = head;
		head->val = head->next->val;
		head->next = head->next->next;

		temp = nullptr;
		delete[]temp;

		return head;
	}

	ListNode* oddEvenList(ListNode* head) {
		ListNode* odd = head;
		ListNode* even = head->next;
		ListNode* evenHead = head->next;
		while (even->next != nullptr && odd->next!=nullptr)
		{
			odd->next = even->next;
			odd = odd->next;
			even->next = odd->next;
			even = even->next;
		}
		odd->next = evenHead;

		return head;
	}
};


void print(ListNode* head)
{
	ListNode* temp = head;
	while (temp != nullptr)
	{
		std::cout << temp->val << " ";
		temp = temp->next;
	}
	std::cout << std::endl;

}

int main() {
	ListNode* l1 = new ListNode(1);
	ListNode* l2 = new ListNode(5);
	ListNode* l3 = new ListNode(2);
	ListNode* l4 = new ListNode(6);
	ListNode* l5 = new ListNode(3);
	ListNode* l6 = new ListNode(7);
	ListNode* l7 = new ListNode(4);

	l1->next = l2;
	l2->next = l3;
	l3->next = l4;
	l4->next = l5;
	l5->next = l6;
	l6->next = l7;


	Solution s1;

	print(l1);

	//s1.removeNthFromEnd(l1, 4);
	//s1.deleteDuplicates(l1);
	//s1.oddEvenList(l1);
	print(l1);