Dada una lista enlazada individualmente, queremos contar los elementos que aumentan continuamente e imprimir la lista enlazada creciente.
Ejemplos:
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
La idea es recorrer una lista enlazada individualmente y comparar curr->data con curr->next->data donde curr es el Node actual que se está atravesando. Si curr->data es más pequeño que curr->next->data, entonces el puntero de curr apunta a curr->next e incrementa la longitud (elemento de aumento continuo) en uno. Si la condición es falsa, compare la longitud con max y si max es menor que len, asigne el valor de len a max. Continúe este proceso hasta que head no sea igual a NULL. También encuentre el índice inicial del elemento creciente continuo. A continuación, recorra la lista vinculada y muestre el elemento de aumento continuo en la lista vinculada.
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 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;
}
// 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 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
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 then 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 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
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 then 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>
Producción:
Linked list: 15 18 5 8 11 12 Number of continuously increasing element in list :4 Increasing linked list 5 8 11 12
Este artículo es una contribución de Dharmendra kumar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA