algorithm - Rearranging data for quadtree/octree -

मेरे पास एक एल्गोरिथम समस्या है!

मैं एक voxel octree raycaster को लागू करने पर काम कर रहा हूं, और केवल छोड़ी गई वस्तु ओकट्री के पत्ते के स्तर को पॉप्युलेट करने के लिए डेटा को दोबारा बदल रही है, ताकि डेटा को वृक्ष के निचले स्तर के निर्माण के लिए औसत किया जा सके।

मैं 2 डी (क्वाटट्री) में शुरुआत में सोच रहा हूं सुविधा। मेरे पास आरेखण की बाईं ओर जैसे डेटा का आदेश दिया गया है, और मैं वर्तमान में इसे सही तरह से पुनर्व्यवस्थित कर रहा हूं। उदाहरण 8x8 है।

हालांकि, मुझे एहसास हुआ कि मुझे डेटा को नोड क्रम में ऑर्डर करने की आवश्यकता है, जैसे नीचे दिए गए चित्र में:

दूसरे शब्दों में, मैं एक सरणी से जाना चाहता हूं जहां डेटा इस तरह के इंडेक्स के अनुरूप है:

  [0 1 2 3 4 5 6 7 8 9 .. 63]   
 एक ऑर्गेन में जिसके पास इस क्रम में डेटा होगा:  
  [0 1 4 5 16 17 20 21 2 3 ... 63]   
 एक 8x8 quadtree उदाहरण के लिए।  
 मुझे यह पता नहीं लगा कि यह कैसे करना है। मेरी मुख्य समस्या एक मनमानी वृक्ष आकार के साथ काम कर रही है। मैं शायद नेस्टेड लूपों का एक सेट हार्ड-कोड अगर मुझे पहले से आकार पता था, लेकिन यह स्पष्ट रूप से एक महान या सुरुचिपूर्ण समाधान नहीं है मैं सोच रहा हूं कि इसमें एक पुनरावर्ती तरीके से इसे प्राप्त किया जा सकता है।  
 यह चित्र के रूप में वर्णित तरीके से डेटा को सॉर्ट करने के लिए यह मेरा त्वरित और गंदे स्केच है यह मूल रूप से मूल आंकड़ों में चार स्थितियों का ट्रैक रखता है, और फिर इन सरलीकरण को आगे बढ़ाता है क्योंकि नई सरणी भर जाती है। जहां तक ​​मैं यह कहने में सक्षम हूं, यह ठीक काम करता है, लेकिन मेरी जरूरतों के अनुरूप नहीं है।  
  int w = 8; Int [] से पहले = नया int [w * w * w]; Int [] के बाद = नए int [w * w * w]; के लिए (इंट i = 0; i & lt; w * w * w; i ++) {पहले [i] = i; } Int toFill = 0; Int front = 0; Int back = w; Int frontZ = w * w; Int backZ = w * w + w; {के लिए (इंट i = 0; i & lt; w / 2; i ++) {for (int j = 0; j & lt; w / 2; j ++) {tofill ++] = सामने ++ के बाद; [ToFill ++] = सामने ++ के बाद; [ToFill ++] के बाद = वापस ++; [ToFill ++] के बाद = वापस ++; के बाद [toFill ++] = फ्रंटज़ ++; के बाद [toFill ++] = फ्रंटज़ ++; [ToFill ++] के बाद = backZ ++; [ToFill ++] के बाद = backZ ++; } सामने + = w; वापस + = w; फ्रंटज़ + + डब्ल्यू; BackZ + = w; } सामने + = w * w; वापस + = w * w; फ्रंटZ + = w * w; BackZ + = w * w; } जबकि (toFill & lt; w * w * w); के लिए (इंट i = 0; i & lt; w * w * w; i ++) {println ("बाद" + i + "" के बाद [i]); }   
 किसी भी विचार की सराहना!   
 
 
 समस्या के लिए मैंने कहा ,  पीएचएस  ने मुझे संकेत दिया कि उसे ज़ेड-ऑर्डर वक्र कहा जाता है इसके लिए धन्यवाद, मुझे यह प्रश्न मिला: जहां 2 डी केस के लिए एक एल्गोरिथ्म प्रस्तुत किया गया है। मैने इसे आजमाया और इसने कार्य किया।  
 यहां 3 डी केस के कुछ लागूकरण भी हैं: