C 在遍历原始列表时创建新列表

我的任务是在遍历原始列表的同时创建一个新列表，并通过将原始列表中的项目添加到第二个列表的前面，然后打印第二个列表“first one reversed”。不使用递归的反向链表**

我的大部分工作都是在addItemToSecondListInreversed功能中完成的。我真的需要帮助。我得到了第一个列表的最后一项，即9，但其他项仍然缺失。我觉得我需要做一个循环，从最后一个循环到第一个循环，但我不知道怎么做

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

typedef struct tagSingleLinkedList {
    int data; // A single integer will be stored as data
    struct tagSingleLinkedList* next;
}SLLI; // Single Linked List Item


 void reverse(SLLI* head);
void print_list(SLLI* head);
SLLI* AddItemToEnd(SLLI* head, int dataToAdd);
SLLI* AddItemToFront(SLLI* head, int dataToAdd);
SLLI* addItemToSecondListInreversed(SLLI* head);

int main(int argc, char** argv)
{
    SLLI* head = NULL; // This means the list hasn't got any items
    int i;

    for (i = 0; i < 10; i++)
       head = AddItemToEnd(head, i);

    printf("Print list...\n");
    print_list(head);

    printf("----------------------------------\n");
    SLLI* printReverse(SLLI* head, int dataToAdd);
   head = addItemToSecondListInreversed(head);

 print_list(head);
}

SLLI* AddItemToEnd(SLLI* head, int dataToAdd)
{
    SLLI* last;

    // 1-) Allocate memory for a new SLLI item
    SLLI* pItem = (SLLI*) malloc(sizeof(SLLI));
    if (NULL == pItem) {
        printf("Cannot allocate memory for the new item!!!\n");
        exit(1);
    }
    // 2-) Put data into SLLI item
    pItem->data = dataToAdd;
    //3-) Set the next item as NULL (Because the new item will be the last item in the list!)
    pItem->next = NULL;


    //Case 0-) If the list doesn’t have any items – EMPTY LIST
    if (NULL == head)
        return pItem;

    //Case 1-) If the linked list has at least one item
    // STEP 1-) Proceed to the last item in the list
    last = head;
    while (NULL != last->next)
        last = last->next;
    // After while loop "last" point the last item in the list

    // STEP 3-) Add new item after the last item!
    last->next = pItem;

    return head;
}


SLLI* addItemToSecondListInreversed(SLLI* head){
    SLLI* last =head;
    SLLI* newHead;

    if(NULL !=last){
    while (NULL != last->next)
        last = last->next;


    AddItemToFront(last,last->data);


       // printf("%d\n", last->data);
   // last = last->next;
    }

    }


SLLI* AddItemToFront(SLLI* head, int dataToAdd)
{
    // STEP 1-) Allocate memory for the new item
    //------------------------------------------
    // 1-) Allocate memory for a new SLLI item
    SLLI* pItem = (SLLI*) malloc(sizeof(SLLI));
    if (NULL == pItem) {
        printf("Cannot allocate memory for the new item!!!\n");
        exit(1);
    }
    // 2-) Put data into SLLI item
    pItem->data = dataToAdd;

    // STEP 2-) Add new item in front of the list!
    //--------------------------------------------
    pItem->next = head;

    // return the new item's address as the new HEAD of the list!
    return pItem;
}

