Question

老实说，这是个问题。

完整的问题：

在O（n）时间复杂度中使用C ++ / Java在一维数组中实现重复删除算法，没有额外空间。例如，如果输入数组是{3,5,5,3,7,8,5,8,9,9}，则输出应为{3,5,7,8,9}。

我已经考虑了很长一段时间，但还没有解决它。

我的想法：

如果数组已排序，我可以删除O（n）中的重复项。但我知道最快的排序算法有O（n * log（n））复杂度。
在O（n）中排序的一种算法是bin或bucket排序。这里的问题是如果不使用额外的空间就无法实现。
我想知道是否有可能。

我研究了一下，没有发现任何新的东西。

感谢您的帮助。

P.S。：如果不是明天的考试，我会给它更多的时间。

Answer 1

这确实可行，只需使用in-place radix sort。

它适用于O(kn)，其中k对于任何标准数字数据类型都是常量，并且需要O(1)额外空间。

这是代码：

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

/// in-place 32-bit recursive radix sort
void I32R(int32_t *data, uint32_t size, uint32_t nbit) {
    uint32_t dbgn = (uint32_t)-1, dend = size;

    while (++dbgn < dend)
        if (data[dbgn] & nbit)
            while (dbgn < --dend)
                if (~data[dend] & nbit) {
                    data[dbgn] ^= data[dend];
                    data[dend] ^= data[dbgn];
                    data[dbgn] ^= data[dend];
                    break;
                }
    if ((nbit >>= 1) && (dend > 1))
        I32R(data, dend, nbit);
    if (nbit && (size - dend > 1))
        I32R(data + dend, size - dend, nbit);
}

/// O_t(n) / O_s(1) duplicate remover
int32_t dups(int32_t *data, uint32_t size) {
    int32_t iter, *uniq = data;

    if (size < 2)
        return size;
    for (iter = 0; iter < size; iter++)
        data[iter] ^= (1 << 31);
    I32R(data, size, 1 << 31);
    data[0] ^= (1 << 31);
    for (iter = 1; iter < size; iter++)
        if (*uniq != (data[iter] ^= (1 << 31)))
            *++uniq = data[iter];
    return uniq - data + 1;
}

void parr(int32_t *data, uint32_t size) {
    for (; size; size--)
        printf("%4d%s", *data++, (size == 1)? "\n\n" : ", ");
}

int main() {
    int32_t iter, size, *data;

    data = malloc((size = 256) * sizeof(*data));
    for (iter = 0; iter < size; iter++)
        data[iter] = (int8_t)rand() & -3;
    parr(data, size);
    parr(data, dups(data, size));
    free(data);
    return 0;
}

N.B.＃1：在排序之前将符号位反转，正数必须大于负数，因为基数排序仅对无符号值起作用。

N.B.＃2：这只是一个粗略的例证，从未真正经过测试。

N.B.＃3：哦哇，这实际上比qsort()快！

N.B.＃4：现在有一个排序函数的非递归版本;除了缺少nbit：

之外，其用法基本相同

void I32NR(int32_t *data, uint32_t size) {
    int32_t mask, head;
    struct {
        uint32_t init, size, nbit, edge;
    } heap[32];

    heap[0].nbit = 32;
    heap[0].size = size;
    heap[0].init = head = 0;
    do {
        size = heap[head].init - 1;
        mask = 1 << ((heap[head].nbit & 0x7F) - 1);
        heap[head].edge = heap[head].size;
        while (++size < heap[head].edge)
            if (data[size] & mask)
                while (size < --heap[head].edge)
                    if (~data[heap[head].edge] & mask) {
                        data[size] ^= data[heap[head].edge];
                        data[heap[head].edge] ^= data[size];
                        data[size] ^= data[heap[head].edge];
                        break;
                    }
        heap[head].nbit = ((heap[head].nbit & 0x7F) - 1)
                        |  (heap[head].nbit & 0x80);
        if ((heap[head].nbit & 0x7F) && (heap[head].edge > 1)) {
            heap[head + 1] = heap[head];
            heap[head + 1].size = heap[head].edge;
            heap[++head].nbit |= 0x80;
            continue;
        }
        do {
            if ((heap[head].nbit & 0x7F)
            &&  (heap[head].size - heap[head].edge > 1)) {
                heap[head + 1] = heap[head];
                heap[head + 1].init = heap[head].edge;
                heap[++head].nbit &= 0x7F;
                break;
            }
            while ((head >= 0) && !(heap[head--].nbit & 0x80));
        } while (head >= 0);
    } while (head >= 0);
}

Answer 2

假设ar[i]=j，检查ar[j]是否为否定，如果否定则删除ar[i]否则将ar[j]替换为-ar[j]。

注意：仅当所有元素都是正数且元素位于0<=elements<array_size内时才会起作用。

    for(int i = 0; i < ar.length; i++) {
       int elem1 = ar[i];
       int elem2 = ar[Math.abs(elem1)];
       if(elem2 >= 0) {
           ar[Math.abs(elem1)] = -elem2;
       }
       else {
           //elem1 already exists in an array. remove elem1 or copy distinct elements to another array
       }
    }

重复删除

2 个答案: