Open In App

Longest increasing sublist in a linked list

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

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 beginning
void 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 functions
int 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 beginning
static 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 Code
public 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 math
 
class 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 Code
if __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 beginning
static 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 Code
public 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)

 



Last Updated : 23 Jan, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads