Question

我有一个抽象基类（Comparable），其中Date和Time实际上是从它继承的，而DateTime类是从日期和时间继承的。[/ p>

我的问题是：我的任务是动态分配可比较数组。

Comparable ** compArray;
compArray = new Comparable *[n]; // where n is user specified number of elements

然后我按交替顺序用DateTimes填充数组。我需要使用quicksort和bubblesort组合对此数组进行排序。如果长度＆lt; 8.可比**和可比**是我允许使用的唯一参数。

但我完全陷入困境。在这一点上，由于它是疯狂的随意性而不值得粘贴在我的代码中。

非常感谢任何帮助。我花了几个小时试图完成这个，只在我的项目中留下了分类。这是明天上午晚些时候到期的。

提前致谢，乔尔

编辑：

  void Sort(Comparable** a);
  void quicksort(Comparable** from, Comparable** to);   
  Comparable** partition(Comparable** from, Comparable** to);
  void Swap(Comparable** from, Comparable** to);    
  void safeRead(istream& sin, Comparable* d, const char* prompt);
  void printArray(ostream & sout, Comparable **a, int size);

我被赋予以上内容以用作我的arraySort.h

我正在使用：int aSize = _msize(a) / sizeof(Comparable) - 1;作为我的长度变量...我必须计算而不是传递它，这有点烦人。

我主要只是因为解除引用**并且在快速排序中调用它的次数或等于方法而感到头疼。一旦我理解了如何使用它来快速点击''点击'，我将能够轻松地冒泡排序。

编辑：我目前有以下作为我的冒泡排序，它根本不对数组进行排序。

  void Swap(Comparable** from, Comparable** to)
  {
    Comparable** tmp;

    tmp = from;
    **from = **to;
    to = tmp;

  }

  void bubbleSort(Comparable** a, int size)
  {

    int i, j;

      for (i=0; i<size-1; i++)
      {
        for (j= size - 1; j > i; j--)
          if(a[j]->lessThan(*a[j-1]))
            Swap(&a[j], &a[j-1]);

      }
  }

Answer 1

你必须有交替的日期和时间，所以你不需要创建DateTime对象，对吗？

记住你正在排序一个inplace数组。 From和to类似于STL容器的begin（）和end（）部分。

void QuickSort(Comparable** from, Comparable** to)
{
    int n = to - from;
    if (n < 8) BubbleSort(from, to);
    else {
        // the trick in here is remembering you have to sort in pairs
    }
}

Comparable** array = new Comparable*[n];
for (int i = 0; i < n; i += 2) {
    array[i] = new Date();
    array[i+1] = new Time();
}

// sort it
QuickSort(array, array+n);

Answer 2

来自和Comparable**的
Comparable**是我唯一允许使用的参数。

这有点傻，因为有一个尺寸参数会是一个更好的API。

无论如何，一个解决方法（我不知道是否允许它）将做C对字符串所做的事情：即使数组一（1）个元素大于分配它时所需的元素，并将其最后一个元素设置为零（null）以标记数组的结尾（以便被调用者可以查找空指针以发现数组的结束位置。）

Answer 3

你应该重载运算符“＆lt;”对于您的类，以便您可以比较其中两个以便对它们进行排序。在那之后，这是一个实现bubblesort和quicksort的问题，非常简单（你会在谷歌找到大量的解释和示例代码）。也许我完全不明白你的问题是什么，所以如果这没有帮助请更明确：）

Answer 4

请记住以下一行：

Comparable ** compArray = new Comparable *[n];

...正在分配一个指针数组;它没有分配任何实际的对象。因此，在分配上述数组之后要做的下一件事是将compArray中的每个指针设置为指向有效对象。（无论你是通过为每个人调用new来设置它们，还是将指针设置为指向你在其他地方的现有对象，当然取决于你）

假设你已经这样做了，你可能要做的下一件事是编写一个IsLessThan（）函数，根据它们指向的内容比较两个指针：

bool IsLessThan(const Comparable * a, const Comparable * b) {return (*a) < (*b);}

请注意，上述内容与指针本身的比较非常不同！

之后的下一步是编写一个BubbleSort函数来对数组进行排序。它可能看起来像这样：

 void BubbleSort(Comparable ** ptrArray, int arrayLen)
 {
    [... bubble sort routine would go here ...]
 }

...它可以重复遍历数组中的指针，每当它找到一对错误顺序的相邻指针时（即IsLessThan（ptrArray [i]，ptrArray [i + 1]） == false），交换指针。一旦它通过数组的整个传递而不必交换任何指针，你知道你已经完成了，你可以允许函数返回。

一旦它正常工作（当然效率低下，但没关系），最后一步是编写QuickSort例程：

 void QuickSort(Comparable ** ptrArray, int arrayLen)
 {
    if (arrayLen < 8) BubbleSort(ptrArray, arrayLen);
    else
    {
        [... quick sort routine would go here ...]
    }
 }

我不太清楚QuickSort在这里解决它，但希望上面的内容至少可以帮助你完成任务。

C ++抽象ptrs到ptrs的基类数组

4 个答案: