बाइनरी ट्री एन्कोडिंग

Question

मान लीजिए कि आपके पास एक पूर्ण बाइनरी ट्री है (यानी प्रत्येक आंतरिक नोड में दो गैर खाली वंश हैं)। प्रत्येक नोड में एक नोज़ेरो पूर्णांक होता है। आपको पूर्णांक की सूची से पेड़ को इनकोडिंग और डिकोड करने का काम दिया जाता है।

पेड़ को आंतरिक रूप से कुछ इस तरह संग्रहीत किया जाता है:

struct node {
  int data;
  struct node *left, *right;
};

और आपको दो कार्य करने होंगे:

int *encode(struct node *root);
struct node *decode(int *array);

यह आपके ऊपर है कि आप किस तरह से एनकोड और डीकोड करते हैं।

इसके लिए अंक:

• न्यूनतम एन्कोडिंग लंबाई
• जटिलता (आदर्श रूप से नोड की संख्या में रैखिक)
• मोलिकता

स्रोत कोड की लंबाई के लिए कोई अंक और आप सी तक सीमित नहीं हैं।

पेड़ का उदाहरण:

     5
    / \
   3   2
      / \
     2   1
    / \
   9   9

Comments

इनपुट और आउटपुट आवश्यकताओं को चोट नहीं पहुंचेगी।

— यासिर अर्सानुकेव

@ वायसिर: एन्कोडिंग एल्गोरिदम आपका काम है इसलिए मैं कोई इनपुट और आउटपुट नहीं दे सकता। int *उपयोगकर्ता के लिए एक ब्लैक बॉक्स है।

— अलेक्जेंड्रू

क्या पूर्णांक की सीमा पर कोई प्रतिबंध है? अधिक विशेष रूप से अगर हम मनमाने ढंग से बड़े पूर्णांक के साथ एक भाषा का उपयोग करते हैं तो क्या हमें इसका उपयोग करने की अनुमति है? और एन्कोडेड डेटा का आकार पूर्णांक या बाइट्स की संख्या में मापा जाता है?

— 20

क्या सांकेतिक शब्दों में बदलना और डिकोड फ़ंक्शन को साइड-इफ़ेक्ट फ़्री (मेमोरी आवंटन के अलावा) होना चाहिए? या वे उदाहरण के लिए वैश्विक चर में डेटा स्टोर कर सकते हैं?

— sepp2k

डेटा पूर्णांकों को स्वयं वास्तविक 32-बिट पूर्णांक मानते हुए, एक सरल एन्कोडिंग है जो केवल 32 * n बिट्स का उपयोग करता है।

— आनन।

Answer 1

~ 1.03 एन