//printing list
void print_list(SLLI* head) {
    SLLI* temp = head;

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

#包括
#包括
typedef结构标记SingleLinkedList{
int data；//单个整数将作为数据存储
结构标记SingleLinkedList*next；
}SLLI；//单链表项
无效反向（SLLI*头部）；
作废打印列表（SLLI*头）；
SLLI*AddItemToEnd（SLLI*head，int data to add）；
SLLI*附加前端（SLLI*前端，内部数据添加）；
SLLI*附加到第二个反向（SLLI*头部）；
int main（int argc，字符**argv）
{
SLLI*head=NULL；//表示列表中没有任何项目
int i；
对于（i=0；i<10；i++）
head=附加项结束（head，i）；
printf（“打印列表…\n”）；
打印列表（标题）；
printf（“--------------------------------------\n”）；
SLLI*打印反转（SLLI*磁头，int DATA TOADD）；
head=附加到第二个反向（head）；
打印列表（标题）；
}
SLLI*添加项结束（SLLI*头，int DATA TOADD）
{
SLLI*最后；
//1-）为新的SLLI项目分配内存
SLLI*pItem=（SLLI*）malloc（sizeof（SLLI））；
if（NULL==pItem）{
printf（“无法为新项目分配内存！！！\n”）；
出口（1）；
}
//2-）将数据放入SLLI项目
pItem->data=dataToAdd；
//3-）将下一项设置为NULL（因为新项将是列表中的最后一项！）
pItem->next=NULL；
//案例0-）如果列表中没有™没有任何项目–空列表
if（NULL==头）
返回桩；
//案例1-）如果链表至少有一项
//步骤1-）继续执行列表中的最后一项
最后=头部；
while（NULL！=最后一次->下一次）
最后一个=最后一个->下一个；
//while循环“last”后指向列表中的最后一项
//步骤3-）在最后一项之后添加新项！
last->next=pItem；
回流头；
}
SLLI*附加项第二个反向（SLLI*头）{
SLLI*last=头部；
SLLI*纽黑德；
如果（NULL！=最后一个）{
while（NULL！=最后一次->下一次）
最后一个=最后一个->下一个；
AddItemToFront（最后，最后->数据）；
//printf（“%d\n”，最后->数据）；
//最后一个=最后一个->下一个；
}
}
SLLI*附加前端（SLLI*前端，内部数据添加）
{
//步骤1-）为新项目分配内存
//------------------------------------------
//1-）为新的SLLI项目分配内存
SLLI*pItem=（SLLI*）malloc（sizeof（SLLI））；
if（NULL==pItem）{
printf（“无法为新项目分配内存！！！\n”）；
出口（1）；
}
//2-）将数据放入SLLI项目
pItem->data=dataToAdd；
//步骤2-）在列表前面添加新项目！
//--------------------------------------------
pItem->next=头部；
//将新项目的地址作为列表的新标题返回！
返回桩；
}
//打印列表
无效打印列表（SLLI*头）{
SLLI*温度=水头；
while（temp！=NULL）{
printf（“%d\n”，临时->数据）；
温度=温度->下一步；
}
}

您的声明

SLLI*printReverse（SLLI*head，int dataToAdd）；

in

main（）

中的声明没有任何用处；函数没有被调用，声明在几行之后超出范围。您不应该在另一个函数中声明函数（在文件范围或在头中声明）

您对

AddItemToFront（）

内部

addItemToSecondListInreversed（）

-为什么

中的第一个
r
没有大写？一致性在编程中很重要！-多次出现错误。您应该将
newHead的初始化值传递给
AddItemToFront（）
而不是
last
，您应该在
newHead
中捕获返回值。您还需要从函数中返回
newHead
。目前，您在读取列表时弄乱了您试图读取的列表-这不会带来任何好处。而且您没有在应该返回值或初始值时返回值正在初始化
newHead

您还需要在扫描第一个列表的循环中调用
AddItemToFront（）

将这些更改付诸实施，稍微清理代码，添加函数
freeList（）
以释放列表，并使用
camelCaseNames（）
重命名函数，将产生：

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

typedef struct tagSingleLinkedList
{
    int data;
    struct tagSingleLinkedList *next;
} SLLI;

static void printList(SLLI *head);
static SLLI *addItemToEnd(SLLI *head, int dataToAdd);
static SLLI *addItemToFront(SLLI *head, int dataToAdd);
static SLLI *createReversedList(SLLI *head);
static void freeList(SLLI *head);

int main(void)
{
    SLLI *head = NULL;
    int i;

    for (i = 0; i < 10; i++)
        head = addItemToEnd(head, i);

    printf("Print list...\n");
    printList(head);
    printf("----------------------------------\n");

    SLLI *revd = createReversedList(head);

    printf("Reversed list:\n");
    printList(revd);

    freeList(head);
    freeList(revd);

    return 0;
}

SLLI *addItemToEnd(SLLI *head, int dataToAdd)
{
    SLLI *last;

    SLLI *pItem = (SLLI *) malloc(sizeof(SLLI));
    if (NULL == pItem)
    {
        printf("Cannot allocate memory for the new item!!!\n");
        exit(1);
    }

    pItem->data = dataToAdd;
    pItem->next = NULL;

    if (NULL == head)
        return pItem;

    last = head;
    while (NULL != last->next)
        last = last->next;

    last->next = pItem;

    return head;
}

static SLLI *createReversedList(SLLI *head)
{
    SLLI *newHead = NULL;

    while (head != NULL)
    {
        newHead = addItemToFront(newHead, head->data);
        head = head->next;
    }
    return newHead;
}

static SLLI *addItemToFront(SLLI *head, int dataToAdd)
{
    SLLI *pItem = (SLLI *) malloc(sizeof(SLLI));
    if (NULL == pItem)
    {
        fprintf(stderr, "Cannot allocate memory for the new item!!!\n");
        exit(1);
    }

    pItem->data = dataToAdd;
    pItem->next = head;

    return pItem;
}

static void printList(SLLI *head)
{
    while (head != NULL)
    {
        printf("%d\n", head->data);
        head = head->next;
    }
}

static void freeList(SLLI *head)
{
    while (head != NULL)
    {
        SLLI *next = head->next;
        free(head);
        head = next;
    }
}

这看起来正是您想要的。
您已经知道如何迭代列表并对每个项目执行某些操作（即打印），因此为什么不在第二个列表的开头添加相同的操作。看看PrintList和AddEachItemToFrontOfSecondList之间的相似性：您的声明
SLLI*printReverse（SLLI*head，int dataToAdd）；
main（）
中的
没有做任何有用的事情；函数没有被调用，几行后声明就超出了范围。你不应该在另一个函数中声明函数（在文件范围或头中声明）。你对
addItemToFront（）的调用
内部
addItemToSecondListInreversed（）
（为什么
中的第一个
r
没有反转
大写？一致性在编程中很重要！）存在多次错误。您应该将
newHead的初始化值传递给
AddItemToFront（）
而不是
last
，您应该在
newHead
中捕获返回值。您还需要从函数中返回
newHead
。目前，您在读取列表时弄乱了试图读取的列表-这不会带来任何好处。而且，当您
Print list...
0
1
2
3
4
5
6
7
8
9
----------------------------------
Reversed list:
9
8
7
6
5
4
3
2
1
0