Given a singly linked list and we want to count the elements that are continuously increasing and print the increasing linked list.
Examples:
Input : 8 -> 5 -> 7 -> 10 -> 9 -> 11 -> 12 -> 13 -> NULL
Output : Number of continuously increasing elements = 4
Increasing linked list : 9 11 12 13
Input : 5 -> 12 -> 18 -> 7 -> 12 -> 15 -> NULL
Output : Number of continuously increasing elements = 3
Increasing linked list = 5 12 18
The idea is to traverse singly linked list and compare curr->data with curr->next->data where curr is current node being traversed. If curr->data is smaller than curr->next->data then curr pointer point to curr->next and increment the length (continuous increasing element) by one. If the condition is false then compare the length with max and if max is less than len then assign the len value to max. Continue this process until head not equal to NULL. Also find the starting index of continuous increasing element. Next traverse the linked list and display the continuous increasing element in linked list.
C++
// Program to count maximum number of continuous// increasing element in linked list and display// the elements of linked list.#include <bits/stdc++.h>using namespace std;struct Node { int data; struct Node* next;};// Function that count maximum number of continuous// increasing elements in linked list and display// the list.void countIncreasingElements(struct Node *head){ // Traverse the list and keep track of max increasing // and current increasing lengths int curr_len = 1, max_len = 1; int total_count = 1, res_index = 0; for (Node *curr=head; curr->next!=NULL; curr=curr->next) { // Compare head->data with head->next->data if (curr->data < curr->next->data) curr_len++; else { // compare maximum length with len. if (max_len < curr_len) { max_len = curr_len; res_index = total_count - curr_len; } curr_len = 1; } total_count++; } if (max_len < curr_len) { max_len = curr_len; res_index = total_count - max_len; } // Print the maximum number of continuous elements // in linked list. cout << "Number of continuously increasing element" " in list : "; cout << max_len << endl; // Traverse the list again to print longest increasing // sublist int i = 0; cout << "Increasing linked list" << endl; for (Node* curr=head; curr!=NULL; curr=curr->next) { // compare with starting index and index of // maximum increasing elements if both are // equals then execute it. if (i == res_index) { // loop until max greater than 0. while (max_len > 0) { // Display the list and temp point // to the next element. cout << curr->data << " "; curr = curr->next; max_len--; } break; } i++; }}// Function to insert an element at the beginningvoid push(struct Node** head, int data){ struct Node* newNode = new Node; newNode->data = data; newNode->next = (*head); (*head) = newNode;}// Display linked list.void printList(struct Node* node){ while (node != NULL) { cout << node->data << " "; node = node->next; } cout << endl;}// Driver functionsint main(){ // Create a node and initialize with NULL struct Node* head = NULL; // push() insert node in linked list. // 15 -> 18 -> 5 -> 8 -> 11 -> 12 push(&head, 12); push(&head, 11); push(&head, 8); push(&head, 5); push(&head, 18); push(&head, 15); cout << "Linked list:" << endl; printList(head); // Function call countIncreasingElements(head) // cout << countIncreasingElements(head) << endl; countIncreasingElements(head); return 0;} |
Java
// A Java Program to count maximum number // of continuous increasing element in// linked list and display the elements// of linked list.import java.util.*;class GFG { static class Node { int data; Node next;}static Node head;// Function that count maximum number // of continuous increasing elements // in linked list and display the list.static void countIncreasingElements(Node head){ // Traverse the list and keep track // of max increasing and // current increasing lengths int curr_len = 1, max_len = 1; int total_count = 1, res_index = 0; for (Node curr = head; curr.next != null; curr = curr.next) { // Compare head.data with head.next.data if (curr.data < curr.next.data) curr_len++; else { // compare maximum length with len. if (max_len < curr_len) { max_len = curr_len; res_index = total_count - curr_len; } curr_len = 1; } total_count++; } if (max_len < curr_len) { max_len = curr_len; res_index = total_count - max_len; } // Print the maximum number of // continuous elements in linked list. System.out.print("Number of continuously " + "increasing element in list : "); System.out.println(max_len); // Traverse the list again to print // longest increasing sublist int i = 0; System.out.println("Increasing linked list"); for (Node curr = head; curr != null; curr = curr.next) { // compare with starting index and index of // maximum increasing elements if both are // equals then execute it. if (i == res_index) { // loop until max greater than 0. while (max_len > 0) { // Display the list and temp point // to the next element. System.out.print(curr.data + " "); curr = curr.next; max_len--; } break; } i++; }}// Function to insert an element at the beginningstatic void push(Node head_ref, int data){ Node newNode = new Node(); newNode.data = data; newNode.next = head_ref; head_ref = newNode; head = head_ref;}// Display linked list.static void printList(Node node){ while (node != null) { System.out.print(node.data + " "); node = node.next; } System.out.println();}// Driver Codepublic static void main(String[] args){ // Create a node and initialize with null head = null; // push() insert node in linked list. // 15 -> 18 -> 5 -> 8 -> 11 -> 12 push(head, 12); push(head, 11); push(head, 8); push(head, 5); push(head, 18); push(head, 15); System.out.println("Linked list:"); printList(head); // Function call countIncreasingElements(head) countIncreasingElements(head);}}// This code is contributed by Princi Singh |
Python3
# Program to count maximum number of continuous # increasing element in linked list and display # the elements of linked list. import mathclass Node: def __init__(self, data): self.data = data self.next = None# Function that count maximum number of continuous # increasing elements in linked list and display # the list. def countIncreasingElements(head): # Traverse the list and keep track of # max increasing and current increasing lengths curr_len = 1 max_len = 1 total_count = 1 res_index = 0 curr = head while(curr.next != None): # Compare head.data with head.next.data if (curr.data < curr.next.data): curr_len = curr_len + 1 else: # compare maximum length with len. if (max_len < curr_len): max_len = curr_len res_index = total_count - curr_len curr_len = 1 total_count = total_count + 1 curr = curr.next if (max_len < curr_len): max_len = curr_len res_index = total_count - max_len # Print the maximum number of # continuous elements in linked list. print("Number of continuously increasing", "element in list : ", end = "") print(max_len) # Traverse the list again to print # longest increasing sublist i = 0 print("Increasing linked list") curr = head while(curr != None): # compare with starting index and index of # maximum increasing elements if both are # equals then execute it. if (i == res_index): # loop until max greater than 0. while (max_len > 0): # Display the list and temp point # to the next element. print(curr.data, end = " ") curr = curr.next max_len = max_len - 1 break i = i + 1 curr = curr.next# Function to insert an element# at the beginning def push(head, data): newNode = Node(data) newNode.data = data newNode.next = head head = newNode return head# Display linked list. def printList(node) : while (node != None): print(node.data, end = " ") node = node.next print() # Driver Codeif __name__=='__main__': # Create a node and initialize with None head = None # push() insert node in linked list. # 15 . 18 . 5 . 8 . 11 . 12 head = push(head, 12) head = push(head, 11) head = push(head, 8) head = push(head, 5) head = push(head, 18) head = push(head, 15) print("Linked list:") printList(head) # Function call countIncreasingElements(head) countIncreasingElements(head) # This code is contributed by Srathore |
C#
// C# Program to count maximum number // of continuous increasing element in// linked list and display the elements// of linked list.using System; class GFG { class Node { public int data; public Node next;}static Node head;// Function that count maximum number // of continuous increasing elements // in linked list and display the list.static void countIncreasingElements(Node head){ // Traverse the list and keep track // of max increasing and // current increasing lengths int curr_len = 1, max_len = 1; int total_count = 1, res_index = 0; for (Node curr = head; curr.next != null; curr = curr.next) { // Compare head.data with head.next.data if (curr.data < curr.next.data) curr_len++; else { // compare maximum length with len. if (max_len < curr_len) { max_len = curr_len; res_index = total_count - curr_len; } curr_len = 1; } total_count++; } if (max_len < curr_len) { max_len = curr_len; res_index = total_count - max_len; } // Print the maximum number of // continuous elements in linked list. Console.Write("Number of continuously " + "increasing element in list : "); Console.WriteLine(max_len); // Traverse the list again to print // longest increasing sublist int i = 0; Console.WriteLine("Increasing linked list"); for (Node curr = head; curr != null; curr = curr.next) { // compare with starting index and index of // maximum increasing elements if both are // equals then execute it. if (i == res_index) { // loop until max greater than 0. while (max_len > 0) { // Display the list and temp point // to the next element. Console.Write(curr.data + " "); curr = curr.next; max_len--; } break; } i++; }}// Function to insert an element at the beginningstatic void push(Node head_ref, int data){ Node newNode = new Node(); newNode.data = data; newNode.next = head_ref; head_ref = newNode; head = head_ref;}// Display linked list.static void printList(Node node){ while (node != null) { Console.Write(node.data + " "); node = node.next; } Console.WriteLine();}// Driver Codepublic static void Main(String[] args){ // Create a node and initialize with null head = null; // push() insert node in linked list. // 15 -> 18 -> 5 -> 8 -> 11 -> 12 push(head, 12); push(head, 11); push(head, 8); push(head, 5); push(head, 18); push(head, 15); Console.WriteLine("Linked list:"); printList(head); // Function call countIncreasingElements(head) countIncreasingElements(head);}}// This code is contributed by PrinciRaj1992 |
Javascript
<script> // JavaScript Program to count maximum number // of continuous increasing element in // linked list and display the elements // of linked list. class Node { constructor() { this.data = 0; this.next = null; } } var head = null; // Function that count maximum number // of continuous increasing elements // in linked list and display the list. function countIncreasingElements(head) { // Traverse the list and keep track // of max increasing and // current increasing lengths var curr_len = 1, max_len = 1; var total_count = 1, res_index = 0; for (var curr = head; curr.next != null; curr = curr.next) { // Compare head.data with head.next.data if (curr.data < curr.next.data) curr_len++; else { // compare maximum length with len. if (max_len < curr_len) { max_len = curr_len; res_index = total_count - curr_len; } curr_len = 1; } total_count++; } if (max_len < curr_len) { max_len = curr_len; res_index = total_count - max_len; } // Print the maximum number of // continuous elements in linked list. document.write( "Number of continuously " + "increasing element in list : " ); document.write(max_len + "<br>"); // Traverse the list again to print // longest increasing sublist var i = 0; document.write("Increasing linked list <br>"); for (var curr = head; curr != null; curr = curr.next) { // compare with starting index and index of // maximum increasing elements if both are // equals then execute it. if (i == res_index) { // loop until max greater than 0. while (max_len > 0) { // Display the list and temp point // to the next element. document.write(curr.data + " "); curr = curr.next; max_len--; } break; } i++; } } // Function to insert an element at the beginning function push(head_ref, data) { var newNode = new Node(); newNode.data = data; newNode.next = head_ref; head_ref = newNode; head = head_ref; } // Display linked list. function printList(node) { while (node != null) { document.write(node.data + " "); node = node.next; } document.write("<br>"); } // Driver Code // Create a node and initialize with null head = null; // push() insert node in linked list. // 15 -> 18 -> 5 -> 8 -> 11 -> 12 push(head, 12); push(head, 11); push(head, 8); push(head, 5); push(head, 18); push(head, 15); document.write("Linked list: <br>"); printList(head); // Function call countIncreasingElements(head) countIncreasingElements(head); </script> |
Output:
Linked list: 15 18 5 8 11 12 Number of continuously increasing element in list :4 Increasing linked list 5 8 11 12
Time Complexity: O(N)
Space Complexity: O(1)
This article is contributed by Dharmendra kumar. If you like neveropen and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the neveropen main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
