將鏈接列表中的值插入堆棧

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 
    }