Question

我上周参加了数据结构期末考试。我正在尝试解决我考试中的一个问题。我提出了一个解决方案，但我写的代码在我的计算机上不起作用。我可能做错了。

问题是这样的：给出了2个队列，我们应该将这些队列中的元素出列并在链表中对它们进行排序。

我想出了一个主意。将有一个函数，它将2个队列和链表的根作为参数，它将使每个队列出列，直到没有任何东西比开始出列另一个队列为止。链接列表有一个添加功能，可以按排序添加。

这是出列并添加到链表的函数 `

void sortedlist(queue *q1, queue *q2, node *root) {
    while (q1->counter != 0) {
        sortedInsert(root, dequeue(q1));
    }
    while (q2->counter != 0) {
        sortedInsert(root, dequeue(q2));
    }
}

`

这是将链接列表中的元素添加为已排序的函数。

  node* sortedInsert(node *root, int x) {
    if (root == NULL) {
        root = (node *)malloc(sizeof(node*));
        root->x = x;
        root->next = NULL;
        return root;
    }
    if (x< root->x) {
        node *temp = (node *)malloc(sizeof(node));
        temp->next = root;
        temp->x = x;
        return temp;
    }
    node *iter = root;
    while (iter->next != NULL && iter->next->x < x) {
        iter = iter->next;
    }
    node *temp = (node *)malloc(sizeof(node));
    temp->x = x;
    temp->next = iter->next;
    iter->next = temp;
    return root;
}

我会在这里写下所有代码。也许有些人可以告诉我我做错了什么。在此先感谢您的考虑。

#include <stdio.h>
#include <stdlib.h>
#define MAX 100
//there are 2 queues, and one empty linked list
//take elements from queues and sort it on linked list

struct q {
    int queue[MAX];
    int front;
    int rear;
    int counter;
};

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

typedef struct node node;
typedef struct q queue;


void enqueue(queue *queue, int x) {

    if (!(queue->counter == MAX)) {
        queue->rear++;
        queue->counter++;
        if (queue->rear == MAX)
            queue->rear = 0;
        queue->queue[queue->rear] = x;
    }

}

int dequeue(queue *queue) {

    if (!(queue->counter == 0)) {
        int x = queue->queue[queue->front];
        queue->counter--;
        queue->front++;
        if (queue->front == MAX)
            queue->front = 0;
        return x;
    }
    else 
        return - 1;
}

node* sortedInsert(node *root, int x) {
    if (root == NULL) {
        root = (node *)malloc(sizeof(node*));
        root->x = x;
        root->next = NULL;
        return root;
    }
    if (x< root->x) {
        node *temp = (node *)malloc(sizeof(node));
        temp->next = root;
        temp->x = x;
        return temp;
    }
    node *iter = root;
    while (iter->next != NULL && iter->next->x < x) {
        iter = iter->next;
    }
    node *temp = (node *)malloc(sizeof(node));
    temp->x = x;
    temp->next = iter->next;
    iter->next = temp;
    return root;
}

void printlist(node *root) {

    while (root != NULL) {
        printf("%d \n", root->x);
        root = root->next;
    }
}

void initialize(queue *queue) {
    queue->counter = 0;
    queue->front = 0;
    queue->rear = -1;
}

void sortedlist(queue *q1, queue *q2, node *root) {
    while (q1->counter != 0) {
        sortedInsert(root, dequeue(q1));
    }
    while (q2->counter != 0) {
        sortedInsert(root, dequeue(q2));
    }
}

int main(void) {

    queue *q1 = NULL, *q2 = NULL;
    node *root = NULL;
    initialize(q1);
    initialize(q2);

    enqueue(q1, 10);
    enqueue(q1, 20);
    enqueue(q1, 30);
    enqueue(q1, 40);
    enqueue(q1, 50);
    enqueue(q1, 60);
    enqueue(q1, 70);
    enqueue(q2, 15);
    enqueue(q2, 25);
    enqueue(q2, 35);
    enqueue(q2, 45);
    enqueue(q2, 55);
    enqueue(q2, 65);
    enqueue(q2, 75);
    enqueue(q2, 85);
    enqueue(q2, 95);
    enqueue(q2, 105);
    enqueue(q2, 115);

    sortedlist(q1, q2, root);
    printlist(root);
}

Answer 1

实际上很少需要改变才能使这个程序发挥作用。

首先，让我们看看你是如何初始化你的队列的：

queue *q1 = NULL, *q2 = NULL;
node *root = NULL;
initialize(q1);
initialize(q2);

您正在创建并初始化为NULL两个队列指针。然后像这样初始化它们：

void initialize(queue *queue) {
    queue->counter = 0;
    queue->front = 0;
    queue->rear = -1;
}

这不起作用（并立即为我分段），因为您将NULL指针传递给该函数，然后尝试在其上设置值（NULL->counter = 0，...）。

有很多方法可以做到这一点，但有一种可能是这样的：

/* Allocate a queue and initialize it */
queue *createQueue(void) {
    queue *q = malloc(sizeof(*q));
    q->counter = 0;
    q->front = 0;
    q->rear = -1;
    return q;
}

/* In your main() */
queue *q1 = createQueue();
queue *q2 = createQueue();
node *root = NULL;

接下来让我们看一下sortedInsert函数的开头以及如何调用它：

node* sortedInsert(node *root, int x) {
    if (root == NULL) {
        root = (node *)malloc(sizeof(node*));
        root->x = x;
        root->next = NULL;
        return root;
    }
    /* ... */
    return root;
}

void sortedlist(queue *q1, queue *q2, node *root) {
    while (q1->counter != 0) {
        sortedInsert(root, dequeue(q1));
    }
    while (q2->counter != 0) {
        sortedInsert(root, dequeue(q2));
    }
}

这里有两个问题。首先，在sortedInsert中，您malloc为node*（指向结构的指针）的内存，但是您想要node的malloc（结构本身）。

此外，您永远不会使用返回的node*，因此每次都会为NULL。我会更多地重新设计这个，但为了做出微小的改变，这将起作用：

/* The proper allocation in sortedInsert */
node* sortedInsert(node *root, int x) {
    if (root == NULL) {
        root = (node *)malloc(sizeof(node));
    /* ... */

    /* Store the return value each time, *and* return root from here */
    node *sortedlist(queue *q1, queue *q2) {
        node *root = NULL;

        while (q1->counter != 0) {
            root = sortedInsert(root, dequeue(q1));
        }
        while (q2->counter != 0) {
            root = sortedInsert(root, dequeue(q2));
        }

        return root;
    }

最后清理您的分配总是很好的做法，所以在打印清单后这样做：

/* New function to free your list elements */
void freelist(node *root) {
    node *tmp;

    while (root) {
        tmp = root->next;
        free(root);
        root = tmp;
    }
}

/* The end of your main() */
root = sortedlist(q1, q2);
printlist(root);
freelist(root);
free(q1);
free(q2);

如果您计划在C中做更多工作，那么使用调试器（gdb，VisualStudio等）和valgrind等工具是非常宝贵的。

如果以上内容难以遵循，则以下是修改后的工作计划的链接：gist

Answer 2

最大的问题是你将指针传递给函数作为没有返回值的参数 - 如果你没有将指针传递给指针那么实际指针指向赢得的是什么＃39;不要改变。我将你的代码更改为以下内容，在ideone.com中使用它时，它运行正常。

        FileInfo fInfo = new FileInfo(FileName);

        // Add encryption.
        fInfo.Encrypt();

对C

2 个答案: