Question

我正在尝试将3个数组按目标c中的一个键数组排序为iphone，这是一个帮助的例子......

Array 1      Array 2      Array 3     Array 4
1            15           21          7
3            12           8           9
6            7            8           0 
2            3            4           8

排序时，我希望它看起来像

Array 1      Array 2      Array 3     Array 4
1            15           21          7
2            3            4           8
3            12           8           9
6            7            8           0

因此数组2,3,4在排序时与数组1一起移动。

目前我正在使用冒泡排序来执行此操作，但它非常糟糕，以至于它会被应用程序崩溃。我用来做这个的代码是

int flag = 0;
int i = 0;
int temp = 0;
do 
{
    flag=1;
    for(i = 0; i < distancenumber; i++)
    {
        if(distance[i] > distance[i+1])
        {
            temp = distance[i];
            distance[i]=distance[i + 1];
            distance[i + 1]=temp;

            temp = FlowerarrayNumber[i];
            FlowerarrayNumber[i] = FlowerarrayNumber[i+1];
            FlowerarrayNumber[i + 1] = temp;

            temp = BeearrayNumber[i];
            BeearrayNumber[i] = BeearrayNumber[i + 1];
            BeearrayNumber[i + 1] = temp;
            flag=0;
        }
    }

}while (flag==0);

其中distance number是所有数组中元素的数量，distance是数组1或我的键数组。

，另外2个正在排序。

如果有人可以帮助我获得合并排序（或更快的东西，它在iPhone上运行所以它需要快速和轻量级）这样做，这将是伟大的我无法弄清楚递归在这种方法中是如何工作的因此很难让代码工作。任何帮助将不胜感激

Answer 1

难道你不能简单地构造你的数组以获得一个数组，每个项目都包含一个数组吗？

然后简单地根据它所拥有的数组的第一项对数组进行排序，或者使用一个包含项目和数组的简单结构。

Answer 2

我只是在这里大声思考，但是如果你的所有数组都相互对应（即BeearrayNumber[x]对应FlowerarrayNumber[x]，对应distance[x]），那么您可以考虑使用结构数组而不是独立数组。例如：

typedef struct
{
    int flowerNumber;
    int beeNumber;
    float distance;
} BeeFlowerData;

#define MAX_BEE_FLOWER_DATA (100)

BeeFlowerData allBeeFlowers[MAX_BEE_FLOWER_DATA];

然后，您可以使用POSIX qsort进行排序：

int BeeFlowerComparator(const void *l, const void *r)
{
    const BeeFlowerData *left = l;
    const BeeFlowerData *right = r;

    if (left->distance > right->distance)
        return 1;
    else if (left->distance < right->distance)
        return -1;
    else 
        return 0;
}


// somewhere in your class:
- (void) sort
{
    qsort (allBeeFlowers, MAX_BEE_FLOWER_DATA, sizeof(BeeFlowerData), BeeFlowerComparator);
}

Answer 3

我无法相信没有人建议将它们包裹在一个物体中。这是相当微不足道的：

//MyObject.h
@interface MyObject : NSObject {
  int a;
  int b;
  int c;
  int d;
}
@property int a;
@property int b;
@property int c;
@property int d;
@end

//MyObject.m
@implementation MyObject
@synthesize a, b, c, d;
@end

//Elsewhere:

MyObject * m = [[MyObject alloc] init];
[m setA:1];
[m setB:15];
[m setC:21];
[m setD:7];

[myMutableArray addObject:m];
[m release];
//... do that for the rest of the sets of numbers

NSSortDescriptor * sortByA = [NSSortDescriptor sortDescriptorWithKey:@"a" ascending:YES];
[myMutableArray sortUsingDescriptors:[NSArray arrayWithObject:sortByA]];

执行此操作时，您将拥有一个数组，但该数组中的对象将按其“a”值按升序排序。

Answer 4

这不是客观的具体问题。这是一个算法问题。

首先排序第一个数组。
遍历第一个数组并找到每个数字的索引。
然后在步骤2中检索与索引对应的第二个数组中的值。
构造一个新数组，用于保存步骤3中的结果。
也为其他阵列重复步骤2,3,4。

需要按一个键阵列对3个数组进行排序

4 个答案: