Open In App

Check if linked list is sorted (Iterative and Recursive)

Improve
Improve
Like Article
Like
Save
Share
Report

Given a Linked List, task is to check whether the Linked List is sorted in Descending order or not? 

Examples :  

Input  : 8 -> 7 -> 5 -> 2 -> 1
Output : Yes
Explanation :
In given linked list, starting from head,
8 > 7 > 5 > 2 > 1. So, it is sorted in reverse order

Input  : 24 -> 12 -> 9 -> 11 -> 8 -> 2
Output : No

Iterative Approach: Traverse the linked list from head to end. For every newly encountered element, check node -> data > node -> next -> data. If True, do same for each node else return 0 and Print “No”.  

Implementation:

C++




// C++ program to check Linked List is sorted
// in descending order or not
#include <bits/stdc++.h>
using namespace std;
 
/* Linked list node */
struct Node
{
    int data;
    struct Node* next;
};
 
// function to Check Linked List is
// sorted in descending order or not
bool isSortedDesc(struct Node *head)
{
    if (head == NULL)
        return true;
 
    // Traverse the list till last node and return
    // false if a node is smaller than or equal
    // its next.
    for (Node *t=head; t->next != NULL; t=t->next)
       if (t->data <= t->next->data)
            return false;
    return true;
}
 
Node *newNode(int data)
{
   Node *temp = new Node;
   temp->next = NULL;
   temp->data = data;
}
 
// Driver program to test above
int main()
{
    struct Node *head = newNode(7);
    head->next = newNode(5);
    head->next->next = newNode(4);
    head->next->next->next = newNode(3);
        
    isSortedDesc(head) ? cout << "Yes" :
                         cout << "No";
     
    return 0;
}


Java




// Java program to check Linked List is sorted
// in descending order or not
class GFG
{
 
/* Linked list node */
static class Node
{
    int data;
    Node next;
};
 
// function to Check Linked List is
// sorted in descending order or not
static boolean isSortedDesc(Node head)
{
    if (head == null)
        return true;
 
    // Traverse the list till last node and return
    // false if a node is smaller than or equal
    // its next.
    for (Node t = head; t.next != null; t = t.next)
    if (t.data <= t.next.data)
            return false;
    return true;
}
 
static Node newNode(int data)
{
    Node temp = new Node();
    temp.next = null;
    temp.data = data;
    return temp;
}
 
// Driver Code
public static void main(String[] args)
{
    Node head = newNode(7);
    head.next = newNode(5);
    head.next.next = newNode(4);
    head.next.next.next = newNode(3);
         
    if(isSortedDesc(head))
        System.out.println("Yes");
    else
        System.out.println("No");
}
}
 
// This code is contributed by 29AjayKumar


Python3




# Python3 program to check Linked List is sorted
# in descending order or not
''' Linked list Node '''
 
class Node:
    def __init__(self, data):
        self.data = data;
        self.next = next;
 
# function to Check Linked List is
# sorted in descending order or not
def isSortedDesc(head):
    if (head == None):
        return True;
 
    # Traverse the list till last Node and return
    # False if a Node is smaller than or equal
    # its next.
    while(head.next != None):
        t = head;
        if (t.data <= t.next.data):
            return False;
        head = head.next
    return True;
 
def newNode(data):
    temp = Node(0);
    temp.next = None;
    temp.data = data;
    return temp;
 
# Driver Code
if __name__ == '__main__':
    head = newNode(7);
    head.next = newNode(5);
    head.next.next = newNode(4);
    head.next.next.next = newNode(3);
 
    if (isSortedDesc(head)):
        print("Yes");
    else:
        print("No");
 
# This code is contributed by 29AjayKumar


C#




// C# program to check Linked List is sorted
// in descending order or not
using System;
     
class GFG
{
 
/* Linked list node */
public class Node
{
    public int data;
    public Node next;
};
 
// function to Check Linked List is
// sorted in descending order or not
static bool isSortedDesc(Node head)
{
    if (head == null)
        return true;
 
    // Traverse the list till last node and
    // return false if a node is smaller than
    // or equal to its next.
    for (Node t = head;
              t.next != null; t = t.next)
    if (t.data <= t.next.data)
            return false;
    return true;
}
 
static Node newNode(int data)
{
    Node temp = new Node();
    temp.next = null;
    temp.data = data;
    return temp;
}
 
// Driver Code
public static void Main(String[] args)
{
    Node head = newNode(7);
    head.next = newNode(5);
    head.next.next = newNode(4);
    head.next.next.next = newNode(3);
         
    if(isSortedDesc(head))
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
}
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
 
      // JavaScript program to recursively check Linked List
      // is sorted in descending order or not
      /* Linked list node */
      class Node {
        constructor() {
          this.data = 0;
          this.next = null;
        }
      }
 
      // function to Check Linked List is
      // sorted in descending order or not
      function isSortedDesc(head) {
        // Base cases
        if (head == null || head.next == null) return true;
 
        // Check first two nodes and recursively
        // check remaining.
        return head.data > head.next.data && isSortedDesc(head.next);
      }
 
      function newNode(data) {
        var temp = new Node();
        temp.next = null;
        temp.data = data;
        return temp;
      }
 
      // Driver code
      var head = newNode(7);
      head.next = newNode(5);
      head.next.next = newNode(4);
      head.next.next.next = newNode(3);
 
