無輸出 - 程序不提供任何輸出

Question

我正在學習數據結構。 我嘗試編寫一個函數 rotate(arr[], d, n) 將大小為 n 的 arr[] 旋轉 d 個元素。

旋轉是指移動數組中的元素。

該程序沒有給出任何錯誤，而是掛起一點但不運行。

這是代碼： -

#include <stdio.h>

int rotate(int arr[], int d, int n, int dir)
{
    int temp, i;

    while (d)
    {
        if (dir)
        {

            // for left shift
            // First element will always get replaced in a rotation.
            temp = arr[0];
            for (i = 0; i < n - 1; i++)

                // for left shifting the second element next to its original position.
                arr[i] = arr[i + 1];

            // Putting the temp value in the last position.
            arr[n - 1] = temp;
        }

        else
        {
            // for right shift
            // Last element will always get replaced in a rotation.
            temp = arr[n - 1];
            for (i = n - 1; i > 0; i--)

                // for right shifting the second last element to the last position.
                arr[i] = arr[i - 1];
            // Putting the temp value in the first position
            arr[0] = temp;
        }
        d--;
    }

    // Print the shifted array
    for (i = 0; i < n; i++)
    {
        printf("%d, ", arr[i]);
    }
}

該程序僅在我不接受用戶輸入時運行。

int main()
{
    int n;
    int arr[n];
    int dir;
    int d;

    printf("Enter the size of the array: \n");
    scanf("%d", &n);

    printf("Enter the elements of the array: \n");
    for (int i = 1; i <= n; i++)
    {
        printf("Enter element %d", i);
        scanf("%d", &arr[i]);
    }

    printf("Enter the position: \n");
    scanf("%d", &d);

    printf("Enter the direction: \n");
    // 0: Right Direction and 1: Left Direction
    scanf("%d", &dir);


    // Before shifting the array
    for (int i = 1; i <= n; i++)
    {
        printf("%d, ", arr[i]);
    }

    // After shifting the array
    rotate(arr, d, n, dir);


    return 0;
}

Answer 1

你可能想在scanf("%d", &n);之后做int arr[n] scanf("%d", &n); 因為當您執行int arr[n]時n未初始化。 此外，C 中的數組索引從 0 開始，因此for (int i = 1; i <= n; i++)將是for (int i = 0; i < n; i++) 。

Answer 2

這不是一個正確的答案，所以不要把它當作正確的答案。 這只是出於教育目的的一種可能實現。

這是一種旋轉數組的方法，以便每個元素只移動一次（除了“組”的第一個元素通過臨時變量移動）。

旋轉量指定為整數，正值向右旋轉，負值向左旋轉。 它將這個數量轉換為0到n-1范圍內的一個數字，這是將被復制到元素 0 的元素的索引。然后它將數組分成一個或多個相同大小的交錯組，這樣連續的元素在每個組以循環方式按旋轉量分隔，並旋轉每個組內的元素。 （組數是n和旋轉量的最大公約數，每組的元素數是元素總數除以組數。）

#include <limits.h>
#include <stddef.h>

static size_t rotate_modulus(int d, size_t n);
static size_t gcd_size(size_t a, size_t b);

/* Rotate arr[] of length n right by d, or left by -d. */
void rotate(int arr[], int d, size_t n)
{
    size_t md = rotate_modulus(d, n);   /* Get offset in range 0 to n-1. */
    if (md)
    {
        /* Rotation needed. */
        /* Divide into interleaved groups and rotate each group. */
        size_t num_groups = gcd_size(n, md);
        size_t group_size = n / num_groups;
        size_t group;
        for (group = 0; group < num_groups; group++)
        {
            size_t a = group;   /* Index of first element in group. */
            size_t i;
            /* Rotate elements in group. */
            int temp = arr[a];  /* Get first element. */
            for (i = 0; i < group_size - 1; i++)
            {
                /* Get index of next element in group. */
                size_t b = (a + md);
                if (a >= n - md)
                {
                    b -= n;         /* Index wraps around. */
                }
                arr[a] = arr[b];    /* Move an element. */
                a = b;              /* Advance to next index. */
            }
            arr[a] = temp;          /* Move first element to last element. */
        }
    }
}

/*
 * Get modulus for rotation of n elements.
 *
 * d is the amount to rotate right; negative d rotates left by -d.
 *
 * For zero n, the return value is 0.
 *
 * For non-zero n, the return value is n - s, where s is d plus an
 * integer multiple of n such that s is in the range 1 to n, and the
 * return value is in the range 0 to n - 1.
 */
static size_t rotate_modulus(int d, size_t n)
{
    size_t md;
    if (n < 2)
    {
        /* No rotation needed if n < 2. */
        md = 0;
    }
    else if (d >= 0)
    {
        /* Non-negative d will rotate right. */
        md = d % n;
        if (md)
        {
            md = n - md;
        }
    }
    else
    {
        /* Negative d will rotate left. */
        /* -d would overflow if d == INT_MIN && INT_MIN == -INT_MAX - 1. */
        int fix_overflow = (d < -INT_MAX);
        md = -(d + fix_overflow) % n;
        if (fix_overflow)
        {
            if (++md == n)
            {
                md = 0;
            }
        }
    }
    return md;
}

/*
 * If both a and b are non-zero, return the greatest common divisor of a and b.
 * Otherwise, return 0.
 */
static size_t gcd_size(size_t a, size_t b)
{
    if (b == 0)
    {
        a = 0;
    }
    else
    {
        do
        {
            size_t t = b;
            b = a % b;
            a = t;
        }
        while (b);
    }
    return a;
}