Đưa ra một danh sách các số nguyên duy nhất, được sắp xếp, tạo một cây tìm kiếm nhị phân cân bằng được biểu diễn dưới dạng một mảng mà không sử dụng đệ quy.

Ví dụ:

func( [1,2,3,5,8,13,21] ) => [5,2,13,1,3,8,21]

Trước khi bắt đầu, một gợi ý: chúng ta có thể đơn giản hóa vấn đề này một tấn để chúng ta không thực sự phải suy nghĩ về các số nguyên đầu vào (hoặc bất kỳ đối tượng có thể so sánh nào cho vấn đề đó!).

Nếu chúng ta biết danh sách đầu vào đã được sắp xếp, nội dung của nó không liên quan. Chúng ta có thể chỉ cần nghĩ về nó theo các chỉ số vào mảng ban đầu.

Một đại diện bên trong của mảng đầu vào sau đó trở thành:

func( [0,1,2,3,4,5,6] ) => [3,1,5,0,2,4,6]

Điều này có nghĩa là thay vì viết một cái gì đó phải xử lý các đối tượng có thể so sánh, chúng ta thực sự chỉ cần viết một hàm ánh xạ từ phạm vi [0, n) sang mảng kết quả. Khi chúng ta có thứ tự mới, chúng ta chỉ cần áp dụng ánh xạ trở lại các giá trị trong đầu vào để tạo mảng trả về.

Các giải pháp hợp lệ phải:

• Chấp nhận một mảng phần tử zero và trả về một mảng trống.
• Chấp nhận một mảng số nguyên có độ dài n và trả về một mảng số nguyên
  • Có độ dài giữa n và công suất cao nhất tiếp theo là 2 trừ 1. (ví dụ, đối với kích thước đầu vào 13 trả về bất cứ nơi nào trong khoảng từ 13 đến 15).
  • Mảng đại diện cho một BST trong đó nút gốc ở vị trí 0 và chiều cao bằng log (n) trong đó 0 đại diện cho một nút bị thiếu (hoặc nullgiá trị giống như nếu ngôn ngữ của bạn cho phép). Các nút trống, nếu có, chỉ phải tồn tại ở cuối cây (ví dụ [2,1,0]:)

Mảng số nguyên đầu vào có các đảm bảo sau:

• Giá trị là các số nguyên có chữ ký 32 bit lớn hơn 0.
• Giá trị là duy nhất.
• Các giá trị theo thứ tự tăng dần từ vị trí 0.
• Các giá trị có thể thưa thớt (nghĩa là không liền kề nhau).

Mã ngắn gọn nhất bằng số ký tự ascii chiến thắng, nhưng tôi cũng thích xem các giải pháp tao nhã cho bất kỳ ngôn ngữ cụ thể nào.

Các trường hợp thử nghiệm

Các kết quả cho mảng đơn giản chứa 1để ncho khác nhau n. Như mô tả ở trên, các dấu 0là tùy chọn.

[]
[1]
[2,1,0]
[2,1,3]
[3,2,4,1,0,0,0]
[4,2,5,1,3,0,0]
[4,2,6,1,3,5,0]
[4,2,6,1,3,5,7]
[5,3,7,2,4,6,8,1,0,0,0,0,0,0,0]
[6,4,8,2,5,7,9,1,3,0,0,0,0,0,0]
[7,4,9,2,6,8,10,1,3,5,0,0,0,0,0]
[8,4,10,2,6,9,11,1,3,5,7,0,0,0,0]
[8,4,11,2,6,10,12,1,3,5,7,9,0,0,0]
[8,4,12,2,6,10,13,1,3,5,7,9,11,0,0]
[8,4,12,2,6,10,14,1,3,5,7,9,11,13,0]
[8,4,12,2,6,10,14,1,3,5,7,9,11,13,15]

Hồng ngọc , 143

s=ARGV.size;r,q=[],[[0,s]];s.times{b,e=q.shift;k=Math::log2(e-b).to_i-1;m=(e-b+2)>(3<<k)?b+(2<<k)-1:e-(1<<k);r<<ARGV[m];q<<[b,m]<<[m+1,e]};p r

Đây là phiên bản nén (lỏng lẻo) của đoạn mã sau, về cơ bản thực hiện BFS trên cây.

def l(n)
    k = Math::log2(n).to_i-1
    if n+2 > (3<<k) then
        (2<<k)-1
    else
        n-(1<<k) 
    end
end

def bfs(tab)
  result = []
  queue = [[0,tab.size]]
  until queue.empty? do
    b,e = queue.shift
    m = b+l(e-b)
    result << tab[m]
    queue << [b,m] if b < m
    queue << [m+1,e] if m+1 < e
  end
  result
end

p bfs(ARGV)

Bên cạnh đó, vì là BFS, không phải DFS, nên yêu cầu về giải pháp không đệ quy là không đáng kể và nó đặt một số ngôn ngữ vào thế bất lợi.

Chỉnh sửa: Đã sửa giải pháp, cảm ơn @PeterTaylor vì bình luận của anh ấy!

Java , 252

Ok, đây là nỗ lực của tôi. Tôi đã chơi xung quanh với các hoạt động bit và tôi đã đưa ra cách tính toán trực tiếp chỉ số của một phần tử trong BST từ chỉ mục trong mảng ban đầu.

Phiên bản nén

public int[]b(int[]a){int i,n=1,t;long x,I,s=a.length,p=s;int[]r=new int[(int)s];while((p>>=1)>0)n++;p=2*s-(1l<<n)+1;for(i=0;i<s;i++){x=(i<p)?(i+1):(p+2*(i-p)+1);t=1;while((x&1<<(t-1))==0)t++;I=(1<<(n-t));I|=((I-1)<<t&x)>>t;r[(int)I-1]=a[i];}return r;}

Các phiên bản dài sau đây.

public static int[] makeBst(int[] array) {
  long size = array.length;
  int[] bst = new int[array.length];

  int nbits = 0;
  for (int i=0; i<32; i++) 
    if ((size & 1<<i)!=0) nbits=i+1;

  long padding = 2*size - (1l<<nbits) + 1;

  for (int i=0; i<size; i++) {
    long index2n = (i<padding)?(i+1):(padding + 2*(i-padding) + 1);

    int tail=1;
    while ((index2n & 1<<(tail-1))==0) tail++;
    long bstIndex = (1<<(nbits-tail));
    bstIndex = bstIndex | ((bstIndex-1)<<tail & index2n)>>tail;

    bst[(int)(bstIndex-1)] = array[i];
  }
 return bst;
}

def fn(input):
    import math
    n = len(input)
    if n == 0:
        return []
    h = int(math.floor(math.log(n, 2)))
    out = []
    last = (2**h) - 2**(h+1) + n

    def num_children(level, sibling, lr):
        if level == 0:
            return 0
        half = 2**(level-1)
        ll_base = sibling * 2**level + lr * (half)
        ll_children = max(0, min(last, ll_base + half - 1) - ll_base + 1)
        return 2**(level-1) - 1 + ll_children

    for level in range(h, -1, -1):
        for sibling in range(0, 2**(h-level)):
            if level == 0 and sibling > last:
                break
            if sibling == 0:
                last_sibling_val = num_children(level, sibling, 0)
            else:
                last_sibling_val += 2 + num_children(level, sibling - 1, 1) \
                    + num_children(level, sibling, 0)
            out.append(input[last_sibling_val])
    return out

Không hoàn toàn chắc chắn nếu điều này phù hợp chính xác với yêu cầu của bạn về các nút trống ở cuối cây và chắc chắn nó sẽ không giành được bất kỳ giải thưởng nào cho sự ngắn gọn, nhưng tôi nghĩ nó đúng và nó có các trường hợp thử nghiệm :)

public class BstArray {
    public static final int[] EMPTY = new int[] { };
    public static final int[] L1 = new int[] { 1 };
    public static final int[] L2 = new int[] { 1, 2 };
    public static final int[] L3 = new int[] { 1, 2, 3 };
    public static final int[] L4 = new int[] { 1, 2, 3, 5 };
    public static final int[] L5 = new int[] { 1, 2, 3, 5, 8 };
    public static final int[] L6 = new int[] { 1, 2, 3, 5, 8, 13 };
    public static final int[] L7 = new int[] { 1, 2, 3, 5, 8, 13, 21 };
    public static final int[] L8 = new int[] { 1, 2, 3, 5, 8, 13, 21, 35 };
    public static final int[] L9 = new int[] { 1, 2, 3, 5, 8, 13, 21, 35, 56 };
    public static final int[] L10 = new int[] { 1, 2, 3, 5, 8, 13, 21, 35, 56, 91 };

    public static void main(String[] args) {
        for (int[] list : Arrays.asList(EMPTY, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10)) {
            System.out.println(Arrays.toString(list) + " => " + Arrays.toString(bstListFromList(list)));
        }
    }

    private static int[] bstListFromList(int[] orig) {
        int[] bst = new int[nextHighestPowerOfTwo(orig.length + 1) - 1];

        if (orig.length == 0) {
            return bst;
        }

        LinkedList<int[]> queue = new LinkedList<int[]>();
        queue.push(orig);

        int counter = 0;
        while (!queue.isEmpty()) {
            int[] list = queue.pop();
            int len = list.length;

            if (len == 1) {
                bst[counter] = list[0];
            } else if (len == 2) {
                bst[counter] = list[1];
                queue.add(getSubArray(list, 0, 1));
                queue.add(new int[] { 0 });
            } else if (len == 3) {
                bst[counter] = list[1];
                queue.add(getSubArray(list, 0, 1));
                queue.add(getSubArray(list, 2, 1));
            } else {
                int divide = len / 2;
                bst[counter] = list[divide];
                queue.add(getSubArray(list, 0, divide));
                queue.add(getSubArray(list, divide + 1, len - (divide + 1)));
            }
            counter++;
        }

        return bst;
    }

    private static int nextHighestPowerOfTwo(int n) {
        n--;
        n |= n >> 1;
        n |= n >> 2;
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;
        n++;

        return n;
    }

    private static int[] getSubArray(int[] orig, int origStart, int length) {
        int[] list = new int[length];
        System.arraycopy(orig, origStart, list, 0, length);
        return list;
    }
}

Golf ( 99 89)

~]:b[]:^;{b}{{:|.,.2base,(2\?:&[-)&2/]{}$0=&(2/+:o[=]^\+:^;|o<.!{;}*|o)>.!{;}*}%:b}while^p

Về cơ bản là một cổng thẳng của giải pháp Python của tôi, hoạt động theo cách tương tự.

Có lẽ có thể được cải thiện một chút với nhiều "gôn" hơn, đã được cải thiện 10 ký tự với đầu vào của @ petertaylor :)

Java 192

Chỉ mục bản đồ trong đầu vào để lập chỉ mục trong đầu ra

int[]b(int[]o){int s=o.length,p=0,u=s,i=0,y,r[]=new int[s],c[]=new int[s];while((u>>=1)>0)p++;for(int x:o){y=p;u=i;while(u%2>0){y--;u/=2;}r[(1<<y)-1+c[y]++]=x;i+=i>2*s-(1<<p+1)?2:1;}return r;}

Phiên bản dài:

static int[] bfs(int[] o) {
  int rowCount = 32 - Integer.numberOfLeadingZeros(o.length); // log2
  int slotCount = (1<<rowCount) - 1; // pow(2,rowCount) - 1

  // number of empty slots at the end
  int emptySlots = slotCount - o.length;
  // where we start to be affected by these empty slots
  int startSkippingAbove = slotCount - 2 * emptySlots; // = 2 * o.length - slotCount

  int[] result = new int[o.length];
  int[] rowCounters = new int[rowCount]; // for each row, how many slots in that row are taken
  int i = 0; // index of where we would be if this was a complete tree (no trailing empty slots)
  for (int x : o) {
    // the row (depth) a slot is in is determined by the number of trailing 1s
    int rowIndex = rowCount - Integer.numberOfTrailingZeros(~i) - 1;
    int colIndex = rowCounters[rowIndex]++; // count where we are
    int rowStartIndex = (1 << rowIndex) - 1; // where this row starts in the result array

    result[rowStartIndex + colIndex] = x;

    i++;
    // next one has to jump into a slot that came available by not having slotCount values
    if (i > startSkippingAbove) i++;
  }

  return result;
}

Wolfram Mathicala 11, 175 Byte

g[l_]:=(x[a_]:=Floor@Min[i-#/2,#]&@(i=Length[a]+1;2^Ceiling@Log2[i]/2);Join@@Table[Cases[l//.{{}->{},b__List:>(n[Take[b,#-1],b[[#]],Drop[b,#]]&@x[b])},_Integer,{m}],{m,x[l]}])

Hàm g[l]lấy làm đầu vào a List(ví dụ l={1,2,3,4,...}) và trả về a Listcủa dạng mong muốn. Nó hoạt động như sau:

• x[a_]:=Floor@Min[i-#/2,#]&@(i=Length[a]+1;2^Ceiling@Log2[i]/2) lấy một danh sách và tìm ra gốc của BST liên quan.
  • i=Length[a]+1 phím tắt cho độ dài của danh sách
  • 2^Ceiling@Log2[i]/2 giới hạn trên của giá trị gốc
  • Min[i-#/2,#]&@(...)Tối thiểu của hai đối số trong đó #đại diện cho những gì bên trong(...)
• l//.{...} Áp dụng nhiều lần các quy tắc thay thế tuân theo l
• {}->{} Không có gì để làm (đây là trường hợp cạnh để tránh một vòng lặp vô hạn)
• b__List:>(n[Take[b,#-1],b[[#]],Drop[b,#]]&@x[b])Chia một Listthành{{lesser}, root, {greater}}
• Cases[...,_Integer,{m}] Lấy tất cả các số nguyên ở cấp độ (độ sâu) m
• Table[...,{m,1,x[l]}]Cho tất cả mlên đếnx[l] (mà thực sự nhiều hơn cần thiết).

Nó có thể được kiểm tra bằng cách chạy

Table[g[Range[a]], {a, 0, 15}]//MatrixForm

Việc thực hiện này không bao gồm các số 0 ở cuối.

Con trăn ( 175 171)

Khá cô đọng, vẫn khá dễ đọc;

def f(a):
 b=[a]
 while b:
  c,t=((s,2**(len(bin(len(s)))-3))for s in b if s),[]
  for x,y in c:
   o=min(len(x)-y+1,y/2)+(y-1)/2
   yield x[o]
   t+=[x[:o],x[o+1:]]
  b=t

Nó mang lại kết quả, vì vậy bạn có thể lặp qua nó hoặc (cho mục đích hiển thị) in nó dưới dạng danh sách;

>>> for i in range(1,17): print i-1,list(f(range(1,i)))
 0 []
 1 [1]
 2 [2, 1]
 3 [2, 1, 3]
 4 [3, 2, 4, 1]
 5 [4, 2, 5, 1, 3]
 6 [4, 2, 6, 1, 3, 5]
 7 [4, 2, 6, 1, 3, 5, 7]
 8 [5, 3, 7, 2, 4, 6, 8, 1]
 9 [6, 4, 8, 2, 5, 7, 9, 1, 3]
10 [7, 4, 9, 2, 6, 8, 10, 1, 3, 5]
11 [8, 4, 10, 2, 6, 9, 11, 1, 3, 5, 7]
12 [8, 4, 11, 2, 6, 10, 12, 1, 3, 5, 7, 9]
13 [8, 4, 12, 2, 6, 10, 13, 1, 3, 5, 7, 9, 11]
14 [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13]
15 [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15]

Java

Đây là một giải pháp tính toán trực tiếp. Tôi nghĩ rằng nó hoạt động, nhưng nó có một tác dụng phụ vô hại thực tế. Mảng nó tạo ra có thể bị hỏng nhưng không ảnh hưởng đến các tìm kiếm. Thay vì tạo các nút 0 (null), nó sẽ tạo ra các nút không thể truy cập, đó là các nút đã được tìm thấy trước đó trong cây trong quá trình tìm kiếm. Nó hoạt động bằng cách ánh xạ mảng chỉ số của một sức mạnh thông thường của mảng cây tìm kiếm nhị phân 2 kích thước lên một mảng cây tìm kiếm nhị phân có kích thước không đều. Ít nhất, tôi nghĩ rằng nó hoạt động.

import java.util.Arrays;

public class SortedArrayToBalanceBinarySearchTreeArray
{
    public static void main(String... args)
    {
        System.out.println(Arrays.toString(binarySearchTree(19)));
    }

    public static int[] binarySearchTree(int m)
    {
        int n = powerOf2Ceiling(m + 1);
        int[] array = new int[n - 1];

        for (int k = 1, index = 1; k < n; k *= 2)
        {
            for (int i = 0; i < k; ++i)
            {
                array[index - 1] = (int) (.5 + ((float) (m)) / (n - 1)
                        * (n / (2 * k) * (1 + 2 * index) - n));
                ++index;
            }
        }

        return array;
    }

    public static int powerOf2Ceiling(int n)
    {
        n--;
        n |= n >> 1;
        n |= n >> 2;
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;
        n++;

        return n;
    }

}

Đây là một phiên bản cô đọng hơn (chỉ có chức năng và tên được ghép nối). Nó vẫn có khoảng trắng, nhưng tôi không lo lắng về chiến thắng. Ngoài ra phiên bản này thực sự có một mảng. Một cái khác chỉ lấy một int cho chỉ số cao nhất trong mảng.

public static int[] b(int m[])
{
    int n = m.length;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    n++;

    int[] a = new int[n - 1];

    for (int k = 1, j = 1, i; k < n; k *= 2)
    {
        for (i = 0; i < k; ++i)
        {
            a[j - 1] = m[(int) (.5 + ((float) m.length) / (n - 1)
                    * (n / (2 * k) * (1 + 2 * j) - n)) - 1];
            ++j;
        }
    }

    return a;
}

GolfScript ( 79 77 70 ký tự)

Vì ví dụ trong câu hỏi sử dụng một hàm, tôi đã biến nó thành một hàm. Loại bỏ {}:f;để để lại một biểu thức lấy đầu vào trên ngăn xếp và để BST trên ngăn xếp sẽ tiết kiệm 5 ký tự.

{[.;][{{.!!{[.,.)[1]*{(\(@++}@(*1=/()\@~]}*}%.{0=}%\{1>~}%.}do][]*}:f;

Bản demo trực tuyến (lưu ý: ứng dụng có thể hơi nóng lên: ứng dụng đã hết thời gian hai lần đối với tôi trước khi chạy trong 3 giây).

Với khoảng trắng để hiển thị cấu trúc:

{
    # Input is an array: wrap it in an array for the working set
    [.;]
    [{
        # Stack: emitted-values working-set
        # where the working-set is essentially an array of subtrees
        # For each subtree in working-set...
        {
            # ...if it's not the empty array...
            .!!{
                # ...gather into an array...
                [
                    # Get the size of the subtree
                    .,
                    # OEIS A006165, offset by 1
                    .)[1]*{(\(@++}@(*1=
                    # Split into [left-subtree-plus-root right-subtree]
                    /
                    # Rearrange to root left-subtree right-subtree
                    # where left-subtree might be [] and right-subtree might not exist at all
                    ()\@~
                ]
            }*
        }%
        # Extract the leading element of each processed subtree: these will join the emitted-values
        .{0=}%
        # Create a new working-set of the 1, or 2 subtrees of each processed subtree
        \{1>~}%
        # Loop while the working-set is non-empty
        .
    }do]
    # Stack: [[emitted values at level 0][emitted values at level 1]...]
    # Flatten by joining with the empty array
    []*
}:f;

J , 52 byte

t=:/:(#/:@{.(+:,>:@+:@i.@>:@#)^:(<.@(2&^.)@>:@#`1:))

Hàm lấy một danh sách đã sắp xếp và trả về theo thứ tự cây nhị phân

Lưu ý rằng cây có hình dạng giống hệt nhau nhưng mức độ đáy được rút ngắn

• `1: bắt đầu với 1
• <.@(2&^.)@>:@# Lặp lại theo tầng của log2 (chiều dài + 1)
• +: , >:@+:@i.@>:@# loop: nối gấp đôi vectơ cuối cùng với các số lẻ 1,3 .. 2 * chiều dài + 1
• # /:@{. chỉ lấy số lượng vật phẩm cần thiết và nhận chỉ số sắp xếp của chúng
• /: áp dụng các chỉ số sắp xếp đó cho đầu vào đã cho

TIO

Python 2 , 107 byte

Câu trả lời của Golf of Joachim Isaksson , Input là một singleton chứa danh sách.

def f(a):
 for x in a:
	if x:w=len(x);y=1<<len(bin(w))-3;o=min(w-y+1,y/2)+~-y/2;yield x[o];a+=x[:o],x[o+1:]

Hãy thử trực tuyến!