Longest increasing sublist in a linked list

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 then 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 then 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;
}
  
// Drier 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 then 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 then 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

chevron_right


Output:

Linked list:
15 18 5 8 11 12 
Number of continuously increasing element in list :4
Increasing linked list
5 8 11 12

This article is contributed by Dharmendra kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks 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.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.