पूर्ववत जावास्क्रिप्ट

Question

में तरह पर हल कर देता है मैं निम्नलिखित कोड है:

//data_r is an array with values 

var i = 0; 
var sort_order = new Array(); 

data_r.sort(function (a,b) { 
    var res = a[0] - b[0]; 

    sort_order[i] = res; 
    i++; 

    return res; 
}); 

अंत में, SORT_ORDER सरणी प्रदर्शन किया, जब हम आइटम अनुसार क्रमबद्ध कार्यों में शामिल है। मैं एक दूसरी सरणी पहले के रूप में ठीक उसी तरह सॉर्ट करने के लिए चाहते हैं, तो मैं निम्नलिखित कर सकते हैं:

//data_x is an array with values 

var i = 0; 
data_x.sort(function (a,b) { 
    i++; 
    return sort_order[i-1]; 
}); 

अब डेटा_ X सरणी data_r सरणी के रूप में ठीक उसी तरह क्रमबद्ध किया जाता है।

सवाल यह है कि, मैं data_r सरणी को कैसे पूर्ववत कर सकता हूं?

निम्नलिखित कोड गलत है:

var unsort = new Array(); 

for(var i = 0; i < data_r.length; i++) 
    unsort[i] = sort_order[i]*(-1);//-1 so we perfom the oposite action 

क्यों, कृपया?

संपादित करें:

मैं सरणी की एक प्रतिलिपि नहीं कर सकता।

मेरे पास सरणी # 1 है। मैं इसे सॉर्ट करता हूं।

फिर मैं सरणी # 2 प्राप्त होता है लेकिन सरणी सरणी # 1 के आधार पर क्रमबद्ध किया जाता है।

मुझे सरणी # 2 पर सॉर्टिंग को उलट करने की आवश्यकता है।

संपादित करें 2:

सरणी # 1 = {9, 5, 3, 0, 2}

मैं सॉर्ट सरणी # 1:

सरणी # 1 = {0, 2, 3, 5, 9}

अब मैं प्राप्त सरणी # 2 # 1 सरणी के आधार पर छाँटे गए:

सरणी # 2 = { "घर", "कार", "ट्रेन", "पीसी", "माउस"}

मैं इस तरह सरणी # 2 बनाने की जरूरत है:

सरणी # 2 = { "माउस" पीसी "," ट्रेन "," घर "," कार "}

हल: http://jsfiddle.net/fQm3a/

Answer 1

@ duskwuff का उत्तर देखें कि आपका दृष्टिकोण क्यों काम नहीं करता है।

इसके बजाय, बस मूल डेटा और सॉर्ट किए गए डेटा के बीच मैपिंग शुरू करें।

{0:2, 1:3, 2:1, 3:0} 

पहला तत्व जिसका मतलब है, तीसरे बन गया दूसरा पिछले और इतने पर बन गया। नीचे हम एक वस्तु के बजाय एक सरणी का उपयोग करेंगे।

यह मानचित्र क्यों सहायता करता है? आप इसे जैसे सॉर्ट कर सकते हैं, जिसमें केवल उस डेटा के पॉइंटर्स के रूप में इसका उपयोग करके एक अन्य डेटासेट है जिसे आप तुलना करने जा रहे हैं। और आप अन्य डेटासेट पर आसानी से मैपिंग लागू कर सकते हैं। और आप उस मैपिंग को बहुत आसानी से उलट सकते हैं। आप data_x सरणी ही सॉर्ट करने के लिए चाहते हैं

// data_r, data_x are arrays with values 

var l = data_r.length; 
var sort_order = new Array(l); 
for (var i=0; i<l; i++) sort_order[i] = i; // initialised as 1-1 mapping 

// change the sort_order first: 
sort_order.sort(function (a,b) { 
    // a and b being indices 
    return data_r[a] - data_r[b]; 
}); 

// Making a new, sorted array 
var data_x_sorted = new Array(l); 
for (var i=0; i<l; i++) 
    data_x_sorted[ sort_order[i] ] = data_x[i]; // put it to sorted position 

, बस एल्गोरिथ्म जो मैं data_r के लिए पता चला है "लागू करें" का उपयोग करें: कोड में इसे देखें।

सवाल यह है कि, मैं data_r सरणी को कैसे पूर्ववत कर सकता हूं?

या तो इसे बिल्कुल हल न करें, और केवल इसकी प्रतिलिपि बनाएं जो क्रमबद्ध हो (या कुछ भी नहीं)।

या इसे हटाने के लिए sort_order का उपयोग करें। आपको बस i और newIndex (sortOrder[i]) हर जगह स्वैप करने की आवश्यकता होगी। एक नया, "अवर्गीकृत" (पुराने आदेश) सरणी के निर्माण के लिए उदाहरण:

var unsorted = new Array(l); 
for (var i=0; i<l; i++) 
    unsorted[i] = data_r[ sort_order[i] ]; // take it from its new position 

Answer 2

आपका आधार यहां त्रुटिपूर्ण है।

अंत में, सॉर्ट_ऑर्डर सरणी में आइटम को सॉर्ट करते समय किए गए क्रियाएं होती हैं।

नहीं, ऐसा नहीं है; इसमें जावास्क्रिप्ट Array.sort फ़ंक्शन द्वारा किए गए तुलनाओं की एक लॉग शामिल है। उन तुलना परिणामों के जवाब में किए गए कार्यों के लिए निजी हैं।

