将链接列表中的值插入堆栈

Question

我正在C中构建一个程序，我想从0-20中插入100个随机值到链接列表中。之后，我希望将这些值按照插入到列表中的相同顺序压入堆栈。有人能指点我吗？

我的代码：

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

struct listNode{ 
     int data; 
     struct listNode * nextPtr; 
}; 



struct stackNode { 
int data; 
struct stackNode *nextPtr; 
}; 


typedef struct stackNode StackNode; 
typedef StackNode* StackNodePtr; 


typedef struct listNode ListNode; 
typedef ListNode * ListNodePtr; 

void push(StackNodePtr *topPtr, int info); 
void printStack(StackNodePtr currentPtr); 

void insert(ListNodePtr *, int); 
void printList(ListNodePtr); 

int main(void) 
{ 
    ListNodePtr startPtr=NULL; 
    ListNodePtr startPtr1=NULL; 
    StackNodePtr stackPtr = NULL; 
    int item, i; 


    for(i=0;i<100;i++) 
    { 
    item = rand() % 20; 
    insert(&startPtr,item); 
    } 
    printList(startPtr); 

    while(startPtr){ 
     push(&stackPtr,startPtr->data); 
     startPtr=startPtr->nextPtr; 
    } 
    printStack(stackPtr); 
    system("PAUSE"); 
    return 0; 
} 

void insert(ListNodePtr *sPtr,int value) 
{ 
    ListNodePtr newPtr,previousPtr,currentPtr; 
    newPtr = (ListNodePtr)malloc(sizeof(ListNode)); 
    if(newPtr!=NULL){ 
         newPtr->data=value; 
         newPtr->nextPtr=NULL; 


         previousPtr=NULL; 
         currentPtr=*sPtr; 

         while(currentPtr!=NULL && value>currentPtr->data){ 
                     previousPtr=currentPtr; 
                     currentPtr=currentPtr->nextPtr; 
                     } 
         if(previousPtr==NULL){ 
              newPtr->nextPtr=*sPtr; 
              *sPtr=newPtr; 
              } 
         else{ 
          previousPtr->nextPtr=newPtr; 
          newPtr->nextPtr=currentPtr; 
          } 
         } 
         else 
          printf("%d not inserted! No memory!\n",value); 
} 

void printList(ListNodePtr c) 
{ 
    if(c==NULL){ 
       printf("List is empty\n"); 
       }else{ 
         printf("The List is:\n"); 
         while(c!=NULL){ 
             printf("%d --> ",c->data); 
             c=c->nextPtr; 
             } 
             printf("NULL\n\n"); 
         } 
} 

void push(StackNodePtr *topPtr, int info) { 
    StackNodePtr newPtr; 
    newPtr=malloc(sizeof(StackNode)); 
    if(newPtr!=NULL) { 
     newPtr->data=info; 
     newPtr->nextPtr=*topPtr; 
     *topPtr=newPtr; 
    } else 
     printf("%d not inserted. No " 
     "memory.\n", info); 
} 

void printStack(StackNodePtr currentPtr) { 
    if (currentPtr == NULL) { 
     printf("Stack is empty.\n\n"); 
    } else { 
     printf("The stack is:\n"); 
     while (currentPtr != NULL) { 
     printf("%d --> ", currentPtr->data); 
     currentPtr = currentPtr->nextPtr; 
     } 
     printf("NULL\n\n"); 
    } 
} 

其实我这样做，现在无论整数插入它插入堆栈以及列表中，但以相反的顺序。

Answer 1

在您的代码中，第二个循环插入在第一个循环的最后一次迭代中生成的整数（Item）。由于它保持不变，堆栈的所有项目都是相同的。将push语句放在第一个循环中，你会没事的。

int item, i; 
for(i=0;i<100;i++) 
{ 
    item = rand() % 19; 
    insert(&startPtr,item); 
} 
for(i=0;i<100;i++) 
{ 
    push(&stackPtr, item); 
} 

只是这样做：

int item, i; 
for(i=0;i<100;i++) 
{ 
    item = rand() % 19; 
    insert(&startPtr,item); 
    push(&stackPtr, item); 
} 

由于您的插入和推动是导致该列表和堆栈是在相反的顺序。你可以做的是这样的：

创建和尺寸100 数组初始化100个随机值的数组（我希望我并不需要给代码这一点） 然后，如果这个数组的名字是randArray ，请写下面的代码：

int item, i; 
for(i=0;i<100;i++) 
{ 
    item = randArray[i]; 
    insert(&startPtr,item); 
    item = randArray[99-i]; 
    push(&stackPtr, item); 
} 

我在做的是我将随机值插入到栈中的顺序与列表的顺序相反。

srand(time(NULL)); 
    int a[100] = {[0 ... 99] =1}; 
    int i; 
    for (i=0; i<100; i++){ 
     a[i]=rand()%19; 
     printf("%i \n",a[i]); // comment this line it is just for printing 
    }