📌  相关文章
📜  将链接列表分成 3 个部分,使它们的大小之间的最大差异最小

📅  最后修改于: 2022-05-13 01:56:08.725000             🧑  作者: Mango

将链接列表分成 3 个部分,使它们的大小之间的最大差异最小

给定一个单链表,任务是将给定的链表精确地拆分为三部分,使得拆分后的链表长度之间的最大差异最小。

例子:

方法:按照以下步骤解决给定问题:

  • 初始化一个向量,比如ans[]存储拆分链表
  • 如果给定链表的大小小于3 ,则创建大小时间 仅具有一个节点的链表和具有节点的3 大小链表,并将其添加到ans向量并返回
  • 初始化一个变量,比如minSizesize / 3 ,它将是要划分的链表的最小大小, remsize % 3
  • 遍历链表直到 size 变为0并执行以下步骤:
    • 在每次迭代中,如果rem等于0 ,则再次将 minSize次迭代到链表中,并将该链表添加到ans中,并将rem1。
    • 否则,在链表中迭代(minSize + 1)次并将该链表添加到ans中。
  • 完成上述步骤后,打印出向量ans[]中存储的所有链表。

下面是上述方法的实现:

C++
// C++ program for the above approach
 
#include 
using namespace std;
 
// Structure of a Node
class Node {
public:
    int data;
    Node* next;
};
 
// Function to find the length of
// the Linked List
int sizeOfLL(Node* head)
{
    int size = 0;
 
    // While head is not null
    while (head != NULL) {
        ++size;
        head = head->next;
    }
    return size;
}
 
// Function to partition list into
// 3 parts such that maximum size
// difference between parts is minimum
vector Partition_of_list(Node* head)
{
    int size = sizeOfLL(head);
    Node* temp = head;
    vector ans;
 
    // If size is less than 3
    if (3 >= size) {
        // Partition linked list
        // into one node each
        while (temp != NULL) {
            Node* next = temp->next;
            temp->next = NULL;
            ans.push_back(temp);
            temp = next;
        }
 
        // The remaining parts (3-size)
        // will be filled by empty
        // the linked list
        int y = 3 - size;
        while (y != 0) {
            ans.push_back(NULL);
            y--;
        }
    }
    else {
        // Minimum size
        int minSize = size / 3;
        int rem = size % 3;
 
        // While size is positive
        // and temp is not null
        while (size > 0 && temp != NULL) {
            int m = 0;
 
            // If remainder > 0, then
            // partition list on the
            // basis of minSize + 1
            if (rem != 0) {
                m = minSize + 1;
                rem--;
            }
 
            // Otherwise, partition
            // on the basis of minSize
            else {
                m = minSize;
            }
            Node* curr = temp;
 
            // Iterate for m-1 steps
            // in the list
            for (int j = 1; j < m
                            && temp->next != NULL;
                 j++) {
                temp = temp->next;
            }
 
            // Change the next of the
            // current node to NULL
            // and add it to the ans
            if (temp->next != NULL) {
                Node* x = temp->next;
                temp->next = NULL;
                temp = x;
                ans.push_back(curr);
            }
 
            // Otherwise
            else {
                // Pushing to ans
                ans.push_back(curr);
                break;
            }
            size -= m;
        }
    }
 
    // Return the resultant lists
    return ans;
}
 
// Function to insert elements in list
void push(Node** head, int d)
{
    Node* temp = new Node();
    temp->data = d;
    temp->next = NULL;
 
    // If the head is NULL
    if ((*head) == NULL)
        (*head) = temp;
 
    // Otherwise
    else {
        Node* curr = (*head);
 
        // While curr->next is not NULL
        while (curr->next != NULL) {
            curr = curr->next;
        }
        curr->next = temp;
    }
}
 
// Function to display the Linked list
void display(Node* head)
{
    // While head is not null
    while (head->next != NULL) {
        // Print the data
        cout << head->data << "->";
        head = head->next;
    }
    cout << head->data << "\n";
}
 
// Driver Code
int main()
{
    // Given Input
    Node* head = NULL;
    push(&head, 1);
    push(&head, 2);
    push(&head, 3);
    push(&head, 4);
    push(&head, 5);
 
    // Function Call
    vector v = Partition_of_list(head);
 
    for (int i = 0; i < v.size(); i++) {
        display(v[i]);
    }
    return 0;
}


Java
// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Structure of a Node
static class Node {
 
    int data;Node next;
};
 
    // Function to find the length of
    // the Linked List
