C 比较排序数组-nlogn

我有2个整数数组，我需要打印O（nlogn）中所有相同的整数 数组未排序，排序后可以：

X [ 1,2,3,4,5,6,7,8,9]
Y [1,2,8,9]

因此，只检查4个位置（较小数组的大小）不是一个选项

我需要使用什么样的循环\方程才能使其成为nlogn ? 如果我将运行for直到较小数组的最后一个值，它仍然是nlogn吗-

---

如何只获取\reach数组中的最后一个整数而不运行到它的末尾？

您可以获取较小的数组并使用二进制搜索在较大的元素中搜索每个元素

for(int i = 0; i < size1; i++) {     
  binarysearch(arr_small[i], arr_big);
}

for（inti=0；i

二进制搜索每次搜索都需要O（logn）时间。所有元素的总搜索时间为O（nlogn）

---

如果您不记得二进制搜索，请参阅链接：）

此方法不需要排序

X

和

Y

将

X

的元素添加到二元搜索树中（避免重复条目，即如果

X[0]=1

和

X[1]=1

，则不要添加

X[1]

；忽略它即可）

然后尝试将

Y

的内容添加到同一个二元搜索树中，如果您发现元素已经在其中，那么它是相同的

总的时间复杂度归结为向BST添加元素的时间复杂度，即

O（n log n）

，但如果树是倾斜的（即如果数组被排序），最坏的情况是

O（n）

---

下面是代码供您参考

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

typedef struct node {
        int data;
        struct node *left;
        struct node *right;
} NODE;

NODE *root = NULL;

NODE * newnode (int data)
{
        NODE * n = NULL;
        if (n = (NODE *) malloc (sizeof (NODE))) {
                n->data = data;
                n->right = n->left = NULL;
        } else {
                printf("%d - %d - unalbe to create new node \n", __LINE__, data);
        }

        return n;
}

NODE * getnode(NODE * n, int data)
{
        if (n == NULL)
                return NULL;

        if (n->data == data)
                return n;

        if (data < n->data)     {
                return getnode (n->left, data);
        }

        if (data > n->data) {
                return getnode (n->right, data);
        }

        return NULL;
}

NODE * insert (NODE * node, int data, int *dup)
{
    NODE * n = NULL;

    if (node != NULL) {
        if (getnode(node, data) != NULL) {
            /* element already present in the tree..
               so set the dup and return the root */
            *dup = 1;
            return node;
        }
    }

    if (node == NULL) {
        n = newnode(data);
        return (n);
    }

    if (data <= node->data)
        node->left = insert(node->left, data, dup);
    else
        node->right = insert(node->right, data, dup);

    return node;
}

NODE * deletetree(NODE * from)
{
    if (from != NULL) {
        deletetree(from->left);
        deletetree(from->right);
        //printf("deleting %d \n", from->data);
        free(from);
    }
    return NULL;
}

int main()
{
    int sum = 35;
    int X[] = {1,2,3,4,5,6,7,8,9,1,2,3,4,5};
    int Y[] = {1,2,8,9};
    int i, dup = 0;

    int xlen = sizeof(X)/sizeof(X[0]);
    int ylen = sizeof(Y)/sizeof(Y[0]);

    printf("len of X is : %d \n", xlen);
    printf("len of Y is : %d \n", ylen);

    NODE * root1 = NULL;

    for (i=0; i<xlen; i++) {
        root = insert(root, X[i], &dup);
    }

    for (i=0; i<ylen; i++) {
        dup = 0;
        root = insert(root, Y[i], &dup);
        if (dup == 1) {
            printf("%d ", Y[i]);
        }
    }

    printf("\n");
    root = deletetree(root);

    return 0;
}

#包括
#包括
#包括
#包括
类型定义结构节点{
int数据；
结构节点*左；
结构节点*右；
}节点；
NODE*root=NULL；
NODE*newnode（int数据）
{
NODE*n=NULL；
如果（n=（节点*）malloc（sizeof（节点）））{
n->data=数据；
n->right=n->left=NULL；
}否则{
printf（“%d-%d-无法创建新节点”\n“，\uuuuu行\uuuuuuu，数据）；
}
返回n；
}
NODE*getnode（NODE*n，int数据）
{
如果（n==NULL）
返回NULL；
如果（n->data==数据）
返回n；
如果（数据数据）{
返回getnode（n->左，数据）；
}
如果（数据>n->数据）{
返回getnode（n->右，数据）；
}
返回NULL；
}
节点*插入（节点*节点，int数据，int*dup）
{
NODE*n=NULL；
如果（节点！=NULL）{
if（getnode（节点，数据）！=NULL）{
/*元素已存在于树中。。
因此，设置dup并返回根*/
*dup=1；
返回节点；
}
}
if（node==NULL）{
n=新节点（数据）；
返回（n）；
}
if（数据）
节点->左=插入（节点->左，数据，dup）；
其他的
节点->右侧=插入（节点->右侧，数据，dup）；
返回节点；
}
节点*删除树（节点*来自）
{
if（from！=NULL）{
删除树（从->左）；
删除树（从->右侧）；
//printf（“从->数据中删除%d\n”）；
自由的；
}
返回NULL；
}
int main（）
{
整数和=35；
int X[]={1,2,3,4,5,6,7,8,9,1,2,3,4,5}；
int Y[]={1,2,8,9}；
int i，dup=0；
int xlen=sizeof（X）/sizeof（X[0]）；
int-ylen=sizeof（Y）/sizeof（Y[0]）；
printf（“X的长度为：%d\n”，xlen）；
printf（“Y的长度为：%d\n”，ylen）；
NODE*root1=NULL；
对于（i=0；i在散列中抛出一个数组。在散列中查找另一个数组。但这不是nlogn..它是m+n。
我希望这是足够的提示

数组排序后，只需“并排”遍历数组。跟踪每个数组的“当前”元素（
X
和
Y
）。您可以为每个数组使用索引变量或使用指针来执行此操作。我个人认为使用指针更容易，但您或您的朋友可能有不同的偏好

对于每一对“当前”元素，如果元素匹配，然后打印值。然后考虑需要做什么（如果有的话），移动到每一个数组的下一个元素（对于元素不匹配的情况以及它们匹配的情况）。只有三种情况：
x[cur\u x]==y[cur\u y]
x[cur\u x]

y[cur\u y]

因此，确定在每种情况下应该做什么应该不会太困难

在O（n logn）操作中对数组进行排序。遍历数组是一个O（n）操作，因此总体上是一个O（n）+O（n logn）操作，这将减少到O（n logn）。换句话说，操作的总体时间复杂度由排序操作决定

使用二进制搜索也会起作用，但可能会稍微复杂一点——特别是在需要的情况下正确处理数组中的重复元素（取决于根据需要“正确”可能意味着什么）.
我正在帮助一位朋友…我不记得这件事了。输入有任何限制吗？我的意思是数组只包含小的整数值吗？如果是这样的话，你可以查看。还有一个问题，你可以检查。那仍然是nlogn吗？在使用合并排序对2个数组进行排序后，有没有任何方法可以用我的方式完成它？我知道s O（nlogn）。事实上，这种方法利用了排序数组，因为二进制搜索不能在未排序的数组中完成。为什么要在函数中添加（arr_small[i]，arr_big）？二进制搜索需要bin_搜索（int key，int*a，int n）？要使用这种方法，第一步必须是“对其中一个数组进行排序”Q表示数组最初是未排序的。合并排序+二进制搜索+比较-这仍然是NLOGN吗？所以基本上你说-不要只使用二进制搜索进行排序？但是二进制搜索只能处理一个已排序的数组？在二叉树中添加n个元素是O（NLOGN）。尽管创建二叉树时不需要排序，b