计算总和等于给定值 x 的已排序双向链表中的三元组

给定不同节点的排序双向链表（没有两个节点具有相同的数据）和值x 。计算列表中总和为给定值x 的三元组。

例子：

方法 1（朴素方法）：
使用三个嵌套循环生成所有三元组并检查三元组中的元素总和是否为x 。

C++

// C++ implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
#include 
 
using namespace std;
 
// structure of node of doubly linked list
struct Node {
    int data;
    struct Node* next, *prev;
};
 
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
int countTriplets(struct Node* head, int x)
{
    struct Node* ptr1, *ptr2, *ptr3;
    int count = 0;
 
    // generate all possible triplets
    for (ptr1 = head; ptr1 != NULL; ptr1 = ptr1->next)
        for (ptr2 = ptr1->next; ptr2 != NULL; ptr2 = ptr2->next)
            for (ptr3 = ptr2->next; ptr3 != NULL; ptr3 = ptr3->next)
 
                // if elements in the current triplet sum up to 'x'
                if ((ptr1->data + ptr2->data + ptr3->data) == x)
 
                    // increment count
                    count++;
 
    // required count of triplets
    return count;
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
void insert(struct Node** head, int data)
{
    // allocate node
    struct Node* temp = new Node();
 
    // put in the data
    temp->data = data;
    temp->next = temp->prev = NULL;
 
    if ((*head) == NULL)
        (*head) = temp;
    else {
        temp->next = *head;
        (*head)->prev = temp;
        (*head) = temp;
    }
}
 
// Driver program to test above
int main()
{
    // start with an empty doubly linked list
    struct Node* head = NULL;
 
    // insert values in sorted order
    insert(&head, 9);
    insert(&head, 8);
    insert(&head, 6);
    insert(&head, 5);
    insert(&head, 4);
    insert(&head, 2);
    insert(&head, 1);
 
    int x = 17;
 
    cout << "Count = "
         << countTriplets(head, x);
    return 0;
}

Java

// Java implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
import java.io.*;
import java.util.*;
 
// Represents node of a doubly linked list
class Node
{
    int data;
    Node prev, next;
    Node(int val)
    {
        data = val;
        prev = null;
        next = null;
    }
}
 
class GFG
{
 
    // function to count triplets in
    // a sorted doubly linked list
    // whose sum is equal to a given value 'x'
    static int countTriplets(Node head, int x)
    {
            Node ptr1, ptr2, ptr3;
            int count = 0;
 
            // generate all possible triplets
            for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
                for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
                    for (ptr3 = ptr2.next; ptr3 != null; ptr3 = ptr3.next)
 
                        // if elements in the current triplet sum up to 'x'
                        if ((ptr1.data + ptr2.data + ptr3.data) == x)
                             
                            // increment count
                            count++;
 
            // required count of triplets
            return count;
    }
 
    // A utility function to insert a new node at the
    // beginning of doubly linked list
    static Node insert(Node head, int val)
    {
            // allocate node
            Node temp = new Node(val);
 
            if (head == null)
                head = temp;
 
            else
            {
                temp.next = head;
                head.prev = temp;
                head = temp;
            }
         
            return head;
    }
 
    // Driver code
    public static void main(String args[])
    {
            // start with an empty doubly linked list
            Node head = null;
             
            // insert values in sorted order
            head = insert(head, 9);
            head = insert(head, 8);
            head = insert(head, 6);
            head = insert(head, 5);
            head = insert(head, 4);
            head = insert(head, 2);
            head = insert(head, 1);
 
            int x = 17;
            System.out.println("count = " + countTriplets(head, x));
    }
}
 
// This code is contributed by rachana soma

Python3

# Python3 implementation to count triplets
# in a sorted doubly linked list
# whose sum is equal to a given value 'x'
 
# structure of node of doubly linked list
class Node:
    def __init__(self):
        self.data = None
        self.prev = None
        self.next = None
 
# function to count triplets in a sorted doubly linked list
# whose sum is equal to a given value 'x'
def countTriplets( head, x):
 
    ptr1 = head
    ptr2 = None
    ptr3 = None
    count = 0
 
    # generate all possible triplets
    while (ptr1 != None ):
        ptr2 = ptr1.next
        while ( ptr2 != None ):
            ptr3 = ptr2.next
            while ( ptr3 != None ):
         
                # if elements in the current triplet sum up to 'x'
                if ((ptr1.data + ptr2.data + ptr3.data) == x):
 
                    # increment count
                    count = count + 1
                ptr3 = ptr3.next
            ptr2 = ptr2.next
        ptr1 = ptr1.next
 
    # required count of triplets
    return count
 
# A utility function to insert a new node at the
# beginning of doubly linked list
def insert(head, data):
 
    # allocate node
    temp = Node()
 
    # put in the data
    temp.data = data
    temp.next = temp.prev = None
 
    if ((head) == None):
        (head) = temp
    else :
        temp.next = head
        (head).prev = temp
        (head) = temp
    return head
     
# Driver code
 
# start with an empty doubly linked list
head = None
 
# insert values in sorted order
head = insert(head, 9)
head = insert(head, 8)
head = insert(head, 6)
head = insert(head, 5)
head = insert(head, 4)
head = insert(head, 2)
head = insert(head, 1)
 
x = 17
 
print( "Count = ", countTriplets(head, x))
 
# This code is contributed by Arnab Kundu

C#

// C# implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
using System;
 
// Represents node of a doubly linked list
public class Node
{
    public int data;
    public Node prev, next;
    public Node(int val)
    {
        data = val;
        prev = null;
        next = null;
    }
}
 
class GFG
{
 
    // function to count triplets in
    // a sorted doubly linked list
    // whose sum is equal to a given value 'x'
    static int countTriplets(Node head, int x)
    {
        Node ptr1, ptr2, ptr3;
        int count = 0;
 
        // generate all possible triplets
        for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
            for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
                for (ptr3 = ptr2.next; ptr3 != null; ptr3 = ptr3.next)
 
                    // if elements in the current triplet sum up to 'x'
                    if ((ptr1.data + ptr2.data + ptr3.data) == x)
                         
                        // increment count
                        count++;
 
        // required count of triplets
        return count;
    }
 
    // A utility function to insert a new node at the
    // beginning of doubly linked list
    static Node insert(Node head, int val)
    {
        // allocate node
        Node temp = new Node(val);
 
        if (head == null)
            head = temp;
 
        else
        {
            temp.next = head;
            head.prev = temp;
            head = temp;
        }
     
        return head;
    }
 
    // Driver code
    public static void Main(String []args)
    {
            // start with an empty doubly linked list
            Node head = null;
             
            // insert values in sorted order
            head = insert(head, 9);
            head = insert(head, 8);
            head = insert(head, 6);
            head = insert(head, 5);
            head = insert(head, 4);
            head = insert(head, 2);
            head = insert(head, 1);
 
            int x = 17;
            Console.WriteLine("count = " + countTriplets(head, x));
    }
}
 
// This code is contributed by Arnab Kundu

Javascript

// javascript implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
// Represents node of a doubly linked list
class Node {
    constructor(val) {
        this.data = val;
        this.prev = null;
        this.next = null;
    }
}
    // function to count triplets in
    // a sorted doubly linked list
    // whose sum is equal to a given value 'x'
    function countTriplets( head , x) {
        var ptr1, ptr2, ptr3;
        var count = 0;
 
        // generate all possible triplets
        for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
            for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
                for (ptr3 = ptr2.next; ptr3 != null; ptr3 = ptr3.next)
 
                    // if elements in the current triplet sum up to 'x'
                    if ((ptr1.data + ptr2.data + ptr3.data) == x)
 
                        // increment count
                        count++;
 
        // required count of triplets
        return count;
    }
 
    // A utility function to insert a new node at the
    // beginning of doubly linked list
    function insert( head , val) {
        // allocate node
         temp = new Node(val);
 
        if (head == null)
            head = temp;
 
        else {
            temp.next = head;
            head.prev = temp;
            head = temp;
        }
 
        return head;
    }
 
    // Driver code
     
        // start with an empty doubly linked list
         head = null;
 
        // insert values in sorted order
        head = insert(head, 9);
        head = insert(head, 8);
        head = insert(head, 6);
        head = insert(head, 5);
        head = insert(head, 4);
        head = insert(head, 2);
        head = insert(head, 1);
 
        var x = 17;
        document.write("count = " + countTriplets(head, x));
 
// This code is contributed by umadevi9616

输出：

Count = 2

时间复杂度： O(n ³ )
辅助空间： O(1)

方法二（散列）：
创建一个哈希表，其中(key, value)元组表示为(node data, node pointer) tuples 。遍历双向链表并将每个节点的数据及其指针对（元组）存储在哈希表中。现在，生成每个可能的节点对。对于每对节点，计算p_sum （两个节点中数据的总和）并检查（x-p_sum）是否存在于哈希表中。如果存在，则还要验证该对中的两个节点与哈希表中与(x-p_sum)关联的节点不同，最后增加count 。返回(count / 3)因为每个三元组在上述过程中被计数 3 次。

C++

// C++ implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
#include 
 
using namespace std;
 
// structure of node of doubly linked list
struct Node {
    int data;
    struct Node* next, *prev;
};
 
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
int countTriplets(struct Node* head, int x)
{
    struct Node* ptr, *ptr1, *ptr2;
    int count = 0;
 
    // unordered_map 'um' implemented as hash table
    unordered_map um;
 
    // insert the  tuple in 'um'
    for (ptr = head; ptr != NULL; ptr = ptr->next)
        um[ptr->data] = ptr;
 
    // generate all possible pairs
    for (ptr1 = head; ptr1 != NULL; ptr1 = ptr1->next)
        for (ptr2 = ptr1->next; ptr2 != NULL; ptr2 = ptr2->next) {
 
            // p_sum - sum of elements in the current pair
            int p_sum = ptr1->data + ptr2->data;
 
            // if 'x-p_sum' is present in 'um' and either of the two nodes
            // are not equal to the 'um[x-p_sum]' node
            if (um.find(x - p_sum) != um.end() && um[x - p_sum] != ptr1
                && um[x - p_sum] != ptr2)
 
                // increment count
                count++;
        }
 
    // required count of triplets
    // division by 3 as each triplet is counted 3 times
    return (count / 3);
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
void insert(struct Node** head, int data)
{
    // allocate node
    struct Node* temp = new Node();
 
    // put in the data
    temp->data = data;
    temp->next = temp->prev = NULL;
 
    if ((*head) == NULL)
        (*head) = temp;
    else {
        temp->next = *head;
        (*head)->prev = temp;
        (*head) = temp;
    }
}
 
// Driver program to test above
int main()
{
    // start with an empty doubly linked list
    struct Node* head = NULL;
 
    // insert values in sorted order
    insert(&head, 9);
    insert(&head, 8);
    insert(&head, 6);
    insert(&head, 5);
    insert(&head, 4);
    insert(&head, 2);
    insert(&head, 1);
 
    int x = 17;
 
    cout << "Count = "
         << countTriplets(head, x);
    return 0;
}

Java

// Java implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
import java.util.*;
 
class GFG{
  
// structure of node of doubly linked list
static class Node {
    int data;
    Node next, prev;
    Node(int val)
    {
        data = val;
        prev = null;
        next = null;
    }
};
  
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
    Node ptr, ptr1, ptr2;
    int count = 0;
  
    // unordered_map 'um' implemented as hash table
    HashMap um = new HashMap();
  
    // insert the  tuple in 'um'
    for (ptr = head; ptr != null; ptr = ptr.next)
        um.put(ptr.data, ptr);
  
    // generate all possible pairs
    for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
        for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next) {
  
            // p_sum - sum of elements in the current pair
            int p_sum = ptr1.data + ptr2.data;
  
            // if 'x-p_sum' is present in 'um' and either of the two nodes
            // are not equal to the 'um[x-p_sum]' node
            if (um.containsKey(x - p_sum) && um.get(x - p_sum) != ptr1
                && um.get(x - p_sum) != ptr2)
  
                // increment count
                count++;
        }
  
    // required count of triplets
    // division by 3 as each triplet is counted 3 times
    return (count / 3);
}
  
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int val)
{
        // allocate node
        Node temp = new Node(val);
 
        if (head == null)
            head = temp;
 
        else
        {
            temp.next = head;
            head.prev = temp;
            head = temp;
        }
      
        return head;
}
  
