Programming - C Stacks using Linked Lists

in #programming5 years ago (edited)

    After talking about Queues, we will also talk about Stacks using Linked Lists. We will implement the same functions we did when using Arrays (push, pop, print). So, without further do, let's get started!


Stack Linked List Implementation:

 As we already know, a Stack is a Data Structure that implements the LIFO way of getting information. We define the most Data Structures with structs in C. But, because this time we use Lists we will also need a Node for the List. This Node will contain Data and a pointer to the next Node. So our Node looks like this: 

typedef struct Node{ 
	int val;
	struct Node *next;
}Node;

   Using this Node definition we can now have our Stack top pointer be a Node pointer! So, our Stack struct will contain this pointer and maybe even other informations like capacity of Stack and so on...
The Code looks like this: 

typedef struct Stack{
	Node *top;
}Stack;

The top pointer will be initialized as NULL, that means the Stack is Empty!


    The functions that use a Stack will have an struct variable of type Stack and we will use this variable for doing stuff like adding, removing an Item or printing the Stack. The adding and removing need the address so we have a stack pointer, and for printing we will use a variable so that we don't lose the Stack informations.


Adding (Push):

    For adding we can check if stack is full that means we can't add a new Item, when having a capacity variable. Afterwards, we have to create a new Node the same we we did it in Linked Lists like this:

Node *nn;
// create new node
nn = (Node*)malloc(sizeof(Node));
nn->val = val;
nn->next = NULL;

    A special Case is when the List or Stack is empty, then we have to set top to be new Node. When there are Items inside we have to make top be the next of the new Node and afterwards make new Node our new Top.

So, our Code looks like this:

void push(Stack *S, int val){
	Node *nn;
	// create new node
	nn = (Node*)malloc(sizeof(Node));
	nn->val = val;
	nn->next = NULL;	
	// check if items inside
	if(S->top != NULL){
		// make nn's next point to top
		nn->next = S->top;
	}	
	// set nn to new top
	S->top = nn;		
}


 

Removing (Pop):

    When removing an item we have to check if stack is empty(that means we return -1), store the value in top index in a temporary variable, make top equal to its next pointer and return the value.

So, our Code looks like this:

int pop(Stack *S){
	int val;
	// check if empty
	if(S->top == NULL){
		return -1;
	}
	// get value in top
	val = S->top->val;
	// make top point to next
	S->top = S->top->next;
	//return the value 
	return val;	
}


Printing:

    Last but not least comes printing. We will pass the variable and not the address and call the pop function as long as there are items.

The Code looks like this:

void print(Stack S){
	int val;
	// check if empty
	if(S.top == NULL){
		printf("Stack is Empty!\n");
		return;
	}
	// call pop as long as there are items
	while((val = pop(&S)) != -1){
		printf("%d ", val);
	}	
	printf("\n");
}


Code:  

    Last for today here a Code that uses those functions so that you know how to set a Stack up and use it. It's the exact same Code that we did using Arrays. The only thing that changes is the initialization.

int main(){
	//initialize Stack
	Stack S;
	S.top = NULL;
	print(S);
	// add 3 to stack
	push(&S, 5);
	print(S);
	// add 7 to stack
	push(&S, 10);
	print(S);
	// add 2 to stack
	push(&S, 2);
	print(S);
	// remove from stack
	int val;
	val = pop(&S);
	if(val == -1){
		printf("Queue is Empty!\n");
	}
	else{
		printf("%d\n", val);
	}
	print(S);	
}


That was the end of this Post. Hope you enjoyed it! :)

Tomorrow I will upload the Solution for the Java Exercise.

Coin Marketplace

STEEM 0.22
TRX 0.06
JST 0.025
BTC 19602.84
ETH 1329.30
USDT 1.00
SBD 2.45