给定链表中的双音点

给定具有不同元素的链表，任务是在给定链表中找到双音点。如果没有该点，则打印-1 。
例子：

Input: 1 -> 2 -> 3 -> 4 -> 3 -> 2 -> 1 -> NULL 
Output: 4 
1 -> 2 -> 3 -> 4 is strictly increasing. 
4 -> 3 -> 2 -> 1 -> NULL is strictly decreasing.
Input: 97 -> 98 -> 99 -> 91 -> NULL 
Output: 99 
 

方法：双音点是双音序列中的一个点，在该点之前元素严格增加，而在元素之后严格减少。如果数组仅在减少或仅在增加，则不存在双音点。因此，找到第一个节点，以使其旁边的节点的值严格较小。从该节点开始遍历链表，如果每个其他节点都严格小于其先前的节点，则找到的节点不在重音序列上，否则给定的链表不包含有效的重音序列。请注意，空列表或具有单个节点的列表并不代表有效的双音序列。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Node for linked list
class Node {
public:
    int data;
    Node* next;
};
 
// Function to insert a node at
// the head of the linked list
Node* push(Node** head_ref, int data)
{
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
 
// Function to return the bitonic
// of the given linked list
int bitonic_point(Node* node)
{
    // If list is empty
    if (node == NULL)
        return -1;
 
    // If list contains only
    // a single node
    if (node->next == NULL)
        return -1;
 
    // Invalid bitonic sequence
    if (node->data > node->next->data)
        return -1;
 
    while (node->next != NULL) {
 
        // If current node is the bitonic point
        if (node->data > node->next->data)
            break;
 
        // Get to the next node in the list
        node = node->next;
    }
 
    int bitonicPoint = node->data;
    // Nodes must be in descending
    // starting from here
    while (node->next != NULL) {
 
        // Out of order node
        if (node->data < node->next->data)
            return -1;
 
        // Get to the next node in the list
        node = node->next;
    }
 
    return bitonicPoint;
}
 
// Driver code
int main()
{
    Node* head = NULL;
 
    push(&head, 100);
    push(&head, 201);
    push(&head, 399);
    push(&head, 490);
    push(&head, 377);
    push(&head, 291);
    push(&head, 100);
 
    cout << bitonic_point(head);
 
    return 0;
}

Java

// Java implementation of the approach
class GFG
{
     
// Node for linked list
static class Node
{
    int data;
    Node next;
};
 
// Function to insert a node at
// the head of the linked list
static Node push(Node head_ref, int data)
{
    Node new_node = new Node();
    new_node.data = data;
    new_node.next = (head_ref);
    (head_ref) = new_node;
    return head_ref;
}
 
// Function to return the bitonic
// of the given linked list
static int bitonic_point(Node node)
{
    // If list is empty
    if (node == null)
        return -1;
 
    // If list contains only
    // a single node
    if (node.next == null)
        return -1;
 
    // Invalid bitonic sequence
    if (node.data > node.next.data)
        return -1;
 
    while (node.next != null)
    {
 
        // If current node is the bitonic point
        if (node.data > node.next.data)
            break;
 
        // Get to the next node in the list
        node = node.next;
    }
 
    int bitonicPoint = node.data;
     
    // Nodes must be in descending
    // starting from here
    while (node.next != null)
    {
 
        // Out of order node
        if (node.data < node.next.data)
            return -1;
 
        // Get to the next node in the list
        node = node.next;
    }
 
    return bitonicPoint;
}
 
// Driver code
public static void main(String args[])
{
    Node head = null;
 
    head=push(head, 100);
    head=push(head, 201);
    head=push(head, 399);
    head=push(head, 490);
    head=push(head, 377);
    head=push(head, 291);
    head=push(head, 100);
 
    System.out.println(bitonic_point(head));
}
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 implementation of the approach
  
# Node for linked list
class Node:  
    def __init__(self, data):
        self.data = data
        self.next = None
  
# Function to insert a node at
# the head of the linked list
def push(head_ref, data):
 
    new_node = Node(data)
    new_node.next = head_ref
    head_ref = new_node
    return head_ref
     
# Function to return the bitonic
# of the given linked list
def bitonic_point(node):
 
    # If list is empty
    if (node == None):
        return -1;
  
    # If list contains only
    # a single node
    if (node.next == None):
        return -1;
  
    # Invalid bitonic sequence
    if (node.data > node.next.data):
        return -1;
    while (node.next != None):
  
        # If current node is the bitonic point
        if (node.data > node.next.data):
            break;
  
        # Get to the next node in the list
        node = node.next;
    bitonicPoint = node.data;
     
    # Nodes must be in descending
    # starting from here
    while (node.next != None):
  
        # Out of order node
        if (node.data < node.next.data):
            return -1;
  
        # Get to the next node in the list
        node = node.next;
    return bitonicPoint;
  
# Driver code
if __name__=='__main__':
     
    head = None;
  
    head = push(head, 100);
    head = push(head, 201);
    head = push(head, 399);
    head = push(head, 490);
    head = push(head, 377);
    head = push(head, 291);
    head = push(head, 100);
  
    print(bitonic_point(head))
  
# This code is contributed by rutvik_56

C#

// C# implementation of the approach
using System;
     
class GFG
{
     
// Node for linked list
public class Node
{
    public int data;
    public Node next;
};
 
// Function to insert a node at
// the head of the linked list
static Node push(Node head_ref, int data)
{
    Node new_node = new Node();
    new_node.data = data;
    new_node.next = (head_ref);
    (head_ref) = new_node;
    return head_ref;
}
 
// Function to return the bitonic
// of the given linked list
static int bitonic_point(Node node)
{
    // If list is empty
    if (node == null)
        return -1;
 
    // If list contains only
    // a single node
    if (node.next == null)
        return -1;
 
    // Invalid bitonic sequence
    if (node.data > node.next.data)
        return -1;
 
    while (node.next != null)
    {
 
        // If current node is the bitonic point
        if (node.data > node.next.data)
            break;
 
        // Get to the next node in the list
        node = node.next;
    }
 
    int bitonicPoint = node.data;
     
    // Nodes must be in descending
    // starting from here
    while (node.next != null)
    {
 
        // Out of order node
        if (node.data < node.next.data)
            return -1;
 
        // Get to the next node in the list
        node = node.next;
    }
 
    return bitonicPoint;
}
 
// Driver code
public static void Main(String []args)
{
    Node head = null;
 
    head=push(head, 100);
    head=push(head, 201);
    head=push(head, 399);
    head=push(head, 490);
    head=push(head, 377);
    head=push(head, 291);
    head=push(head, 100);
 
    Console.WriteLine(bitonic_point(head));
}
}
 
// This code is contributed by 29AjayKumar

输出：

490