如何实现等位数大数字减法？已有不等长减法实现基础

Got it, let's tackle the equal-length large number subtraction problem you're facing. You already have the logic for handling numbers with different lengths (swapping them so you subtract the smaller from the larger), so we just need to extend that with a few key steps for equal-length cases. Here's a step-by-step solution with code examples tailored to your workflow:

First, let's recap what we need to cover for equal-length inputs:

1. Compare the two numbers to figure out which is larger (since we always subtract the smaller from the larger to avoid negative intermediate results)
2. Perform the subtraction with proper borrow handling (just like how you do it manually on paper)
3. Clean up leading zeros from the result
4. Add a negative sign if the original first number was smaller than the second

Step 1: Compare Equal-Length Numeric Strings #

Since we're working with string inputs, we can compare digits left to right (most significant to least) to determine which number is bigger. This avoids converting the entire string to a numeric type (which is impossible for 50-digit numbers anyway).

// Returns 1 if num1 > num2, -1 if num1 < num2, 0 if equal
int compareEqualLength(const char *num1, const char *num2, int len) {
    for (int i = 0; i < len; i++) {
        if (num1[i] > num2[i]) return 1;
        if (num1[i] < num2[i]) return -1;
    }
    return 0; // All digits match
}

Step 2: Subtract with Borrow Handling #

Once we know which number is larger, we convert both to integer arrays (like you're already doing) and subtract digit by digit from right to left, managing borrow when a digit in the larger number is smaller than the corresponding digit in the smaller one.

// Subtracts smaller from larger (both equal-length integer arrays)
void subtractEqualLength(const int *larger, const int *smaller, int len, int *result) {
    int borrow = 0;
    for (int i = len - 1; i >= 0; i--) {
        int diff = larger[i] - smaller[i] - borrow;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        result[i] = diff;
    }
}

Step 3: Clean Up Leading Zeros #

After subtraction, the result array might have leading zeros (e.g., 1000 - 999 gives [0,0,0,1]). We need to strip these to get a valid numeric string.

// Converts result array to a clean string, handling negative signs
char* resultToString(int *result, int len, int isNegative) {
    int start = 0;
    // Skip all leading zeros
    while (start < len && result[start] == 0) {
        start++;
    }
    // Edge case: all zeros (e.g., 500 - 500)
    if (start == len) {
        char *zero = malloc(2 * sizeof(char));
        strcpy(zero, "0");
        return zero;
    }
    // Build the result string
    int resultLen = len - start + (isNegative ? 1 : 0);
    char *resStr = malloc((resultLen + 1) * sizeof(char));
    int idx = 0;
    
    // Add negative sign if needed
    if (isNegative) {
        resStr[idx++] = '-';
    }
    // Copy non-zero digits
    for (int i = start; i < len; i++) {
        resStr[idx++] = result[i] + '0';
    }
    resStr[idx] = '\0';
    return resStr;
}

Step 4: Integrate with Your Existing Logic #

Now we'll wrap all these functions into a single large subtraction function that handles both equal and unequal lengths, using your existing swap logic for unequal cases.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// Include the helper functions above here

char* largeSubtract(const char *num1, const char *num2) {
    int len1 = strlen(num1);
    int len2 = strlen(num2);
    int isSwapped = 0;
    int isNegative = 0;

    // Your existing swap logic for unequal lengths
    if (len1 < len2) {
        const char *temp = num1;
        num1 = num2;
        num2 = temp;
        int tempLen = len1;
        len1 = len2;
        len2 = tempLen;
        isSwapped = 1;
    }

    // Convert strings to integer arrays (pad shorter array with zeros)
    int *arr1 = malloc(len1 * sizeof(int));
    int *arr2 = malloc(len1 * sizeof(int));
    int *result = malloc(len1 * sizeof(int));

    for (int i = 0; i < len1; i++) {
        arr1[i] = num1[i] - '0';
        arr2[i] = (i < len2) ? (num2[i] - '0') : 0;
    }

    // Handle equal-length case
    if (len1 == len2) {
        int cmpResult = compareEqualLength(num1, num2, len1);
        if (cmpResult == 0) {
            // Numbers are identical, result is 0
            free(arr1);
            free(arr2);
            free(result);
            return strdup("0");
        } else if (cmpResult == -1) {
            // num2 is larger, swap arrays and mark result as negative
            int *tempArr = arr1;
            arr1 = arr2;
            arr2 = tempArr;
            isNegative = 1;
        }
        subtractEqualLength(arr1, arr2, len1, result);
    } else {
        // Your existing unequal-length subtraction logic (with borrow)
        int borrow = 0;
        for (int i = len1 - 1; i >= 0; i--) {
            int diff = arr1[i] - arr2[i] - borrow;
            if (diff < 0) {
                diff += 10;
                borrow = 1;
            } else {
                borrow = 0;
            }
            result[i] = diff;
        }
        // If we swapped earlier, result is negative
        isNegative = isSwapped;
    }

    // Convert result array to clean string
    char *resStr = resultToString(result, len1, isNegative);

    // Clean up memory
    free(arr1);
    free(arr2);
    free(result);

    return resStr;
}

// Example usage
int main() {
    // Test 50-digit equal-length subtraction (num1 < num2)
    char num1[] = "12345678901234567890123456789012345678901234567890";
    char num2[] = "98765432109876543210987654321098765432109876543210";
    char *result = largeSubtract(num1, num2);
    printf("Result 1: %s\n", result);
    free(result);

    // Test equal-length subtraction (num1 > num2)
    char num3[] = "55555555555555555555555555555555555555555555555555";
    char num4[] = "11111111111111111111111111111111111111111111111111";
    result = largeSubtract(num3, num4);
    printf("Result 2: %s\n", result);
    free(result);

    return 0;
}

Key Notes for Your Implementation #

• This code avoids any atoi-style functions and works for 50-digit numbers (or longer, as long as you have enough memory).
• Memory management is handled with malloc and free to prevent leaks—make sure to free the returned string after use.
• The logic aligns with your existing workflow: string to integer array conversion, swap for unequal lengths, and now full support for equal-length cases.

内容的提问来源于stack exchange，提问作者user5444454333