      if (isSortedDesc(head) == true) document.write("Yes");
      else document.write("No");
       
</script>


Output

Yes

Time Complexity : O(N), where N is the length of linked list.

Auxiliary Space: O(1) because it is using constant variables

Recursive Approach: Check Recursively that node -> data > node -> next -> data, If not, return 0 that is our terminated condition to come out from recursion else Call Check_List Function Recursively for next node. 

Implementation:

C++




// C++ program to recursively check Linked List
// is sorted in descending order or not
#include <bits/stdc++.h>
using namespace std;
 
/* Linked list node */
struct Node
{
    int data;
    struct Node* next;
};
 
// function to Check Linked List is
// sorted in descending order or not
bool isSortedDesc(struct Node *head)
{
    // Base cases
    if (head == NULL || head->next == NULL)
        return true;
     
    // Check first two nodes and recursively
    // check remaining.  
    return (head->data > head->next->data &&
        isSortedDesc(head->next));
}
 
Node *newNode(int data)
{
   Node *temp = new Node;
   temp->next = NULL;
   temp->data = data;
}
 
// Driver program to test above
int main()
{
    struct Node *head = newNode(7);
    head->next = newNode(5);
    head->next->next = newNode(4);
    head->next->next->next = newNode(3);
        
    isSortedDesc(head) ? cout << "Yes" :
                         cout << "No";
     
    return 0;
}


Java




// Java program to recursively check Linked List
// is sorted in descending order or not
class GfG {
 
/* Linked list node */
static class Node
{
    int data;
    Node next;
}
 
// function to Check Linked List is
// sorted in descending order or not
static boolean isSortedDesc(Node head)
{
    // Base cases
    if (head == null || head.next == null)
        return true;
     
    // Check first two nodes and recursively
    // check remaining.
    return (head.data > head.next.data && isSortedDesc(head.next));
}
 
static Node newNode(int data)
{
Node temp = new Node();
temp.next = null;
temp.data = data;
return temp;
}
 
// Driver program to test above
public static void main(String[] args)
{
    Node head = newNode(7);
    head.next = newNode(5);
    head.next.next = newNode(4);
    head.next.next.next = newNode(3);
         
    if(isSortedDesc(head) == true)
    System.out.println("Yes");
    else
    System.out.println("No");
     
}
}


Python3




# Python3 program to recursively check
# Linked List is sorted in descending
# order or not
  
# Linked list node
class Node:
     
    def __init__(self, data):
         
        self.data = data
        self.next = None
 
# Function to Check Linked List is
# sorted in descending order or not
def isSortedDesc(head):
     
    # Base cases
    if (head == None or head.next == None):
        return True
      
    # Check first two nodes and recursively
    # check remaining.  
    return (head.data > head.next.data and
           isSortedDesc(head.next))
 
def newNode(data):
 
   temp = Node(data)
   return temp
    
# Driver code
if __name__=="__main__":
     
    head = newNode(7)
    head.next = newNode(5)
    head.next.next = newNode(4)
    head.next.next.next = newNode(3)
         
    if isSortedDesc(head):
        print("Yes")
    else:
        print("No")
 
# This code is contributed by rutvik_56


C#




// C# program to recursively check Linked List
// is sorted in descending order or not
using System;
 
class GfG
{
 
/* Linked list node */
public class Node
{
    public int data;
    public Node next;
}
 
// function to Check Linked List is
// sorted in descending order or not
static bool isSortedDesc(Node head)
{
    // Base cases
    if (head == null || head.next == null)
        return true;
     
    // Check first two nodes and recursively
    // check remaining.
    return (head.data > head.next.data &&
                    isSortedDesc(head.next));
}
 
static Node newNode(int data)
{
    Node temp = new Node();
    temp.next = null;
    temp.data = data;
    return temp;
}
 
// Driver code
public static void Main(String[] args)
{
    Node head = newNode(7);
    head.next = newNode(5);
    head.next.next = newNode(4);
    head.next.next.next = newNode(3);
         
    if(isSortedDesc(head) == true)
    Console.WriteLine("Yes");
    else
    Console.WriteLine("No");
     
}
}
 
// This code contributed by Rajput-Ji


Javascript




<script>
    // Javascript program to recursively check Linked List
    // is sorted in descending order or not
    class Node
    {
        constructor(data) {
           this.next = null;
           this.data = data;
        }
    }
     
    // function to Check Linked List is
    // sorted in descending order or not
    function isSortedDesc(head)
    {
        // Base cases
        if (head == null || head.next == null)
            return true;
 
        // Check first two nodes and recursively
        // check remaining.
        return (head.data > head.next.data &&
                        isSortedDesc(head.next));
    }
 
    function newNode(data)
    {
        let temp = new Node(data);
        return temp;
    }
     
    let head = newNode(7);
    head.next = newNode(5);
    head.next.next = newNode(4);
    head.next.next.next = newNode(3);
          
    if(isSortedDesc(head) == true)
        document.write("Yes");
    else
        document.write("No");
     
    // This code is contributed by divyeshrabadiya07.
</script>


Output

Yes

Complexities Analysis:

  • Time complexity: O(N) where N is no of nodes in linked list.
  • Auxiliary Space: O(N)


Last Updated : 01 Sep, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads