1

我有一个已经用整数填充的二维数组，准备切割成行并进行处理，并且我需要将每一行（一维数组）传递给链表的一个节点。每个节点如下所示：

struct node {
    int *val;
    struct node *next;
};

以这种方式添加和链接新节点：

struct node *addnode(int *val, struct node *next, int columns)
{
    struct node *tnode;
    tnode = (struct node*)malloc(sizeof(*tnode));
    if(tnode != NULL) {
        tnode->val = malloc(sizeof(int) * columns);
        memcpy(tnode->val, val, sizeof(int) * columns);
        tnode->val = val;
        tnode->next = next;
    };
    return tnode;
}

将填充每个节点的程序片段大致如下所示：

int table[rows][columns], i, j;
for (i = 0; i < rows; i++){
    head = addnode(*table, head, columns);
    for (j = 0; j < columns; j++){
        scanf("%d",&table[i][j]);
        head->val[j] = table[j];
        printf("%d ",head->val[j]);
    };
    puts("\n");
};

我不确定如何在指定的地方进行：

  1. 这是整个节点的 malloc ，但是我应该用 malloc 做val什么呢？我知道应该在每个节点中的表的长度，并且它是columns在 main 函数中获取的。我应该在哪里为它分配内存？
  2. 这条线上方是我足够 malloc 的地方（columns为单行整数分配足够 () 内存的地方。这是一个不错的选择吗？
  3. 这与前面的循环应该head->val[j]用足够的 i-row of 2D array填充当前table，但它看起来好得令人难以置信。我可以就这样离开吗？

编辑：我在某些地方更正了它，但是在尝试对其进行排序后，它返回垃圾。我将在这里转储大部分代码：

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

struct node {
    int *val;
    struct node *next;
};

struct node *addnode(int *val, struct node *next, int columns);
struct node *mergesort(struct node *head, int column);
struct node *merge(struct node *head_one, struct node *head_two, int column);

int main(int argc, char *argv[])
{

    struct node *head;
    struct node *current;
    struct node *next;
    int symbol = 0;
    int columns = 0;
    //int columns = atoi(argv[1]); //until sorting works, I'll keep it at 0
    int rows = 0;
    head = NULL;
    int column = 0; //temporary until I find the way to send one argument during executing it under linux like so 'name_of_program columns < test.txt'
    int lastSpace = 0;

    do {
        symbol = fgetc(stdin);

        if (rows == 0 && (lastSpace == 0 && (isspace(symbol) || feof(stdin)))) {
            columns++;
            lastSpace = 1;
        } else if (!isspace(symbol)) {
            lastSpace = 0;
        }
        if (symbol == '\n' || feof(stdin)) {
            rows++;
        };      
    } while (symbol != EOF);

    if (ferror(stdin))
    {
        printf("Error on reading from file.\n");
    } else {
        printf("The file contains %d row(s) and %d column(s).\n", rows, columns);
    };

    rewind(stdin); //I have heard conflicting opinions on that, but in this case it works, and in the end it's a school project, not commercial code

    int table[rows][columns], i, j;
    for (i = 0; i < rows; i++){
        head = addnode(*table, head, columns);
        for (j = 0; j < columns; j++){
            scanf("%d",&table[i][j]);
            head->val[j] = table[i][j];
            printf("%d ",head->val[j]);
        };
        puts("\n");
    };  


    head = mergesort(head, column);

    for(current = head; current != NULL; current = current->next){
        for (j = 0; j < columns; j++){
            printf("%d ", current->val[j]);
        };
        puts("\n");
    };

    for(current = head; current != NULL; current = next)
      next = current->next, free(current);
    return 0;
};


struct node *addnode(int *val, struct node *next, int columns)
{
    struct node *tnode;
    tnode = (struct node*)malloc(sizeof(*tnode));
    if(tnode != NULL) {
        tnode->val = malloc(sizeof(int) * columns);
        memcpy(tnode->val, val, sizeof(int) * columns);
        tnode->val = val;
        tnode->next = next;
    };
    return tnode;
}

struct node *mergesort(struct node *head, int column)
{
    struct node *head_one;
    struct node *head_two;
    if((head == NULL) || (head->next == NULL))
        return head;
    head_one = head;
    head_two = head->next;
    while((head_two != NULL) && (head_two->next != NULL)) {
        head = head->next;
        head_two = head->next->next;
    };
    head_two = head->next;
    head->next = NULL;
    return merge(mergesort(head_one, column), mergesort(head_two, column), column);
}

struct node *merge(struct node *head_one, struct node *head_two, int column)
{
    struct node *head_combined;
    if(head_one == NULL)
        return head_two;
    if(head_two == NULL)
        return head_one;
    if(head_one->val[column] < head_two->val[column]) {
        head_combined = head_one;
        head_combined->next = merge(head_one->next, head_two, column);
    } else {
        head_combined = head_two;
        head_combined->next = merge(head_one, head_two->next, column);
    };
    return head_combined;
}

我像这样在 Unix 中运行它：

name_of_program < test.txt

test.txt 具有这种结构http://pastebin.com/WL5brutf

4

1 回答 1

1

1）您正在传递int *val给函数，在节点中使用它本身。如果要丢弃val传递给函数并希望保留它的另一个副本，则需要malloc内存。正如您所说，您知道数组中有多少元素，因此您可以分配那么多元素，然后将内存复制val为

 tnode->val = malloc(sizeof(int) * num_of_elements); //replace num_of_elements with appropriate variable/constant
    memcpy(tnode->val, val, sizeof(int) * num_of_elements);

2）是的，那是正确的地方。

3）是的，您可以以这种方式为指向的当前节点分配值head。您可能希望在jfor 循环结束后移动到下一个节点并在其val.

于 2013-06-05T13:56:49.563 回答