C 使用宏进行抖动排序

向量的类型： 该计划可行，但：

我试着使用相同的函数对bubble up和bubble down进行抖动排序（bubble up在右边得到最大值，bubble down在左边得到最小值）。为此，我尝试使用以下未编译的宏：

气泡的符号为“+”，运算符为“>”

---

符号是“-”而oper是“，不太清楚为什么要在这里使用宏。你想避免重复代码吗？还是要使排序例程类型独立

无论如何，您的宏有几个错误：

• 您可能已经读过，应该用括号保护宏参数。这通常是一个很好的建议，因为宏是文本替换；例如，臭名昭著的

  SQ（x+1）

  将解析为

  x+1*x+1

  。就你而言，这个建议是错误的。您将得到语法错误的“运算符”，例如

  （

  ）和

  （

  或

  +

  ）应该让您警惕
• 对通用代码使用函数，而不是宏
• 接受C处理不同类型的方法。学习

  qsort

  的工作原理比摆弄宏来实现冒泡排序更有用（如果没有那么有趣的话）
• 如果您真的需要编写大量与类型无关的代码，您可能不应该使用C

---

错误是什么？开发宏代码是很长的代码。BTW你的思维方式在C++模板中有很好的视角。这里使用宏的要点是什么？你只想在执行上/下冒泡排序和抖动排序时替换冗余代码吗？如果代码< > <代码> >代码> StValue< /Calp> APPa，它是什么类型？rently不是独立于类型的？那么如何调用宏呢？这是我想要复制的函数，这样我可以在冒泡上升和冒泡下降时使用它。Get/Set值是整数-for（当前索引=*开始；当前索引>*结束；--当前索引）{VectorGet（pVector，当前索引和当前值）；向量Get（pVector，当前索引-1和下一个值）；if（当前值<下一个值）{VectorSet（pVector，当前索引，下一个值）；向量集（pVector，当前索引-1，当前值）；*{U为当前值=1；}感谢您的详细回答。关于您的第一条评论-是的，我希望避免重复代码，这就是我选择使用宏的原因。您是否有任何其他建议如何使用相同的函数将向量的最大值向右冒泡和最小值向左冒泡（对于抖动类向量）？您认为使用函数参数作为指向另一个函数的指针可以解决此问题吗？此外，插入var_t是为了将此函数用于其他向量-变量上的其他类型（不仅仅是整数）。在这种情况下，我也可以使用指向void的指针。

#define bubble_up_down(var_t, pVector, _Is_swp, start, end, sign, oper)\
{\
    var_t current_index;\
    var_t current_val;\
    var_t next_val;\              
    for (current_index = *(start) ; current_index (oper) *(end) ; (sign)(sign)current_index){\
    {\
        VectorGet((pVector), current_index, &current_val);\
        VectorGet((pVector), current_index(sign)1, &next_val);\
        if(current_val (oper) next_val)\
        {\
            VectorSet((pVector), current_index, next_val);\
            VectorSet((pVector), current_index(sign)1, current_val);\
            *(_Is_swp) = 1;\
        }\
    }\
}

int done = 0;

while (!done) {
    done = 1;

    for (int i = 1; i < n; i++) {
        if (a[i - 1] > a[i]) {
            swap(a, i - 1, i);
            done = 0;
        }
    }
}

while (!done) {
    done = 1;

    for (int i = n - 1; i > 0; i--) {
        if (a[i - 1] > a[i]) {
            swap(a, i - 1, i);
            done = 0;
        }
    }
}

for (unsigned int i = 0; i < n; i++) ...

for (unsigned int i = n; i-- > 0; ) ...

static int bubble_up(int a[], int n)
{
    int done = 1;

    for (int i = 1; i < n; i++) {
        if (a[i - 1] > a[i]) {
            swap(a, i - 1, i);
            done = 0;
        }
    }

    return done;
}

static int bubble_down(int a[], int n)
{
    int done = 1;

    for (int i = n; i-- > 1; ) {
        if (a[i - 1] > a[i]) {
            swap(a, i - 1, i);
            done = 0;
        }
    }

    return done;
}

void sort_bubble_up(int a[], int n)
{
    int done = 0;

    while (!done) {
        done = bubble_down(a, n);
    }
}

void sort_bubble_down(int a[], int n)
{
    int done = 0;

    while (!done) {
        done = bubble_down(a, n);
    }
}

void sort_shaker(int a[], int n)
{
    int done = 0;

    while (!done) {
        done = bubble_up(a, n) || bubble_down(a, n);
    }
}

void sort_bubble_up(int a[], int n)
{
    while (bubble_down(a, n)) { }
}

void sort_bubble_down(int a[], int n)
{
    while (bubble_down(a, n)) { }
}

void sort_shaker(int a[], int n)
{
    while (bubble_up(a, n) || bubble_down(a, n)) { }
}

#define BUBBLE_SORT(ARRAY, N, TYPE) do {         \
        int done = 0;                            \
        int i;                                   \
                                                 \
        while (!done) {                          \
            done = 1;                            \
                                                 \
            for (i = 1; i < N; i++) {            \
                if (ARRAY[i - 1] > ARRAY[i]) {   \
                    TYPE sawp = ARRAY[i];        \
                                                 \
                    ARRAY[i] = ARRAY[i - 1];     \
                    ARRAY[i - 1] = swap;         \
                    done = 0;                    \
                }                                \
            }                                    \
        }                                        \
    } while (0)

char c[] = "Mississippi";

BUBBLE_SORT(c, strlen(c), char);