public del_nodes_which_have_greater_value_on_right_side()
{
/*
* Given a singly linked list, remove all the nodes which have a greater value on right side.
*
* Examples:
* a) The list 12->15->10->11->5->6->2->3->NULL should be changed to 15->11->6->3->NULL. Note that 12, 10, 5 and 2 have
* been deleted because there is a greater value on the right side.
*
* When we examine 12, we see that after 12 there is one node with value greater than 12 (i.e. 15), so we delete 12.
* When we examine 15, we find no node after 15 that has value greater than 15 so we keep this node.
* When we go like this, we get 15->6->3
*
*
*
* b) The list 10->20->30->40->50->60->NULL should be changed to 60->NULL. Note that 10, 20, 30, 40 and 50 have been deleted because they all have a greater value on the right side.
*
* c) The list 60->50->40->30->20->10->NULL should not be changed.
*/
int[] tc1 = { 3, 2, 6, 5, 11, 10, 15, 12 };
int[] tc2 = { 40, 30, 20, 10 };
int[] tc3 = { 10, 20, 30, 40 };
create_linked_list obj = new create_linked_list(tc1);
delNode(obj.head);
}
public check_if_linkedlist_is_palindrome()
{
int[] arr1 = { 1, 2, 3, 2, 1 };
create_linked_list obj = new create_linked_list(arr1);
isPalindrome(obj.head);
}
public pairwise_swap_elements_of_linked_list()
{
int[] arr = { 6, 5, 4, 3, 2, 1 };
create_linked_list obj = new create_linked_list(arr);
swap(obj.head);
}
/*
* Given a linked list which is sorted based on absolute values. Sort the list based on actual values.
*
* Examples:
*
* Input : 1 -> -10
* output: -10 -> 1
*
* Input : 1 -> -2 -> -3 -> 4 -> -5
* output: -5 -> -3 -> -2 -> 1 -> 4
*
* Input : -5 -> -10
* Output: -10 -> -5
*/
public sort_linked_list_which_is_already_sorted_with_absolute_values()
{
int[] arr = { -5, 4, -3, -2, 1 };
create_linked_list obj = new create_linked_list(arr);
sort_abosulte_sorted(obj.head);
}
public delete_every_k_node_linkedlist()
{
int[] arr = { 8, 7, 6, 5, 4, 3, 2, 1 };
create_linked_list obj = new create_linked_list(arr);
del_k_node(obj.head, 4);
}
/*Given a Linked List. The Linked List is in alternating ascending and descending orders. Sort the list efficiently.
* Example:
*
* Input List: 10->40->53->30->67->12->89->NULL
* Output List: 10->12->30->40->53->67->89->NULL
*
*
* 10->53->67->89->NULL
* 40->30->12->>NULL -- reverser it 12->30->40
*
*/
public sort_a_linkedlist_that_is_sorted_alternating_asc_and_dsc_order()
{
int[] arr = { 89, 12, 67, 30, 53, 40, 10 };
create_linked_list obj = new create_linked_list(arr);
sortLinkedList(obj.head);
}
public nth_node_from_end_of_linked_list()
{
int[] arr = { 4, 3, 2, 1 };
int n = 3;
create_linked_list obj = new create_linked_list(arr);
nthLastNode(obj.head, n);
}
public detect_and_remove_loop()
{
int[] arr = { 5, 4, 3, 2, 1 };
create_linked_list obj = new create_linked_list(arr);
Node head = createLoop(obj.head);
removeLoop(head);
}
public intersection_of_2_linkedlists()
{
int[] arr1 = { 6, 4, 3, 2, 1 };
create_linked_list obj1 = new create_linked_list(arr1);
int[] arr2 = { 8, 6, 4, 2 };
create_linked_list obj2 = new create_linked_list(arr2);
Node head = intersection(obj1.head, obj2.head);
}
public delete_n_nodes_after_m_nodes()
{
int[] arr1 = { 7, 6, 5, 4, 3, 2, 1 };
create_linked_list obj1 = new create_linked_list(arr1);
int m = 2, n = 2;
del_n_nodes_after_m_nodes(obj1.head, n, m);
}
/*Given two numbers represented by linked lists, write a function that returns the multiplication of these two linked lists.
*
* Examples:
*
* Input : 9->4->6
* 8->4
* Output : 79464
*
* Input : 3->2->1
* 1->2
* Output : 3852
*/
public multiply_2_nos_represented_by_linkedlist()
{
int[] arr1 = { 6, 4, 9 };
create_linked_list obj1 = new create_linked_list(arr1);
int[] arr2 = { 4, 8 };
create_linked_list obj2 = new create_linked_list(arr2);
multipy_2_list(obj1.head, obj2.head);
}
public modify_contents_of_linked_list()
{
int[] arr1 = { 6, 3, 5, 4, 10 };
create_linked_list obj1 = new create_linked_list(arr1);
// modify_list(obj1.head);
int[] arr2 = { 10, 7, 12, 8, 9, 2 };
create_linked_list obj2 = new create_linked_list(arr2);
modify_list(obj2.head);
}
/**
* Given two numbers represented by two lists, write a function that returns the sum list. The sum list is list representation of the addition of two input numbers.
* Input: List1: 5->6->3 // represents number 365
* List2: 8->4->2 // represents number 248
* Output: Resultant list: 3->1->6 // represents number 613
*
*
* Input: List1: 7->5->9->4->6 // represents number 64957
* List2: 8->4 // represents number 48
* Output: Resultant list: 5->0->0->5->6 // represents number 65005
* **/
public add_two_nos_in_a_linkedList()
{
//int[] arr1 = { 3, 6, 5 };
//int[] arr2 = { 2, 4, 8 };
int[] arr1 = { 6, 4, 9, 5, 7 };
int[] arr2 = { 4, 8 };
create_linked_list obj1 = new create_linked_list(arr1);
create_linked_list obj2 = new create_linked_list(arr2);
addtwonos(obj1.head, obj2.head);
}
public sort_0s_1s_and_2s_in_a_linkedlist()
{
/*
* Input: 1 -> 1 -> 2 -> 0 -> 2 -> 0 -> 1 -> NULL
* Output: 0 -> 0 -> 1 -> 1 -> 1 -> 2 -> 2 -> NULL
*
*/
int[] arr = { 1, 0, 2, 0, 2, 1, 1 };
create_linked_list obj = new create_linked_list(arr);
sortLL(obj.head);
}
public del_all_coocurences_of_key_in_linked_list()
{
/*
* Given a singly linked list, delete all occurrences of a given key in it. For example, consider the following list.
* Input: 2 -> 2 -> 1 -> 8 -> 2 -> 3 -> 2 -> 7
* Key to delete = 2
* Output: 1 -> 8 -> 3 -> 7
*/
int[] arr = { 7, 2, 3, 2, 8, 1, 2, 2 };
create_linked_list obj = new create_linked_list(arr);
del_occourenes(obj.head, 2);
}
/*
* Rearrange a linked list such that all even and odd positioned nodes are together
* Rearrange a linked list in such a way that all odd position nodes are together and all even positions node are together,
*
* Examples:
*
* Input: 1->2->3->4
* Output: 1->3->2->4
*
* Input: 10->22->30->43->56->70
* Output: 10->30->56->22->43->70
*/
public rearrange_linkedlist_with_even_and_odd_position_nodes_together()
{
int[] arr1 = { 4, 3, 2, 1 };
Node dummy1 = new Node(0);
Node dummy2 = new Node(0);
create_linked_list obj1 = new create_linked_list(arr1);
rearrange(obj1.head);
int[] arr2 = { 70, 56, 43, 30, 22, 10 };
create_linked_list obj2 = new create_linked_list(arr2);
rearrange(obj2.head);
}
public merge_2_sorted_lineked_list_and_return_new()
{
/*
* For example if the first linked list a is 5->10->15 and the other linked list b is 2->3->20,
* then SortedMerge() should return a pointer to the head node of the merged list 2->3->5->10->15->20.
*/
int[] arr1 = { 15, 10, 5 };
int[] arr2 = { 20, 3, 2 };
create_linked_list obj1 = new create_linked_list(arr1);
create_linked_list obj2 = new create_linked_list(arr2);
Node newlist = new Node(0);
MergeLinkedList(obj1.head, obj2.head, newlist);
newlist = newlist.next;
}
void addtwonos(Node head1, Node head2)
{
List <int> res = new List <int>();
int carryAhead = 0;
while (head1 != null || head2 != null)
{
int data1 = 0;
int data2 = 0;
if (head1 != null)
{
data1 = head1.data;
}
if (head2 != null)
{
data2 = head2.data;
}
int temp_res = data1 + data2 + carryAhead;
if (temp_res <= 9)
{
res.Add(temp_res);
carryAhead = 0;
}
else
{
carryAhead = temp_res / 10;
res.Add(temp_res % 10);
}
if (head1 != null)
{
head1 = head1.next;
}
if (head2 != null)
{
head2 = head2.next;
}
}
create_linked_list resLinkedList = new create_linked_list(res.ToArray());
}
public sorted_insert_in_circular_linked_list()
{
int[] arr = { 5, 3, 2, 1 };
create_linked_list obj = new create_linked_list(arr);
// make LL circular
Node cur = obj.head;
while (cur.next != null)
{
cur = cur.next;
}
cur.next = obj.head;
insert_in_circular_linked_list(obj.head, 4);
}
public seperate_even_and_odd_nodes_in_linked_list()
{
/*
* Given a Linked List of integers, write a function to modify the linked list such that all even numbers appear before all the odd numbers in the modified linked list. Also, keep the order of even and odd numbers same.
*
* Examples:
*
* Input: 17->15->8->12->10->5->4->1->7->6->NULL
* Output: 8->12->10->4->6->17->15->5->1->7->NULL
*
* Input: 8->12->10->5->4->1->6->NULL
* Output: 8->12->10->4->6->5->1->NULL
*
*/
int[] arr = { 6, 7, 1, 4, 5, 10, 12, 8, 15, 17 };
create_linked_list obj = new create_linked_list(arr);
seperate(obj.head);
}
public given_only_pointer_for_node_tobe_deleted_delete_the_node()
{
int[] arr = { 1, 2, 3, 4, 5, 6 };
create_linked_list obj = new create_linked_list(arr);
}