ऐसा लगता है कि अब तक के सभी उत्तरों में स्टोर करने के लिए कम से कम 2 * N * 32-बिट हैं। (भाषाओं में समाधानों को छोड़कर जो 32 बिट्स से अधिक पूर्णांक मानों की अनुमति देता है, जैसे हास्केल और रूबी समाधान - लेकिन वे अभी भी अतिरिक्त बाइट्स लेने जा रहे हैं जब भी डेटा 16K से अधिक हो।

यहां एक समाधान है जो केवल एन + सीलिंग (एन / 32) +1 इन्ट्स स्टोरेज लेता है। यह बड़े एन के लिए 1.03125 एन तक पहुंचता है, और 20 से अधिक सभी एन के लिए 1.1 एन के नीचे है।

विचार प्रत्येक नोड के लिए एक अतिरिक्त बिट स्टोर करने का है जहां 1 "हैशल्ड्रेन" है। ये बिट्स एन / 32 शब्दों में सामने से भरे होते हैं।

int* encodeHelper(Node* n, int* code, int* pos, int* flag)
{
   int hasKids = (n->left!=0);
   code[*flag/32]|=hasKids<<(*flag&31);
   *flag+=1;
   if (hasKids) bencodeHelper(n->left, code, pos, flag);
   code[*pos]=n->data;
   *pos+=1;
   if (hasKids) bencodeHelper(n->right, code, pos, flag);
   return code;
}

int* encode(Node* h, int* sizeOut)
{
   int nnodes=countNodes(h);
   int nflags = (int)ceil(nnodes/32.0);
   int pos=nflags+1;
   int flag=32;
   int* out;
   *sizeOut = 1+nnodes+nflags;
   out = calloc(*sizeOut, sizeof(int));
   if (!h) return out;
   out[0]=nflags+1; //store start of data
   return encodeHelper(h,out,&pos,&flag);
}

Node* decodeHelper(int* code, int* pos, int* flag)
{
   Node*n = calloc(1, sizeof(Node));
   int hasKids = code[*flag/32]>>(*flag&31)&1;
   *flag+=1;
   if (hasKids) n->left = bdecodeHelper(code, pos, flag);
   n->data = code[*pos];
   *pos+=1;
   if (hasKids) n->right = bdecodeHelper(code, pos, flag);
   return n;
}

Node* decode(int* code)
{
   int flag=32;
   int pos=code[0];
   if (!pos) return NULL;
   return decodeHelper(code, &pos, &flag);
}

(यहां पर संकलन लागू करें)

Answer 2

यह हास्केल कार्यक्रम एन इंटिजर्स में एन नोड्स के एक पेड़ को एनकोड करता है। चाल यह है कि यह नोड के डेटा को दोगुना कर देता है, और फिर निचले क्रम के बिट का उपयोग करके यह इंगित करता है कि यह लीफ नोड है या आंतरिक नोड।

तकनीकी रूप से, Parserयहां का मोनाड ओवर-किल है, क्योंकि केवल एक ही पार्सर बनाया गया है, decoderऔर मैं पार्सर को सीधे तर्क देने वाले तर्क को रख सकता था। लेकिन इस तरह से डिकोडर बहुत स्पष्ट है, और Parserछोटे आकार के बावजूद, एक उचित सरल पार्सिंग ढांचा है।

import Control.Monad (ap)

data Tree = Leaf Integer | Node Integer Tree Tree
  deriving (Eq, Show)

encode :: Tree -> [Integer]
encode (Leaf n)     = [n*2]
encode (Node n t u) = (n*2+1) : encode t ++ encode u

decode :: [Integer] -> Maybe Tree
decode = fullyParse decoder
  where
    decoder :: Parser Integer Tree
    decoder = do
      i <- next
      let n = i `div` 2
      if even i
        then return (Leaf n)
        else return (Node n) `ap` decoder `ap` decoder

-- A simple Parsing Monad
data Parser a b = P { runParser :: [a] -> Maybe (b, [a]) }

instance Monad (Parser a) where
  return a = P ( \ts -> Just (a, ts) )
  p >>= q  = P ( \ts -> runParser p ts >>= (\(v,ts') -> runParser (q v) ts') )
  fail _   = P ( const Nothing )

next :: Parser a a
next = P n
 where n (t:ts) = Just (t,ts)
       n _      = Nothing

fullyParse :: Parser a b -> [a] -> Maybe b
fullyParse p ts = runParser p ts >>= consumedResult
  where
    consumedResult (v,[]) = Just v
    consumedResult _      = Nothing

-- Example
main :: IO ()
main = do
    putStrLn $ "example:  " ++ show ex
    putStrLn $ "encoding: " ++ show encEx
    putStrLn $ "decoding: " ++ show decEx
    putStrLn $ "worked?   " ++ show worked
  where
    ex = Node 5
          (Leaf 3)
          (Node 2
            (Node 2
              (Leaf 9)
              (Leaf 9)
            )
            (Leaf 1)
          )
    encEx = encode ex
    decEx = decode encEx
    worked = maybe False (ex ==) decEx

इसे चलाने से आपको प्राप्त होता है:

> runhaskell TreeEncoding.hs 
example:  Node 5 (Leaf 3) (Node 2 (Node 2 (Leaf 9) (Leaf 9)) (Leaf 1))
encoding: [11,6,5,5,18,18,2]
decoding: Just (Node 5 (Leaf 3) (Node 2 (Node 2 (Leaf 9) (Leaf 9)) (Leaf 1)))
worked?   True

Answer 3

सी में

#include <stdlib.h>
#include <stdio.h>

struct Node;
typedef struct Node Node;

struct Node
{
    int   data;
    Node* left;
    Node* right;
};
/* Private Functions */
static int*  encodeNode(Node* tree, int* store);
static Node* decodeNode(int** store);

/* Public Functions */
Node*   newNode(int data,Node* left,Node* right);
void    deleteTree(Node* tree);
int     countNodesTree(Node* tree);
int*    encode(Node *tree);
Node*   decode(int* store);
void    printTree(Node* tree);

Node* newNode(int data,Node* left,Node* right)
{
    Node* result    = (Node*)malloc(sizeof(Node));
    result->data    = data;
    result->left    = left;
    result->right   = right;

    return result;
}

void deleteTree(Node* tree)
{
    if (tree == NULL)
    {   return;
    }

    deleteTree(tree->left);
    deleteTree(tree->right);
    free(tree);
}

int countNodesTree(Node* tree)
{
    if (tree == NULL)
    {   return 0;
    }

    return    countNodesTree(tree->left)
            + countNodesTree(tree->right)
            + 1;
}

void printTree(Node* tree)
{
    if (tree == NULL)
    {
        fprintf(stdout, "- ");
    }
    else
    {
        fprintf(stdout, "%d ", tree->data);
        printTree(tree->left);
        printTree(tree->right);
    }
};

सांकेतिक शब्दों में बदलना:

int* encode(Node *tree)
{
    int     nodeCount   = countNodesTree(tree);
    int*    result      = (int*)malloc(sizeof(int) * (nodeCount * 2 + 1));

    // Put the node count in the first element.
    // This makes it easy to also serialize this object for transport
    // i.e. you can put it in a file or a stream (socket) and easily recover it.
    result[0]           = nodeCount;
    encodeNode(tree, result + 1);
    return result;
}

int* encodeNode(Node* tree, int* store)
{
    if (tree != NULL)
    {
        store[0]    = tree->data;
        /*
         * Slight overkill. for this question.
         * But works and makes future enhancement easy
         */
        store[1]    = (tree->left  == NULL ? 0 : 1)
                    + (tree->right == NULL ? 0 : 2);
        store += 2;

        store       = encodeNode(tree->left,  store);
        store       = encodeNode(tree->right, store);
    }
    return store;
}

डिकोड:

Node* decode(int* store)
{
    if (store == NULL)
    { fprintf(stderr, "Bad Input terminating: encode() always return non NULL\n");
      exit(1);
    }

    if (store[0] == 0)
    {
        return NULL;
    }

    store++;
    return decodeNode(&store);
}

Node* decodeNode(int** store)
{
    int     value   = (*store)[0];
    int     flag    = (*store)[1];
    (*store) += 2;

    Node*   left    = flag & 1 ? decodeNode(store) : NULL;
    Node*   right   = flag & 2 ? decodeNode(store) : NULL;

    return newNode(value, left, right);
}

मुख्य:

int main()
{
    Node*   t = newNode(5,
                        newNode(3, NULL, NULL),
                        newNode(2,
                                newNode(2,
                                        newNode(9, NULL, NULL),
                                        newNode(9, NULL, NULL)
                                       ),
                                newNode(1, NULL, NULL)
                               )
                       );

    printTree(t);
    fprintf(stdout,"\n");

    int*    e   = encode(t);
    Node*   d   = decode(e);
    printTree(d);
    fprintf(stdout,"\n");

    free(e);
    deleteTree(d);
    deleteTree(t);
}

ध्यान दें। प्रत्येक नोड को दो पूर्णांकों के रूप में एन्कोड किया गया है (नोड्स की गणना के लिए एक इंट)।
तो आपूर्ति किए गए पेड़ इस तरह से एन्कोड करते हैं:

 7, 5, 3, 3, 0, 2, 3, 2, 3, 9, 0, 9, 0 1, 0
 ^  ^
 ^  ^ Node 1
 ^
 Count

Answer 4

रूबी में, @MnnViewMark के समान एन्कोडिंग के साथ :

class Node
        def initialize(data, left = nil, right = nil)
                @data, @left, @right = data, left, right
        end

        def encode
                "%d %s %s" % [@data<<1|1, @left.encode, @right.encode]
        end

        class << self
                def decode(str)
                        _decode(str.split.map &:to_i)
                end

                private

                def _decode(a)
                        n = a.shift
                        if n & 1 == 1
                                Node.new(n>>1, _decode(a), _decode(a))
                        else
                                Leaf.new(n>>1)
                        end
                end
        end
end

class Leaf < Node
        def encode
                (@data<<1).to_s
        end
end

tree=Node.decode("11 6 5 5 18 18 2")
print tree.encode

लागत प्रति नोड एक पूर्णांक है ( data << 1 | has_childs):

11 6 5 5 18 18 2

Comments

वाह - जो दुबला और सुरुचिपूर्ण दिखता है। हालांकि, यह इंट का एरियर नहीं लेता है, क्या यह है?

— उपयोगकर्ता अज्ञात

Answer 5

nनोड्स के साथ एक द्विआधारी पेड़ को देखते हुए , यह इसे 2n + 1पूर्णांक की सूची में संलग्न करता है। एन्कोडिंग और डिकोडिंग एल्गोरिदम दोनों में O(n)जटिलता है।

मैं एन्कोडिंग करते समय एक पूर्णांक मार्कर के रूप में 0 पूर्णांक का उपयोग करता हूं, जब मैं पुनरावृत्ति को प्रकट करता हूं। फिर जब मैं डिकोड कर रहा होता हूं, मैं ट्री नोड्स बना रहा हूं जो एक स्टैक पर बना रहा है (सॉर्ट का) और सूची में 0s का उपयोग करके अगले नोड को जोड़ने के लिए ट्रैक करें। मैंने कोशिश नहीं की है, लेकिन मुझे पूरा यकीन है कि अगर पेड़ पूरा नहीं होता तो डिकोडिंग टूट जाएगी।

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

// Prototypes
struct BTnode;
struct BTnode * bt_add_left(struct BTnode * node, int data);
struct BTnode * bt_add_right(struct BTnode * node, int data);
int             bt_depth(struct BTnode * tree);
int             bt_encode_preorder(int * list, struct BTnode * tree, int index);
struct BTnode * bt_node_create(int data);
int             bt_node_delete(struct BTnode * node);
void            bt_print_preorder(struct BTnode * tree);
int *           encode(struct BTnode * tree);
struct BTnode * decode(int * list);

// Binary tree node
struct BTnode
{
  int data;
  struct BTnode *left, *right;
};

// Add node to this node's left
struct BTnode * bt_add_left(struct BTnode * node, int data)
{
  struct BTnode * newnode = bt_node_create(data);
  node->left = newnode;
  return newnode;
}

// Add node to this node's right
struct BTnode * bt_add_right(struct BTnode * node, int data)
{
  struct BTnode * newnode = bt_node_create(data);
  node->right = newnode;
  return newnode;
}

// Determine depth of the tree
int bt_depth(struct BTnode * tree)
{
  int depth;
  int leftdepth = 0;
  int  rightdepth = 0;
  if( tree == NULL ) return 0;

  if( tree->left != NULL )
    leftdepth = bt_depth(tree->left);
  if( tree->right != NULL )
    rightdepth = bt_depth(tree->right);

  depth = leftdepth;
  if(rightdepth > leftdepth)
    depth = rightdepth;

  return depth + 1;
}

// Recursively add node values to integer list, using 0 as an unfolding sentinel
int bt_encode_preorder(int * list, struct BTnode * tree, int index)
{
  list[ index++ ] = tree->data;

  // This assumes the tree is complete (i.e., if the current node does not have
  // a left child, then it does not have a right child either)
  if( tree->left != NULL )
  {
    index = bt_encode_preorder(list, tree->left, index);
    index = bt_encode_preorder(list, tree->right, index);
  }

  // Add sentinel
  list[ index++ ] = 0;
  return index;
}

// Allocate memory for a node
struct BTnode * bt_node_create(int data)
{
  struct BTnode * newnode = (struct BTnode *) malloc(sizeof(struct BTnode));
  newnode->left = NULL;
  newnode->right = NULL;
  newnode->data = data;
  return newnode;
}

// Free node memory
int bt_node_delete(struct BTnode * node)
{
  int data;
  if(node == NULL)
    return 0;
  data = node->data;

  if(node->left != NULL)
    bt_node_delete(node->left);
  if(node->right != NULL)
    bt_node_delete(node->right);

  free(node);
  return data;
}

// Print all values from the tree in pre-order
void bt_print_preorder(struct BTnode * tree)
{
  printf("%d ", tree->data);
  if(tree->left != NULL)
    bt_print_preorder(tree->left);
  if(tree->right != NULL)
    bt_print_preorder(tree->right);
}

// Decode binary tree structure from a list of integers
struct BTnode * decode(int * list)
{
  struct BTnode * tree;
  struct BTnode * nodestack[ list[0] ];
  int i,j;

  // Handle trivial case
  if( list == NULL ) return NULL;

  tree = bt_node_create( list[1] );
  nodestack[ 1 ] = tree;

  j = 1;
  for(i = 2; i < list[0]; i++)
  {
    if( list[i] == 0 )
    {
      //printf("popping\n");
      j--;
    }
    else
    {
      if( nodestack[j]->left == NULL )
      {
        //printf("Adding %d to left of %d\n", list[i], nodestack[j]->data);
        nodestack[ j+1 ] = bt_add_left(nodestack[j], list[i]);
        j++;
      }
      else
      {
        //printf("Adding %d to right of %d\n", list[i], nodestack[j]->data);
        nodestack[ j+1 ] = bt_add_right(nodestack[j], list[i]);
        j++;
      }
    }
  }

  return tree;
}

// Encode binary tree structure as a list of integers
int * encode(struct BTnode * tree)
{
  int maxnodes, depth, length;
  int * list;
  int j;

  // Handle trivial case
  if(tree == NULL) return NULL;

  // Calculate maximum number of nodes in the tree from the tree depth
  maxnodes = 1;
  depth = bt_depth(tree);
  for(j = 0; j < depth; j++)
  {
    maxnodes += pow(2, j);
  }

  // Allocate memory for the list; we need two ints for each value plus the
  // first value in the list to indicate length
  list = (int *) malloc( ((maxnodes * 2)+1) * sizeof(int));
  length = bt_encode_preorder(list, tree, 1);
  list[ 0 ] = length;
  return list;
}

int main()
{
  struct BTnode * tree;
  struct BTnode * newtree;
  int * list;
  int i;

  /* Provided example

        5
       / \
      3   2
         / \
        2   1
       / \
      9   9
  */
  tree = bt_node_create(5);
  bt_add_left(tree, 3);
  struct BTnode * temp = bt_add_right(tree, 2);
  bt_add_right(temp, 1);
  temp = bt_add_left(temp, 2);
  bt_add_left(temp, 9);
  bt_add_right(temp, 9);
  printf("T (traversed in pre-order):  ");
  bt_print_preorder(tree);
  printf("\n");

  list = encode(tree);
  printf("T (encoded as integer list): ");
  for(i = 1; i < list[0]; i++)
    printf("%d ", list[i]);
  printf("\n");

  newtree = decode(list);
  printf("T' (decoded from int list):  ");
  bt_print_preorder(newtree);
  printf("\n\n");


  // Free memory
  bt_node_delete(tree);
  bt_node_delete(newtree);
  free(list);
  return 0;
}

इसे सहेजा encode.cगया और फिर संकलित और निष्पादित किया गया। यह प्रोग्राम आपके द्वारा दिए गए उदाहरण ट्री का उपयोग करता है, और मैंने इसे कुछ अन्य लोगों पर सफलतापूर्वक परीक्षण किया है।

$ gcc -Wall -lm -o encode encode.c
$ ./encode 
T (traversed in pre-order):  5 3 2 2 9 9 1 
T (encoded as integer list): 5 3 0 2 2 9 0 9 0 0 1 0 0 0 
T' (decoded from int list):  5 3 2 2 9 9 1

Comments

यह बहुत ज्यादा है जो मेरे मन में था :)।

— अलेक्जेंड्रू

यदि डेटा 0 हो तो यह डिकोडिंग में विफल नहीं होगा?

— एशेल्ली

@AShelly उन्होंने स्पष्ट रूप से कहा कि 0 को पेड़ में शामिल नहीं किया जाएगा। अगर ऐसा होता, तो हाँ यह विफल होता।

— डैनियल स्टैंडेज

Answer 6

मेरा कोड ट्री को प्रीऑर्डर ट्रैवर्सल, प्रत्येक पत्ती को दो इन्ट्स (इसके बाद 0 में डेटा) और प्रत्येक आंतरिक नोड को एक इंट (इसके बाद उसके बाएं बच्चे द्वारा डेटा, उसके बाद दाएं) में एनकोड करता है। एक पूर्ण बाइनरी ट्री के लिए (जैसा कि आप इसे परिभाषित करते हैं) n nodes के साथ, n विषम होना चाहिए, और वहाँ (n + 1) / 2 पत्ते और (n-1) / 2 आंतरिक नोड हैं, इसलिए यह 3n / 2 + 1 / है एन्कोडिंग के लिए 2 पूर्णांक।

चेतावनी: अप्रयुक्त, बस इसे टाइप किया गया।

struct node {
  int data;
  struct node *left, *right;
};

void encodeInternal(struct node *root, vector<int> *buf) {
  buf->push_back(root->data);
  if (root->left) {
    encodeInternal(root->left, buf);
    encodeInternal(root->right, buf);
  } else {
    buf->push_back(0);
  }
}
int *encode(struct node *root) {
  vector<int> buf;
  encodeInternal(root, &buf);
  return &buf[0];
}

struct decodeResult {
  int encoded_size;
  struct node *n;
}
struct decodeResult decodeInternal(int *array) {
  struct node *n = (struct node*)malloc(sizeof(struct node));
  n->data = array[0];
  if (array[1] == 0) {
    n->left = n->right = NULL;
    return (decodeResult){2, n};
  } else {
    decodeResult L = decodeInternal(array + 1);
    decodeResult R = decodeInternal(array + 1 + L.encoded_size);
    n->left = L.n;
    n->right = R.n;
    return (decodeResult){1 + L.encoded_size + R.encoded_size, n};
  }
}
struct node *decode(int *array) {
  return decodeInternal(array).n;
}

Answer 7

यहाँ मेरी कोशिश है। यह पेड़ को आकार 2 + गहराई + 1 के एक सरणी में संग्रहीत करता है। यह a[0]आकार को पकड़ने के लिए उपयोग करता है, और a[size]पहले "खाली नोड" के सूचकांक को पकड़ने के लिए यह गहराई-पहले ट्रैवर्सल में सामना करता है। (एक खाली नोड वह स्थान है जहां एक बच्चे को संग्रहीत किया जाएगा यदि माता-पिता के पास एक हो)। प्रत्येक खाली नोड अगले खाली नोड का सूचकांक रखता है जो सामने होगा।

यह योजना प्रीसेट बच्चों को चिह्नित करने के लिए बिट्स को जमा करने से बचाती है, इसलिए प्रत्येक नोड पूर्ण पूर्णांक सीमा का उपयोग कर सकता है। यह असंतुलित पेड़ों को भी अनुमति देता है - एक माता-पिता का एक ही बच्चा हो सकता है।

उत्पादन:

empty tree:  [0]
head node only:  [2,5,0]
example tree: [16,5,3,2,5,14,2,1,0,0, 0,0,9,9,15,0,4];

एनकोडर:

//utility
 int findDepth(Node* n) {
    int l = 0 ,r = 0;
    if (n) {
       l = 1 + findDepth(n->left);
       r = 1 + findDepth(n->right);
    }
    return ( l > r ) ? l : r;
 }

//Encode Function
 int* encodeTree(Node* head) {
    int* out;
    int depth = findDepth(head);
    int size = depth>0;
    while (depth--) size*=2;
    out = calloc(size+1,sizeof(int));
    out[0]=size;
    encodeNode(head, out,1, out+size);
    return out;
 }

 void encodeNode(Node* n, int* a, int idx, int* pEmpty) {
    if (n) {
       a[idx]=n->data;
       encodeNode(n->left,a,idx*2,pEmpty);
       encodeNode(n->right,a,idx*2+1,pEmpty);
    }
    else if (idx<a[0]) {
       *pEmpty = idx;
       pEmpty = a+idx;
    }
 }

विकोडक:

 //Decode Function
 Node* decodeArray(int* a) {
    return (a[0]) ?  decodeNode(a,1,a+a[0]) : NULL;
 }

 Node* decodeNode(int* a, int idx, int* pEmpty) {
    Node* n = NULL;
    if (idx== *pEmpty)
       *pEmpty=a[idx];
    else {
       n = calloc(1,sizeof(Node));
       n->data = a[idx];
       if (idx*2<a[0]) {
          n->left = decodeNode(a, idx*2, pEmpty);
          n->right = decodeNode(a, idx*2+1, pEmpty);
       }
    }
    return n;
 }

---

(प्रारूप निर्धारण के लिए धन्यवाद @daniel सोबरल)

Answer 8

स्काला:

trait Node {
  def encode (): Array[Int]
}

case object Node {
  def decode (a: Array[Int]): InnerNode = {
    if (a.length == 1) InnerNode (a(0)) else {
      val r = InnerNode (a(1)) 
      val l = decode (a.tail.tail) 
      InnerNode (a(0), l, r) 
    }
  }
}

case object Leaf extends Node {
  def encode (): Array[Int] = Array.empty
}

case class InnerNode (val data: Int, var l: Node=Leaf, var r: Node=Leaf) extends Node {
  def encode (): Array[Int] = Array (data) ++ r.encode () ++ l.encode () 
}

object BinTreeTest extends App {
  println (Node.decode (Array (1, 2, 3, 4, 5)).encode.mkString (", "))
}

यह एक दृष्टिकोण है जो अपग्रेड किए गए सिंटैक्स का उपयोग करता है, लेकिन स्कैला 2.9.1 में त्रुटि के बिना संकलित करता है। यह एक ट्री जनरेट करता है और हर एन्कोडेड ट्री को उसी Array में डिकोड करता है जो एन्कोडिंग के लिए उपयोग किया जाता है। हो सकता है कि मुझे आज किसी तरह से हटाए गए चेतावनियों से छुटकारा मिल जाए।

वाह - यह एक सरल था। पहले विचार ने तुरंत काम किया।