📌  相关文章
📜  从数组中按排序顺序打印所有重复的相邻对

📅  最后修改于: 2021-04-22 09:06:51             🧑  作者: Mango

给定一个由N个整数组成的数组arr [] ,任务是从该数组中打印出所有相邻的整数对,这些对在给定数组中出现多次。如果数组包含多个这样的对,请按排序顺序打印所有对。

例子:

方法:最简单的方法是遍历数组并将每个相邻对存储在Map中。打印所有频率大于1的这样的对。请按照以下步骤解决问题:

  1. 创建一个Map M以将所有相邻对存储在一个数组中。
  2. 遍历给定数组,并将每个相邻对存储在Map M中
  3. 完成上述步骤后,遍历该图,如果任意一对频率至少为一个,则将其插入向量V中
  4. 按升序对向量v进行排序,并打印存储在其中的所有对。

下面是上述方法的实现:

C++
// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to print adjacent pairs
// in sorted order
void repeated_pairs(int arr[], int N)
{
    // Store the frequency of all
    // the adjacent pairs
    map, int> m;
 
    // Stores the resultant pairs
    vector > v;
    int i, j;
 
    // Stores the count of all
    // adjacent pairs
    for (i = 0; i < N - 1; i++) {
 
        pair p
            = { arr[i], arr[i + 1] };
 
        // Increment the count of pair
        m[p]++;
    }
 
    // Store pairs that appears more
    // than once
    for (auto i = m.begin();
         i != m.end(); i++) {
 
        // If frequency is at least 1
        if (i->second > 1) {
            pair p = i->first;
 
            // Insert pair into vector
            v.push_back(p);
        }
    }
 
    // Sort the vector
    sort(v.begin(), v.end());
 
    // Print the pairs
    for (i = 0; i < v.size(); i++) {
 
        pair p = v[i];
 
        // Print the pair
        cout << p.first << " "
             << p.second << endl;
    }
}
 
// Driver Code
int main()
{
    // Given arr[]
    int arr[] = { 1, 2, 3, 4, 1,
                  2, 3, 4, 1, 2 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function call
    repeated_pairs(arr, N);
 
    return 0;
}


Java
// Java code of above approach
import java.util.*;
import java.lang.*;
 
class pair
{
  int first, second;   
  pair(int f, int s)
  {
    this.first = f;
    this.second = s;
  }
 
  @Override
  public boolean equals(Object obj)
  {
 
    // if both the object references are 
    // referring to the same object.
    if(this == obj)
      return true;
 
    if(obj == null || obj.getClass() != this.getClass())
      return false;
 
    // type casting of the argument. 
    pair p = (pair) obj;
 
    return (p.first == this.first  && p.second == this.second);
  }
  @Override
  public int hashCode()
  {
    return this.first + this.second/2;
  }
}
class GFG {
 
  // Function to print adjacent pairs
  // in sorted order
  static void repeated_pairs(int arr[], int N)
  {
 
    // Store the frequency of all
    // the adjacent pairs
    Map m=new HashMap<>();
 
    // Stores the resultant pairs
    ArrayList v = new ArrayList<>();
    int i, j;
 
    // Stores the count of all
    // adjacent pairs
    for (i = 0; i < N - 1; i++)
    {
 
      pair p = new pair(arr[i], arr[i + 1]);
 
      // Increment the count of pair
      m.put(p,m.getOrDefault(p, 0) + 1);
 
    }
 
    // Store pairs that appears more
    // than once
    for (Map.Entry k: m.entrySet())
    {
 
      // If frequency is at least
      if (k.getValue() > 1)
      {
 
        // Insert pair into vector
        v.add(k.getKey());
      }
    }
 
    // Sort the vector
    Collections.sort(v, (a, b)->a.first-b.first);
 
    // Print the pairs
    for (pair k:v)
    {
 
      // Print the pair
      System.out.println(k.first + " " + k.second);
    }
  }  
 
  // Driver code
  public static void main(String[] args)
  {
 
    // Given arr[]
    int arr[] = { 1, 2, 3, 4, 1,
                 2, 3, 4, 1, 2 };
 
    int N = arr.length;
 
    // Function call
    repeated_pairs(arr, N);
  }
}
 
// This code is contributed by offbeat


Python3
# Python3 program for the above approach
 
# Function to print adjacent pairs
# in sorted order
def repeated_pairs(arr, N):
     
    # Store the frequency of all
    # the adjacent pairs
    m = {}
 
    # Stores the resultant pairs
    v = []
 
    # Stores the count of all
    # adjacent pairs
    for i in range(N - 1):
        p = (arr[i], arr[i + 1])
 
        # Increment the count of pair
        m[p] = m.get(p, 0) + 1
 
    # Store pairs that appears more
    # than once
    for i in m:
         
        # If frequency is at least 1
        if (m[i] > 1):
            p = i
             
            # Insert pair into vector
            v.append(p)
 
    # Sort the vector
    v = sorted(v)
 
    # Print the pairs
    for i in range(len(v)):
        p = v[i]
 
        # Print the pair
        print(p[0], p[1])
 
# Driver Code
if __name__ == '__main__':
     
    # Given arr[]
    arr = [ 1, 2, 3, 4, 1,
            2, 3, 4, 1, 2 ]
 
    N = len(arr)
 
    # Function call
    repeated_pairs(arr, N)
 
# This code is contributed by mohit kumar 29


输出:
1 2
2 3
3 4
4 1

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