static int sizeOfLL(Node head)
{
    int size = 0;
 
    // While head is not null
    while (head != null) {
        ++size;
        head = head.next;
    }
    return size;
}
 
// Function to partition list into
// 3 parts such that maximum size
// difference between parts is minimum
static Vector Partition_of_list(Node head)
{
    int size = sizeOfLL(head);
    Node temp = head;
    Vector ans = new Vector<>();
 
    // If size is less than 3
    if (3 >= size) {
        // Partition linked list
        // into one node each
        while (temp != null) {
            Node next = temp.next;
            temp.next = null;
            ans.add(temp);
            temp = next;
        }
 
        // The remaining parts (3-size)
        // will be filled by empty
        // the linked list
        int y = 3 - size;
        while (y != 0) {
            ans.add(null);
            y--;
        }
    }
    else {
        // Minimum size
        int minSize = size / 3;
        int rem = size % 3;
 
        // While size is positive
        // and temp is not null
        while (size > 0 && temp != null) {
            int m = 0;
 
            // If remainder > 0, then
            // partition list on the
            // basis of minSize + 1
            if (rem != 0) {
                m = minSize + 1;
                rem--;
            }
 
            // Otherwise, partition
            // on the basis of minSize
            else {
                m = minSize;
            }
            Node curr = temp;
 
            // Iterate for m-1 steps
            // in the list
            for (int j = 1; j < m
                            && temp.next != null;
                 j++) {
                temp = temp.next;
            }
 
            // Change the next of the
            // current node to null
            // and add it to the ans
            if (temp.next != null) {
                Node x = temp.next;
                temp.next = null;
                temp = x;
                ans.add(curr);
            }
 
            // Otherwise
            else {
                // Pushing to ans
                ans.add(curr);
                break;
            }
            size -= m;
        }
    }
 
    // Return the resultant lists
    return ans;
}
 
    // Function to insert elements in list
static Node push(Node head, int d)
{
    Node temp = new Node();
    temp.data = d;
    temp.next = null;
 
    // If the head is null
    if ((head) == null)
        (head) = temp;
 
    // Otherwise
    else {
        Node curr = (head);
 
        // While curr.next is not null
        while (curr.next != null) {
            curr = curr.next;
        }
        curr.next = temp;
    }
    return head;
}
 
    // Function to display the Linked list
static void display(Node head)
{
    // While head is not null
    while (head.next != null) {
        // Print the data
        System.out.print(head.data+ "->");
        head = head.next;
    }
    System.out.print(head.data+ "\n");
}
 
    // Driver Code
public static void main(String[] args)
{
    // Given Input
    Node head = null;
    head = push(head, 1);
    head = push(head, 2);
    head = push(head, 3);
    head = push(head, 4);
    head = push(head, 5);
 
    // Function Call
    Vector v = Partition_of_list(head);
 
    for (int i = 0; i < v.size(); i++) {
        display(v.get(i));
    }
}
}
// This code is contributed by gauravrajput1


Python3
# Python program for the above approach
 
# Structure of a Node
class Node:
    def __init__(self):
        self.data = 0;
        self.next = next;
 
# Function to find the length of
# the Linked List
def sizeOfLL(head):
    size = 0;
 
    # While head is not None
    while (head != None):
        size += 1;
        head = head.next;
     
    return size;
 
# Function to partition list into
# 3 parts such that maximum size
# difference between parts is minimum
def Partition_of_list(head):
    size = sizeOfLL(head);
    temp = head;
    ans = [];
 
    # If size is less than 3
    if (3 >= size):
       
        # Partition linked list
        # into one Node each
        while (temp != None):
            next = temp.next;
            temp.next = None;
            ans.append(temp);
            temp = next;
         
 
        # The remaining parts (3-size)
        # will be filled by empty
        # the linked list
        y = 3 - size;
        while (y != 0):
            ans.append(None);
            y-=1;
         
    else:
        # Minimum size
        minSize = size // 3;
        rem = size % 3;
 
        # While size is positive
        # and temp is not None
        while (size > 0 and temp != None):
            m = 0;
 
            # If remainder > 0, then
            # partition list on the
            # basis of minSize + 1
            if (rem != 0):
                m = minSize + 1;
                rem-=1;
             
 
            # Otherwise, partition
            # on the basis of minSize
            else:
                m = minSize;
             
            curr = temp;
 
            # Iterate for m-1 steps
            # in the list
            for j in range(1,m):# (j = 1; j < m and temp.next != None; j+=1):
                temp = temp.next;
             
 
            # Change the next of the
            # current Node to None
            # and add it to the ans
            if (temp.next != None):
                x = temp.next;
                temp.next = None;
                temp = x;
                ans.append(curr);
             
            # Otherwise
            else:
                # Pushing to ans
                ans.append(curr);
                break;
             
            size -= m;
         
    # Return the resultant lists
    return ans;
 
# Function to insert elements in list
def push(head, d):
    temp = Node();
    temp.data = d;
    temp.next = None;
 
    # If the head is None
    if ((head) == None):
        (head) = temp;
 
    # Otherwise
    else:
        curr = (head);
 
        # While curr.next is not None
        while (curr.next != None):
            curr = curr.next;
         
        curr.next = temp;
     
    return head;
 
 
# Function to display the Linked list
def display(head):
    # While head is not None
    while (head.next != None):
        # Print the data
        print(head.data , "->", end="");
        head = head.next;
     
    print(head.data );
 
# Driver Code
if __name__ == '__main__':
   
    # Given Input
    head = None;
    head = push(head, 1);
    head = push(head, 2);
    head = push(head, 3);
    head = push(head, 4);
    head = push(head, 5);
 
    # Function Call
    v = Partition_of_list(head);
 
    for i in range(len(v)):
        display(v[i]);
 
# This code is contributed by umadevi9616


C#
// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG {
 
    // Structure of a Node
public    class Node {
 
    public    int data;
    public    Node next;
    };
 
    // Function to find the length of
    // the Linked List
    static int sizeOfLL(Node head) {
        int size = 0;
 
        // While head is not null
        while (head != null) {
            ++size;
            head = head.next;
        }
        return size;
    }
 
    // Function to partition list into
    // 3 parts such that maximum size
    // difference between parts is minimum
    static List Partition_of_list(Node head) {
        int size = sizeOfLL(head);
        Node temp = head;
        List ans = new List();
 
        // If size is less than 3
        if (3 >= size) {
            // Partition linked list
            // into one node each
            while (temp != null) {
                Node next = temp.next;
                temp.next = null;
                ans.Add(temp);
                temp = next;
            }
 
            // The remaining parts (3-size)
            // will be filled by empty
            // the linked list
            int y = 3 - size;
            while (y != 0) {
                ans.Add(null);
                y--;
            }
        } else {
            // Minimum size
            int minSize = size / 3;
            int rem = size % 3;
 
            // While size is positive
            // and temp is not null
            while (size > 0 && temp != null) {
                int m = 0;
 
                // If remainder > 0, then
                // partition list on the
                // basis of minSize + 1
                if (rem != 0) {
                    m = minSize + 1;
                    rem--;
                }
 
                // Otherwise, partition
                // on the basis of minSize
                else {
                    m = minSize;
                }
                Node curr = temp;
 
                // Iterate for m-1 steps
                // in the list
                for (int j = 1; j < m && temp.next != null; j++) {
                    temp = temp.next;
                }
 
                // Change the next of the
                // current node to null
                // and add it to the ans
                if (temp.next != null) {
                    Node x = temp.next;
                    temp.next = null;
                    temp = x;
                    ans.Add(curr);
                }
 
                // Otherwise
                else {
                    // Pushing to ans
                    ans.Add(curr);
                    break;
                }
                size -= m;
            }
        }
 
        // Return the resultant lists
        return ans;
    }
 
    // Function to insert elements in list
    static Node push(Node head, int d) {
        Node temp = new Node();
        temp.data = d;
        temp.next = null;
 
        // If the head is null
        if ((head) == null)
            (head) = temp;
 
        // Otherwise
        else {
            Node curr = (head);
 
            // While curr.next is not null
            while (curr.next != null) {
                curr = curr.next;
            }
            curr.next = temp;
        }
        return head;
    }
 
    // Function to display the Linked list
    static void display(Node head) {
        // While head is not null
        while (head.next != null) {
            // Print the data
            Console.Write(head.data + "->");
            head = head.next;
        }
        Console.Write(head.data + "\n");
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
       
        // Given Input
        Node head = null;
        head = push(head, 1);
        head = push(head, 2);
        head = push(head, 3);
        head = push(head, 4);
        head = push(head, 5);
 
        // Function Call
        List v = Partition_of_list(head);
 
        for (int i = 0; i < v.Count; i++) {
            display(v[i]);
        }
    }
}
 
// This code is contributed by gauravrajput1


Javascript


输出:
1->2
3->4
5

时间复杂度: O(N)
辅助空间: O(N)