मैं एक दूसरी सरणी ठीक उसी तरह पहले के रूप में तो मैं निम्न कर सकते हैं सॉर्ट करने के लिए करना चाहते हैं:

यह काम करने के लिए गारंटी नहीं है। यहां तक ​​कि यदि दो सरणी एक ही आकार के हैं, Array.sort हमेशा एक ही ऑब्जेक्ट को उसी क्रम में तुलना नहीं कर सकते हैं जब भी इसे कॉल किया जाता है - यह संभव है कि यह एक यादृच्छिक एल्गोरिदम का उपयोग कर रहा हो, यह तुलनात्मक रूप से अन्य डेटा के आधार पर तुलना करता है जो दुभाषिया के लिए आंतरिक हैं , या यह कुछ परिस्थितियों में कई अलग-अलग प्रकार के एल्गोरिदम के बीच स्विच करता है।

हालांकि यह कोड आपके वर्तमान वेब ब्राउज़र में, आपके लिए काम कर सकता है, फिर भी यह अन्य परिस्थितियों (संभावित रूप से भविष्य के ब्राउज़र में) में आश्चर्यजनक तरीकों से असफल होने की संभावना है। उत्पादन तकनीक में इस तकनीक का उपयोग न करें।

सवाल यह है कि, मैं data_r सरणी को कैसे रद्द कर सकता हूं?

इसे सॉर्ट करने से पहले सरणी की प्रति बनाएं।

Answer 3

सॉर्ट फ़ंक्शन केवल एक संख्या देता है जो सकारात्मक, शून्य, या ऋणात्मक हो सकता है यदि वर्तमान तत्व पहले जाता है, वही वजन होता है, या तत्व के बाद भी जाता है जो इसकी तुलना कर रहा है। मैं कल्पना करता हूं कि आपके सॉर्ट ऑर्डर सरणी आपके डेटा_आर सरणी से अधिक है क्योंकि आपके द्वारा किए गए तुलना की संख्या। मैं इसे सॉर्ट करने से पहले डेटा_आर की प्रतिलिपि बनाउंगा और फिर उस सरणी के बराबर डेटा_आर सेट कर दूंगा जब आप इसे बिना छेड़छाड़ करना चाहते हैं।

Answer 4

भंडारण res [i] = a - b क्रमबद्ध() एल्गोरिदम जर्नलिंग की तरह है - लेकिन अगर यह एक यादृच्छिक पिवट का उपयोग करता है तो क्या होगा? यह कोड स्वाभाविक रूप से अविश्वसनीय है जब तक कि आप स्वयं को क्रमबद्ध नहीं करते हैं। यह भी अक्षम है।

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

यदि x 0: n-1 से है, तो उसी आकार के सरणी सॉर्ट_आई बनाएं, फिर प्रत्येक sort_i [i] = i प्रारंभ करें।

for(var i = 0; i < n; i++) 
    sort_i[i] = i; 

फिर

sort_i.sort(function (a,b) { return x[a] - x[b]; }); 

अब आप सूचकांक होते हैं। एक्स के लिए लागू करने के लिए:

for(var i = 0; i < n; i++) 
    sort_x[i] = x[sort_i[i]]; 

यह unsort के लिए, पहले सूचकांक

for(var i = 0; i < n; i++) 
    unsort_i[sort_i[i]] = i; 

को उलटने के बाद सूचकांक लागू होते हैं। सवाल पूछने के लिए छोड़ दिया व्यायाम।

पूर्णांक सूचकांक की एक सरणी को सॉर्ट करने का यह तरीका आवश्यक है जब आप मूल तत्वों को स्मृति में चारों ओर स्थानांतरित नहीं करना चाहते (शायद वे बड़ी वस्तुएं हैं), और कई अन्य परिस्थितियों में। असल में आप पॉइंटर्स सॉर्ट कर रहे हैं। नतीजा डेटा के लिए एक सूचकांक है, और एक रिवर्स इंडेक्स है।

Answer 5

आप इन सरणियों का एक बहुत बनाए रखने के लिए है, तो यह वस्तुओं, प्रत्येक की एक सरणी में रूप में अच्छी तरह परिवर्तित array1 हो सकता है जिसमें और सरणी में इसकी मूल स्थिति है। यह सब कुछ एक साथ में रखता है।

var array1 = [9, 5, 3, 0, 2]; 
var array2 = ["home", "car", "train", "pc", "mouse"]; 

var sort = function(array){ 
    var indexed_objects = array.map(function(value, index){ 
     return {index: index, value: value}; 
    }); 
    indexed_objects.sort(function(a,b){ 
     return a.value <= b.value ? -1 : 1; 
    }); 
    return indexed_objects; 
}; 

var sorted1 = sort(array1); 
sorted1; // [{index: 3, value:0}, {index: 4, value: 2}, ...] 

और अब, क्रमबद्ध ऑब्जेक्ट की श्रृंखला को देखते हुए, हम करने के लिए एक समारोह किसी अन्य सरणी तदनुसार unsort लिख सकते हैं:

var unsort = function(array, sorted_objects){ 
    var unsorted = []; 
    sorted_objects.forEach(function(item, index){ 
     unsorted[item.index] = array[index]; 
    }); 
    return unsorted; 
}; 

var array2_unsorted = unsort(array2, sorted1); 
array2_unsorted; // ["mouse", "pc", "train", "home", "car"]