सरणी से अद्वितीय मूल्यों को कुशलतापूर्वक निकालने के लिए कैसे?

Question

मैं अपने (गतिशील रूप से आवंटित) सरणी से अद्वितीय मान निकालना चाहता हूं।

[0]  0 int 
    [1]  1 int 
    [2]  2 int 
    [3]  2 int 
    [4]  2 int 
    [5]  5 int 
    [6]  6 int 
    [7]  6 int 
    [8]  8 int 
    [9]  9 int 
    [10] 10 int 
    [11] 8 int 
    [12] 12 int 
    [13] 10 int 
    [14] 14 int 
    [15] 6 int 
    [16] 2 int 
    [17] 17 int 
    [18] 10 int 
    [19] 5 int 
    [20] 5 int 

मैं इसे किया जा रहा है अनूठा मूल्य अन्य सरणी फार्म में हर रिकॉर्ड के साथ आकार 12 की सारणी रखने के लिए चाहते हैं: मैं कुछ इस तरह की है।

मैं यह कैसे कर सकता हूं?

संपादित मुझे लगता है कि मैं एसटीएल कंटेनर (जैसे std::vector या std::list) का उपयोग नहीं कर सकते हैं उल्लेख करना भूल गया

Answer 1

सबसे पहले आपको सरणी को सॉर्ट करने की आवश्यकता है, फिर क्रमबद्ध सरणी पर फिर से चालू करें और जांचें कि पिछली या अगली प्रविष्टि वर्तमान प्रविष्टि के समान है या नहीं। यदि नहीं तो मूल्य अद्वितीय है।

संपादित करें: मैंने प्रश्न को गलत समझा होगा ... आप जो चाहते हैं उसे प्राप्त करने का एक तरीका सरणी पर फिर से चलाना है। प्रत्येक मान के लिए जांच करें कि अन्य सरणी में मान पहले से मौजूद है, अगर वहां इसकी प्रतिलिपि नहीं है। इसे संख्या अद्वितीय प्रविष्टियों (मौजूदा आकार के समान आकार का उपयोग करके) और एक को सही आकार की सरणी प्राप्त करने के लिए दो चरणों में किया जाना पड़ सकता है।

Answer 2

उपयोग std::unique अपने पसंदीदा छँटाई कलन विधि के साथ अपने सरणी छँटाई के बाद (जैसे std::sort)

संपादित करें: एसटीएल के बिना, सबसे सरल समाधान सरणी में न्यूनतम & अधिकतम मानों को ढूंढना होगा और गतिशील रूप से bool की सरणी आवंटित करना होगा। सरणी को पार करें और यदि आप तत्व देखते हैं, तो संबंधित bool तत्व true पर सेट करें। अद्वितीय तत्वों की कुल संख्या के साथ एक नया int सरणी आवंटित करें और इसे bool सरणी से डेटा के साथ भरें।

अनुशंसित: सरणी को सॉर्ट करें और लगातार तत्वों को हटा दें। त्वरित प्रकार को कार्यान्वित करना बहुत कठिन नहीं है, और यदि आप पूर्णांक से निपट रहे हैं, तो radix sort बेहतर हो सकता है।

Answer 3

आप स्रोत सरणी के प्रत्येक मान को स्टोर करने के लिए हैश सेट (unordered_set) का उपयोग कर सकते हैं। सेट स्वचालित रूप से केवल अद्वितीय मानों को संग्रहीत करेगा। फिर, यदि आपको वास्तव में एक सरणी की आवश्यकता है और सेट नहीं है, तो आप अच्छे आकार की एक सरणी बना सकते हैं और इसे सेट के तत्वों से भर सकते हैं।

Answer 4

आप std::set का उपयोग कर सकते हैं। इसके लिए सभी तत्व जोड़ें, अंत में केवल अद्वितीय मान मौजूद होंगे।

Answer 5

यदि आप अधिकतम और न्यूनतम जानते हैं तो आप अपने द्वारा प्राप्त किए जा सकने वाले सभी संभावित मानों के साथ एक नई सरणी बना सकते हैं और फिर अपनी गतिशील सरणी के माध्यम से लूप कर सकते हैं। मूल्य के सूचकांक के रूप में नई सरणी के लिए प्रत्येक मान सेट 1 के लिए। एक उदाहरण के रूप: - कहते हैं कि तुम इस 1,2,2,4,6

की तरह डेटा है तो सीमा 1 से 7

को दूसरी सरणी इस

1 2 3 4 5 6 7 
1 1 0 1 0 1 0 

algo की जटिलता तरह होगा किया जाएगा 2 एन

Answer 6

#include <iostream> 
#include <stdlib.h> 
using namespace std; 

int cmpfun(const void * a, const void * b){ 
    return (*(int*)a - *(int*)b); 
} 
int main(){ 
    int n,i,j=0; 
    cout<<"Enter the number of elements in the array:\n"; 
    cin>>n; 
    int arr[n],arr_new[n]; 
    for(i=0;i<n;i++) 
     cin>>arr[i]; 
    qsort(arr, n, sizeof(int), cmpfun); /*Sorting the array; if you aren't allowed to use any library sorting method, 
            then I suggest to implement one sorting function on your own.*/ 

    for(i=0;i<n;i++){ 
     arr_new[j++]=arr[i]; 
     // Excluding all duplicates 
     while(i<(n-1) && arr[i]==arr[i+1]) 
       i++; 
    } 
    for(i=0;i<j;i++) 
    cout<<arr_new[i]<<" "; 

return 0;} 

मुख्य उद्देश्य यह सुनिश्चित करना है कि डुप्लीकेट को नजरअंदाज कर दिया जाए। तो, आपको पहले सरणी को क्रमबद्ध करना चाहिए और फिर ओ (एन) समय में, सरणी को पार करना चाहिए, सभी पुनरावृत्ति को अनदेखा करना चाहिए। सरणी को घुमाने के दौरान, नए सरणी में सभी अद्वितीय मानों (मान जिन्हें आप पहली बार सामना करते हैं) की प्रतिलिपि बनाएँ।

एकमात्र चीज जो मुझे मिलती है वह आपको चिंता कर सकती है कि पुरानी सरणी में तत्वों का संबंधित क्रम नई सरणी में संरक्षित नहीं है। लेकिन अगर आप केवल अद्वितीय मूल्यों को ढूंढने के लिए चिंतित हैं, तो इस विधि को ठीक काम करना चाहिए।