// Driver program to test above
public static void main(String[] args)
{
    // start with an empty doubly linked list
    Node head = null;
  
    // insert values in sorted order
    head = insert(head, 9);
    head = insert(head, 8);
    head = insert(head, 6);
    head = insert(head, 5);
    head = insert(head, 4);
    head = insert(head, 2);
    head = insert(head, 1);
  
    int x = 17;
  
    System.out.print("Count = "
         + countTriplets(head, x));
}
}
 
// This code is contributed by Rajput-Ji

蟒蛇3

# Python3 implementation to count triplets in a sorted doubly linked list
# whose sum is equal to a given value 'x'
  
# structure of node of doubly linked list
class Node:
     
    def __init__(self, data):
         
        self.data=data
        self.next=None
        self.prev=None
 
  
# function to count triplets in a sorted doubly linked list
# whose sum is equal to a given value 'x'
def countTriplets(head, x):
 
    ptr2=head
    count = 0;
  
    # unordered_map 'um' implemented as hash table
    um = dict()
     
    ptr = head
    # insert the  tuple in 'um'
    while ptr!=None:
        um[ptr.data] = ptr;
        ptr = ptr.next
  
    # generate all possible pairs
    ptr1=head
     
    while ptr1!=None:
         
        ptr2 = ptr1.next
         
        while ptr2!=None:
  
            # p_sum - sum of elements in the current pair
            p_sum = ptr1.data + ptr2.data;
  
            # if 'x-p_sum' is present in 'um' and either of the two nodes
            # are not equal to the 'um[x-p_sum]' node
            if ((x-p_sum) in um) and um[x - p_sum] != ptr1 and um[x - p_sum] != ptr2:
  
                # increment count
                count+=1
            ptr2 = ptr2.next
        ptr1 = ptr1.next
         
  
    # required count of triplets
    # division by 3 as each triplet is counted 3 times
    return (count // 3);
 
  
# A utility function to insert a new node at the
# beginning of doubly linked list
def insert(head, data):
 
    # allocate node
    temp = Node(data);
  
    if ((head) == None):
        (head) = temp;
    else:
        temp.next = head;
        (head).prev = temp;
        (head) = temp;
    return head
     
  
# Driver program to test above
if __name__=='__main__':
     
    # start with an empty doubly linked list
    head = None;
  
    # insert values in sorted order
    head = insert(head, 9);
    head = insert(head, 8);
    head = insert(head, 6);
    head = insert(head, 5);
    head = insert(head, 4);
    head = insert(head, 2);
    head = insert( head, 1);
  
    x = 17;
  
    print("Count = "+ str(countTriplets(head, x)))
     
# This code is contributed by rutvik_56

C＃

// C# implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
using System;
using System.Collections.Generic;
 
class GFG
{
 
// structure of node of doubly linked list
class Node {
    public int data;
    public Node next, prev;
    public Node(int val)
    {
        data = val;
        prev = null;
        next = null;
    }
};
 
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
    Node ptr, ptr1, ptr2;
    int count = 0;
 
    // unordered_map 'um' implemented as hash table
    Dictionary um = new Dictionary();
 
    // insert the  tuple in 'um'
    for (ptr = head; ptr != null; ptr = ptr.next)
        if(um.ContainsKey(ptr.data))
            um[ptr.data] = ptr;
        else
            um.Add(ptr.data, ptr);
 
    // generate all possible pairs
    for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
        for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
        {
 
            // p_sum - sum of elements in the current pair
            int p_sum = ptr1.data + ptr2.data;
 
            // if 'x-p_sum' is present in 'um' and either of the two nodes
            // are not equal to the 'um[x-p_sum]' node
            if (um.ContainsKey(x - p_sum) && um[x - p_sum] != ptr1
                && um[x - p_sum] != ptr2)
 
                // increment count
                count++;
        }
 
    // required count of triplets
    // division by 3 as each triplet is counted 3 times
    return (count / 3);
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int val)
{
        // allocate node
        Node temp = new Node(val);
 
        if (head == null)
            head = temp;
 
        else
        {
            temp.next = head;
            head.prev = temp;
            head = temp;
        }
     
        return head;
}
 
// Driver code
public static void Main(String[] args)
{
    // start with an empty doubly linked list
    Node head = null;
 
    // insert values in sorted order
    head = insert(head, 9);
    head = insert(head, 8);
    head = insert(head, 6);
    head = insert(head, 5);
    head = insert(head, 4);
    head = insert(head, 2);
    head = insert(head, 1);
 
    int x = 17;
 
    Console.Write("Count = "
        + countTriplets(head, x));
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
// Javascript implementation to count
// triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
     
// Structure of node of doubly linked list
class Node{
constructor(data)
{
    this.data = data;
    this.prev = null;
    this.next = null;
}
}
 
// Function to count triplets in a sorted
// doubly linked list whose sum is equal
// to a given value 'x'
function countTriplets(head, x)
{
    let ptr, ptr1, ptr2;
    let count = 0;
     
    // unordered_map 'um' implemented
    // as hash table
    let um = new Map();
     
    // Insert the <node data, node pointer>
    // tuple in 'um'
    for(ptr = head; ptr != null; ptr = ptr.next)
        um.set(ptr.data, ptr);
     
    // Generate all possible pairs
    for(ptr1 = head;
        ptr1 != null;
        ptr1 = ptr1.next)
        for(ptr2 = ptr1.next;
            ptr2 != null;
            ptr2 = ptr2.next)
        {
             
            // p_sum - sum of elements in
            // the current pair
            let p_sum = ptr1.data + ptr2.data;
     
            // If 'x-p_sum' is present in 'um'
            // and either of the two nodes are
            // not equal to the 'um[x-p_sum]' node
            if (um.has(x - p_sum) &&
                um.get(x - p_sum) != ptr1 &&
                um.get(x - p_sum) != ptr2)
     
                // Increment count
                count++;
        }
         
    // Required count of triplets
    // division by 3 as each triplet
    // is counted 3 times
    return (count / 3);
}
 
// A utility function to insert a new
// node at the beginning of doubly linked list
function insert(head, val)
{
     
    // Allocate node
    let temp = new Node(val);
 
    if (head == null)
        head = temp;
 
    else
    {
        temp.next = head;
        head.prev = temp;
        head = temp;
    }
    return head;
}
 
// Driver code
 
// Start with an empty doubly linked list
let head = null;
 
// Insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
 
let x = 17;
 
document.write("Count = " +
               countTriplets(head, x));
 
// This code is contributed by patel2127
 

输出：

Count = 2

时间复杂度： O(n ² )
辅助空间： O(n)

方法三高效方法（使用两个指针）：
从左到右遍历双向链表。对于遍历过程中的每个当前节点，初始化两个指针first = 指向当前节点旁边节点的指针和last = 指向列表最后一个节点的指针。现在，计算列表中从第一个到最后一个指针的对，总和为值（x – 当前节点的数据） （本文中描述的算法）。将此计数添加到三元组的total_count中。指向最后一个节点的指针只能在开头找到一次。

C++

// C++ implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
#include 
 
using namespace std;
 
// structure of node of doubly linked list
struct Node {
    int data;
    struct Node* next, *prev;
};
 
// function to count pairs whose sum equal to given 'value'
int countPairs(struct Node* first, struct Node* second, int value)
{
    int count = 0;
 
    // The loop terminates when either of two pointers
    // become NULL, or they cross each other (second->next
    // == first), or they become same (first == second)
    while (first != NULL && second != NULL &&
           first != second && second->next != first) {
 
        // pair found
        if ((first->data + second->data) == value) {
 
            // increment count
            count++;
 
            // move first in forward direction
            first = first->next;
 
            // move second in backward direction
            second = second->prev;
        }
 
        // if sum is greater than 'value'
        // move second in backward direction
        else if ((first->data + second->data) > value)
            second = second->prev;
 
        // else move first in forward direction
        else
            first = first->next;
    }
 
    // required count of pairs
    return count;
}
 
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
int countTriplets(struct Node* head, int x)
{
    // if list is empty
    if (head == NULL)
        return 0;
 
    struct Node* current, *first, *last;
    int count = 0;
 
    // get pointer to the last node of
    // the doubly linked list
    last = head;
    while (last->next != NULL)
        last = last->next;
 
    // traversing the doubly linked list
    for (current = head; current != NULL; current = current->next) {
 
        // for each current node
        first = current->next;
 
        // count pairs with sum(x - current->data) in the range
        // first to last and add it to the 'count' of triplets
        count += countPairs(first, last, x - current->data);
    }
 
    // required count of triplets
    return count;
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
void insert(struct Node** head, int data)
{
    // allocate node
    struct Node* temp = new Node();
 
    // put in the data
    temp->data = data;
    temp->next = temp->prev = NULL;
 
    if ((*head) == NULL)
        (*head) = temp;
    else {
        temp->next = *head;
        (*head)->prev = temp;
        (*head) = temp;
    }
}
 
// Driver program to test above
int main()
{
    // start with an empty doubly linked list
    struct Node* head = NULL;
 
    // insert values in sorted order
    insert(&head, 9);
    insert(&head, 8);
    insert(&head, 6);
    insert(&head, 5);
    insert(&head, 4);
    insert(&head, 2);
    insert(&head, 1);
 
    int x = 17;
 
    cout << "Count = "
         << countTriplets(head, x);
    return 0;
}

Java

// Java implementation to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
import java.util.*;
 
class GFG{
  
// structure of node of doubly linked list
static class Node {
    int data;
    Node next, prev;
};
  
// function to count pairs whose sum equal to given 'value'
static int countPairs(Node first, Node second, int value)
{
    int count = 0;
  
    // The loop terminates when either of two pointers
    // become null, or they cross each other (second.next
    // == first), or they become same (first == second)
    while (first != null && second != null &&
           first != second && second.next != first) {
  
        // pair found
        if ((first.data + second.data) == value) {
  
            // increment count
            count++;
  
            // move first in forward direction
            first = first.next;
  
            // move second in backward direction
            second = second.prev;
        }
  
        // if sum is greater than 'value'
        // move second in backward direction
        else if ((first.data + second.data) > value)
            second = second.prev;
  
        // else move first in forward direction
        else
            first = first.next;
    }
  
    // required count of pairs
    return count;
}
  
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
    // if list is empty
    if (head == null)
        return 0;
  
    Node current, first, last;
    int count = 0;
  
    // get pointer to the last node of
    // the doubly linked list
    last = head;
    while (last.next != null)
        last = last.next;
  
    // traversing the doubly linked list
    for (current = head; current != null; current = current.next) {
  
        // for each current node
        first = current.next;
  
        // count pairs with sum(x - current.data) in the range
        // first to last and add it to the 'count' of triplets
        count += countPairs(first, last, x - current.data);
    }
  
    // required count of triplets
    return count;
}
  
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int data)
{
    // allocate node
    Node temp = new Node();
  
    // put in the data
    temp.data = data;
    temp.next = temp.prev = null;
  
    if ((head) == null)
        (head) = temp;
    else {
        temp.next = head;
        (head).prev = temp;
        (head) = temp;
    }
    return head;
}
  
// Driver program to test above
public static void main(String[] args)
{
    // start with an empty doubly linked list
    Node head = null;
  
    // insert values in sorted order
    head = insert(head, 9);
    head = insert(head, 8);
    head = insert(head, 6);
    head = insert(head, 5);
    head = insert(head, 4);
    head = insert(head, 2);
    head = insert(head, 1);
  
    int x = 17;
  
    System.out.print("Count = "
         + countTriplets(head, x));
}
}
 
// This code is contributed by 29AjayKumar

蟒蛇3

# Python3 implementation to count triplets
# in a sorted doubly linked list whose sum
# is equal to a given value 'x'
 
# Structure of node of doubly linked list
class Node:
     
    def __init__(self, x):
         
        self.data = x
        self.next = None
        self.prev = None
 
# Function to count pairs whose sum
# equal to given 'value'
def countPairs(first, second, value):
     
    count = 0
 
    # The loop terminates when either of two pointers
    # become None, or they cross each other (second.next
    # == first), or they become same (first == second)
    while (first != None and second != None and
           first != second and second.next != first):
 
        # Pair found
        if ((first.data + second.data) == value):
             
            # Increment count
            count += 1
 
            # Move first in forward direction
            first = first.next
 
            # Move second in backward direction
            second = second.prev
 
        # If sum is greater than 'value'
        # move second in backward direction
        elif ((first.data + second.data) > value):
            second = second.prev
 
        # Else move first in forward direction
        else:
            first = first.next
 
    # Required count of pairs
    return count
 
# Function to count triplets in a sorted
# doubly linked list whose sum is equal
# to a given value 'x'
def countTriplets(head, x):
     
    # If list is empty
    if (head == None):
        return 0
 
    current, first, last = head, None, None
    count = 0
 
    # Get pointer to the last node of
    # the doubly linked list
    last = head
     
    while (last.next != None):
        last = last.next
 
    # Traversing the doubly linked list
    while current != None:
 
        # For each current node
        first = current.next
 
        # count pairs with sum(x - current.data) in
        # the range first to last and add it to the
        # 'count' of triplets
        count, current = count + countPairs(
            first, last, x - current.data), current.next
 
    # Required count of triplets
    return count
 
# A utility function to insert a new node
# at the beginning of doubly linked list
def insert(head, data):
     
    # Allocate node
    temp = Node(data)
 
    # Put in the data
    # temp.next = temp.prev = None
    if (head == None):
        head = temp
    else:
        temp.next = head
        head.prev = temp
        head = temp
         
    return head
 
# Driver code
if __name__ == '__main__':
     
    # Start with an empty doubly linked list
    head = None
 
    # Insert values in sorted order
    head = insert(head, 9)
    head = insert(head, 8)
    head = insert(head, 6)
    head = insert(head, 5)
    head = insert(head, 4)
    head = insert(head, 2)
    head = insert(head, 1)
 
    x = 17
 
    print("Count = ", countTriplets(head, x))
     
# This code is contributed by mohit kumar 29

C＃

// C# implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
using System;
 
class GFG
{
 
// structure of node of doubly linked list
class Node
{
    public int data;
    public Node next, prev;
};
 
// function to count pairs whose sum equal to given 'value'
static int countPairs(Node first, Node second, int value)
{
    int count = 0;
 
    // The loop terminates when either of two pointers
    // become null, or they cross each other (second.next
    // == first), or they become same (first == second)
    while (first != null && second != null &&
        first != second && second.next != first) {
 
        // pair found
        if ((first.data + second.data) == value) {
 
            // increment count
            count++;
 
            // move first in forward direction
            first = first.next;
 
            // move second in backward direction
            second = second.prev;
        }
 
        // if sum is greater than 'value'
        // move second in backward direction
        else if ((first.data + second.data) > value)
            second = second.prev;
 
        // else move first in forward direction
        else
            first = first.next;
    }
 
    // required count of pairs
    return count;
}
 
// function to count triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
    // if list is empty
    if (head == null)
        return 0;
 
    Node current, first, last;
    int count = 0;
 
    // get pointer to the last node of
    // the doubly linked list
    last = head;
    while (last.next != null)
        last = last.next;
 
    // traversing the doubly linked list
    for (current = head; current != null; current = current.next) {
 
        // for each current node
        first = current.next;
 
        // count pairs with sum(x - current.data) in the range
        // first to last and add it to the 'count' of triplets
        count += countPairs(first, last, x - current.data);
    }
 
    // required count of triplets
    return count;
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int data)
{
    // allocate node
    Node temp = new Node();
 
    // put in the data
    temp.data = data;
    temp.next = temp.prev = null;
 
    if ((head) == null)
        (head) = temp;
    else {
        temp.next = head;
        (head).prev = temp;
        (head) = temp;
    }
    return head;
}
 
// Driver program to test above
public static void Main(String[] args)
{
    // start with an empty doubly linked list
    Node head = null;
 
    // insert values in sorted order
    head = insert(head, 9);
    head = insert(head, 8);
    head = insert(head, 6);
    head = insert(head, 5);
    head = insert(head, 4);
    head = insert(head, 2);
    head = insert(head, 1);
 
    int x = 17;
 
    Console.Write("Count = "
        + countTriplets(head, x));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

 
// Javascript implementation to count
// triplets in a sorted doubly linked list
// whose sum is equal to a given value 'x'
     
// Structure of node of doubly linked list
class Node
{
    constructor(data)
    {
        this.data = data;
        this.next = this.prev = null;
    }
}
 
// Function to count pairs whose sum
// equal to given 'value'
function countPairs(first, second, value)
{
    let count = 0;
 
    // The loop terminates when either of two pointers
    // become null, or they cross each other (second.next
    // == first), or they become same (first == second)
    while (first != null && second != null &&
           first != second && second.next != first)
    {
         
        // Pair found
        if ((first.data + second.data) == value)
        {
     
            // Increment count
            count++;
     
            // Move first in forward direction
            first = first.next;
     
            // Move second in backward direction
            second = second.prev;
        }
     
        // If sum is greater than 'value'
        // move second in backward direction
        else if ((first.data + second.data) > value)
            second = second.prev;
     
        // Else move first in forward direction
        else
            first = first.next;
    }
     
    // Required count of pairs
    return count;
}
 
// Function to count triplets in a sorted
// doubly linked list whose sum is equal
// to a given value 'x'
function countTriplets(head, x)
{
     
    // If list is empty
    if (head == null)
        return 0;
     
    let current, first, last;
    let count = 0;
     
    // Get pointer to the last node of
    // the doubly linked list
    last = head;
    while (last.next != null)
        last = last.next;
     
    // Traversing the doubly linked list
    for(current = head;
        current != null;
        current = current.next)
    {
         
        // For each current node
        first = current.next;
     
        // Count pairs with sum(x - current.data)
        // in the range first to last and add it
        // to the 'count' of triplets
        count += countPairs(first, last,
                            x - current.data);
    }
     
    // Required count of triplets
    return count;
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
function insert(head, data)
{
     
    // Allocate node
    let temp = new Node();
     
    // Put in the data
    temp.data = data;
    temp.next = temp.prev = null;
     
    if ((head) == null)
        (head) = temp;
    else
    {
        temp.next = head;
        (head).prev = temp;
        (head) = temp;
    }
    return head;
}
 
// Driver code
 
// Start with an empty doubly linked list
let head = null;
 
// Insert values in sorted order
head = insert(head, 9);
head = insert(head, 8);
head = insert(head, 6);
head = insert(head, 5);
head = insert(head, 4);
head = insert(head, 2);
head = insert(head, 1);
 
let x = 17;
 
document.write("Count = " +
    countTriplets(head, x));
 
// This code is contributed by unknown2108
 

输出：

Count = 2

时间复杂度： O(n ² )
辅助空间： O(1)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。