{"id":1116,"date":"2015-04-07T19:30:20","date_gmt":"2015-04-08T02:30:20","guid":{"rendered":"http:\/\/www.giassa.net\/?page_id=1116"},"modified":"2025-08-24T08:03:52","modified_gmt":"2025-08-24T15:03:52","slug":"stacks","status":"publish","type":"page","link":"https:\/\/www.giassa.net\/?page_id=1116","title":{"rendered":"Stacks"},"content":{"rendered":"<p>A stack is a simple abstract data type with a small number of operations:<\/p>\n<ul>\n<li>Push: put a new element on the top of the stack.<\/li>\n<li>Pop: remove the top-most element on the stack.<\/li>\n<li>Peek: take a look at the element on the top of the stack without removing it.<\/li>\n<\/ul>\n<p>The key principle behind the stack is that there should be no means of accessing data at a lower level in the stack without first sequentially &#8220;pop&#8221;ing the elements above it in the stack. It has uses in numerous fields, including logic flow, image processing, and so on. A general purpose implementation is provided below. It is also referred to as a LIFO (Last In, First Out) structure, since the first element to be pushed onto the stack will be the last one popped off of it in normal circumstances.<\/p>\n<p>&nbsp;<\/p>\n<pre class=\"lang:c decode:true \" title=\"stack.h\">#ifndef STACK_H \/\/ Prevent multiple inclusions\r\n#define STACK_H\r\n\r\n\/*******************************************************************************\r\n * Preprocessor Directives\r\n ******************************************************************************\/\r\n\r\n\r\n\/*******************************************************************************\r\n * Macros and Constants\r\n ******************************************************************************\/\r\n\r\n\r\n\/*******************************************************************************\r\n * Abstract Data Types\r\n ******************************************************************************\/\r\n\/* Generic node in a stack *\/\r\ntypedef struct snode_t {\r\n   struct snode_t* next;\r\n   void*           data;\r\n   size_t          width;\r\n} snode_t;\r\n\r\n\/* Generic stack *\/\r\ntypedef struct stack_t {\r\n   snode_t* top;\r\n   size_t   length;\r\n} stack_t;\r\n\r\n\/*******************************************************************************\r\n * Public Function Prototypes\r\n *******************************************************************************\/\r\n\/* Handle compiling C code as part of a C++ project *\/\r\n#ifdef __cplusplus\r\nextern \"C\" {\r\n#endif\r\n\r\n\/* @functionName: stackInit\r\n * @brief:        Initializes an empty stack.\r\n * @param:        stk: A pointer to the stack.\r\n *\/\r\nint stackInit(stack_t* stk);\r\n\r\n\/* @functionName: stackDestroy\r\n * @brief:        Destroys and cleans up an entire stack.\r\n * @param:        stk: A pointer to the stack.\r\n *\/\r\nint stackDestroy(stack_t* stk);\r\n\r\n\/* @functionName: stackPop\r\n * @brief:        Pop an item from the top of the stack.\r\n * @param:        stk:  A pointer to the stack.\r\n * @param:        node: A pointer to where to store the contents of the\r\n *                      \"popped\" element.\r\n *\/\r\nint stackPop(stack_t* stk, snode_t* node);\r\n\r\n\/* @functionName: stackPush\r\n * @brief:        Push an item on top of the stack.\r\n * @param:        stk:  A pointer to the stack.\r\n * @param:        node: A pointer to the element to \"push\".\r\n *\/\r\nint stackPush(stack_t* stk, snode_t* node);\r\n\r\n\/* @functionName: stackPeek\r\n * @brief:        Peek at the item on top of the stack without deleting it.\r\n * @param:        stk:  A pointer to the stack.\r\n * @param:        node: A pointer to where to store a copy of the data\r\n *                      (not including stack pointer contents) of the data\r\n *                      a the top of the stack.\r\n *\/\r\nint stackPeek(stack_t* stk, snode_t* node);\r\n\r\n#ifdef __cplusplus\r\n}\r\n#endif\r\n\r\n#endif \/\/ STACK_H\r\n<\/pre>\n<p>&nbsp;<\/p>\n<pre class=\"lang:c decode:true \" title=\"stack.c\">\/*******************************************************************************\r\n * @file:      stack.c\r\n * @author:    Matthew Giassa\r\n * @email:     matthew@giassa.net\r\n * @copyright: Matthew Giassa, 2008\r\n * @brief:     Simple stack (FILO) implementation as part of Mmath library for\r\n *             current research projects in biomedical engineering.\r\n *\/\r\n\r\n\/*******************************************************************************\r\n * Preprocessor Directives\r\n ******************************************************************************\/\r\n\/* System Includes *\/\r\n#include &lt;stdio.h&gt;\r\n#include &lt;errno.h&gt;\r\n#include &lt;stdlib.h&gt;\r\n#include &lt;string.h&gt;\r\n#include &lt;time.h&gt;\r\n\r\n\/* Project Includes *\/\r\n#include \"inc\/stack.h\"\r\n\r\n\r\n\/*******************************************************************************\r\n * Macros and Constants\r\n ******************************************************************************\/\r\n#define EOK (0)\r\n\r\n\r\n\/*******************************************************************************\r\n * Abstract Data Types\r\n ******************************************************************************\/\r\n\r\n\r\n\/*******************************************************************************\r\n * Private Function Prototypes\r\n ******************************************************************************\/\r\nsnode_t* stackCloneNode(snode_t* node);\r\nsnode_t* stackFreeNode(snode_t* node);\r\n\r\n\r\n\/*******************************************************************************\r\n * Function Definitions\r\n ******************************************************************************\/\r\n#if 0\r\n\/*----------------------------------------------------------------------------*\/\r\nint main(void) {\r\n   stack_t stk = { 0 };   \/* Need to zero out contents prior to calling init *\/\r\n   snode_t* cur;\r\n   snode_t* tmp;\r\n   snode_t peekStore;\r\n   int i, ret;\r\n\r\n   \/* Initialize random seed *\/\r\n   srand(time(NULL));\r\n\r\n   \/* Initialize stack and populate with a single zeroed out entry *\/\r\n   if ((ret = stackInit(&amp;stk)) != EOK) {\r\n      return ret;\r\n   }\r\n\r\n   \/* Create template entry for populating simple stack *\/\r\n   const int nEntries = 10;\r\n   cur = calloc(1, sizeof(snode_t));\r\n   cur-&gt;width = sizeof(int);\r\n   cur-&gt;data = calloc(1, cur-&gt;width);\r\n\r\n   \/* Add items to the stack *\/\r\n   for (i=0; i&lt;20; i++) {\r\n      *(int*)cur-&gt;data = rand() % 100;\r\n      stackPush(&amp;stk, cur);\r\n   }\r\n\r\n   \/* Print stack contents *\/\r\n   tmp = stk.top;\r\n   for (i=0; tmp != NULL; tmp = tmp-&gt;next, i++) {\r\n      printf(\"i:%02d - Value:%d\\n\", i, *(int*)tmp-&gt;data);\r\n   }\r\n\r\n   \/* Take a peek at the top *\/\r\n   (void)stackPeek(&amp;stk, &amp;peekStore);\r\n   printf(\"Peeked Value:%d\\n\", *(int*)peekStore.data);\r\n\r\n   \/* Clean up *\/\r\n   stackDestroy(&amp;stk);\r\n   stackFreeNode(cur);\r\n\r\n   return EOK;\r\n}\r\n#endif\r\n\r\n\r\n\/*----------------------------------------------------------------------------*\/\r\nsnode_t* stackCloneNode(snode_t* node) {\r\n   if (!node) {\r\n      return NULL;\r\n   }\r\n\r\n   snode_t* tmp;\r\n   if ((tmp = malloc(1*sizeof(snode_t))) == NULL) {\r\n      return NULL;\r\n   }\r\n   if ((tmp-&gt;data = malloc(1*tmp-&gt;width)) == NULL) {\r\n      free(tmp);\r\n      return NULL;\r\n   }\r\n\r\n   \/* Copy contents of node, accounting for dynamically allocated contents *\/\r\n   tmp-&gt;width = node-&gt;width;\r\n   tmp-&gt;next = node-&gt;next;\r\n   memcpy(tmp-&gt;data, node-&gt;data, node-&gt;width);\r\n   return tmp;\r\n}\r\n\r\n\r\n\/*----------------------------------------------------------------------------*\/\r\nsnode_t* stackFreeNode(snode_t* node) {\r\n   if (!node) {\r\n      return NULL;\r\n   }\r\n\r\n   free(node-&gt;data);\r\n   memset(node, 0, sizeof(snode_t));\r\n   free(node);\r\n\r\n   return NULL;\r\n}\r\n\r\n\r\n\/*----------------------------------------------------------------------------*\/\r\nint stackInit(stack_t* stk) {\r\n   if (!stk) {\r\n      return (-EINVAL);\r\n   }\r\n   int ret = EOK;\r\n\r\n   \/* Just make sure the provided \"top\" node pointer points to NULL, so that\r\n    * we aren't erroneously calling init on an already-populated stack.\r\n    *\/\r\n   if (stk-&gt;top != NULL) {\r\n      ret = (-EIO);\r\n   } else {\r\n      stk-&gt;length = 0;\r\n   }\r\n\r\n   return ret;\r\n}\r\n\r\n\r\n\/*----------------------------------------------------------------------------*\/\r\nint stackDestroy(stack_t* stk) {\r\n   if (!stk) {\r\n      return (-EINVAL);\r\n   }\r\n   snode_t* cur = stk-&gt;top;\r\n\r\n\r\n   \/* Delete first entry in stack until empty *\/\r\n   while (cur) {\r\n      stackPop(stk, NULL);\r\n      cur = cur-&gt;next;\r\n   }\r\n   stk-&gt;length = 0;\r\n\r\n   return EOK;\r\n}\r\n\r\n\r\n\/*----------------------------------------------------------------------------*\/\r\nint stackPush(stack_t* stk, snode_t* node) {\r\n   if (!stk || !node) {\r\n      return (-EINVAL);\r\n   }\r\n   snode_t* tmp;\r\n   if ((tmp = stackCloneNode(node)) == NULL) {\r\n      return (-ENOMEM);\r\n   }\r\n\r\n   if (stk-&gt;top == NULL) {\r\n      \/* Account for empty stack *\/\r\n      stk-&gt;top = tmp;\r\n      stk-&gt;top-&gt;next = NULL;\r\n   } else {\r\n      \/* Add to the top of the stack *\/\r\n      tmp-&gt;next = stk-&gt;top;\r\n      stk-&gt;top = tmp;\r\n   }\r\n   stk-&gt;length++;\r\n\r\n   return EOK;\r\n}\r\n\r\n\r\n\/*----------------------------------------------------------------------------*\/\r\nint stackPop(stack_t* stk, snode_t* node) {\r\n   if (!stk || !stk-&gt;top) {\r\n      return (-EINVAL);\r\n   }\r\n   \/* Just delete the top node if an invalid target pointer is provided *\/\r\n   if (node) {\r\n      snode_t* tmp;\r\n      if ((tmp = stackCloneNode(stk-&gt;top)) == NULL) {\r\n         return (-ENOMEM);\r\n      }\r\n      memcpy(node, tmp, sizeof(snode_t));\r\n      free(tmp);\r\n   }\r\n\r\n   if (stk-&gt;top-&gt;next == NULL) {\r\n      \/* Account for last item in stack *\/\r\n      stackFreeNode(stk-&gt;top);\r\n      stk-&gt;top = NULL;\r\n   } else {\r\n      \/* Add to the top of the stack *\/\r\n      stk-&gt;top = stk-&gt;top-&gt;next;\r\n   }\r\n   stk-&gt;length--;\r\n\r\n   return EOK;\r\n}\r\n\r\n\r\n\/*----------------------------------------------------------------------------*\/\r\nint stackPeek(stack_t* stk, snode_t* node) {\r\n   if (!stk || !stk-&gt;top || !node) {\r\n      return (-EINVAL);\r\n   }\r\n\r\n   \/* Provide a deep copy like with the pop operation *\/\r\n   snode_t* tmp;\r\n   if ((tmp = stackCloneNode(stk-&gt;top)) == NULL) {\r\n      return (-ENOMEM);\r\n   }\r\n   memcpy(node, tmp, sizeof(snode_t));\r\n   node-&gt;next = NULL;   \/* Hide internal pointer data *\/\r\n\r\n   return EOK;\r\n}\r\n\r\n\r\n\r\n<\/pre>\n<p>&nbsp;<\/p>\n","protected":false},"excerpt":{"rendered":"<p>A stack is a simple abstract data type with a small number of operations: Push: put a new element on the top of the stack. Pop: remove the top-most element on the stack. Peek: take a look at the element &hellip; <a href=\"https:\/\/www.giassa.net\/?page_id=1116\">Continue reading <span class=\"meta-nav\">&rarr;<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1075,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-1116","page","type-page","status-publish","hentry"],"aioseo_notices":[],"aioseo_head":"\n\t\t<!-- All in One SEO 4.9.9 - aioseo.com -->\n\t<meta name=\"description\" content=\"A stack is a simple abstract data type with a small number of operations: Push: put a new element on the top of the stack. Pop: remove the top-most element on the stack. Peek: take a look at the element on the top of the stack without removing it. The key principle behind the stack\" \/>\n\t<meta name=\"robots\" content=\"max-image-preview:large\" \/>\n\t<link rel=\"canonical\" href=\"https:\/\/www.giassa.net\/?page_id=1116\" \/>\n\t<meta name=\"generator\" content=\"All in One SEO (AIOSEO) 4.9.9\" \/>\n\t\t<meta property=\"og:locale\" content=\"en_US\" \/>\n\t\t<meta property=\"og:site_name\" content=\"GIASSA.NET | Engineering, DIY, and Everything Else\" \/>\n\t\t<meta property=\"og:type\" content=\"article\" \/>\n\t\t<meta property=\"og:title\" content=\"Stacks | GIASSA.NET\" \/>\n\t\t<meta property=\"og:description\" content=\"A stack is a simple abstract data type with a small number of operations: Push: put a new element on the top of the stack. Pop: remove the top-most element on the stack. Peek: take a look at the element on the top of the stack without removing it. The key principle behind the stack\" \/>\n\t\t<meta property=\"og:url\" content=\"https:\/\/www.giassa.net\/?page_id=1116\" \/>\n\t\t<meta property=\"article:published_time\" content=\"2015-04-08T02:30:20+00:00\" \/>\n\t\t<meta property=\"article:modified_time\" content=\"2025-08-24T15:03:52+00:00\" \/>\n\t\t<meta name=\"twitter:card\" content=\"summary\" \/>\n\t\t<meta name=\"twitter:title\" content=\"Stacks | GIASSA.NET\" \/>\n\t\t<meta name=\"twitter:description\" content=\"A stack is a simple abstract data type with a small number of operations: Push: put a new element on the top of the stack. Pop: remove the top-most element on the stack. Peek: take a look at the element on the top of the stack without removing it. The key principle behind the stack\" \/>\n\t\t<script type=\"application\/ld+json\" class=\"aioseo-schema\">\n\t\t\t{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1116#breadcrumblist\",\"itemListElement\":[{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net#listItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.giassa.net\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=865#listItem\",\"name\":\"Projects\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=865#listItem\",\"position\":2,\"name\":\"Projects\",\"item\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=865\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1075#listItem\",\"name\":\"Algorithms\"},\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net#listItem\",\"name\":\"Home\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1075#listItem\",\"position\":3,\"name\":\"Algorithms\",\"item\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1075\",\"nextItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1116#listItem\",\"name\":\"Stacks\"},\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=865#listItem\",\"name\":\"Projects\"}},{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1116#listItem\",\"position\":4,\"name\":\"Stacks\",\"previousItem\":{\"@type\":\"ListItem\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1075#listItem\",\"name\":\"Algorithms\"}}]},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/#organization\",\"name\":\"GIASSA.NET\",\"description\":\"Engineering, DIY, and Everything Else\",\"url\":\"https:\\\/\\\/www.giassa.net\\\/\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1116#webpage\",\"url\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1116\",\"name\":\"Stacks | GIASSA.NET\",\"description\":\"A stack is a simple abstract data type with a small number of operations: Push: put a new element on the top of the stack. Pop: remove the top-most element on the stack. Peek: take a look at the element on the top of the stack without removing it. The key principle behind the stack\",\"inLanguage\":\"en-US\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.giassa.net\\\/#website\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.giassa.net\\\/?page_id=1116#breadcrumblist\"},\"datePublished\":\"2015-04-07T19:30:20-07:00\",\"dateModified\":\"2025-08-24T08:03:52-07:00\"},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.giassa.net\\\/#website\",\"url\":\"https:\\\/\\\/www.giassa.net\\\/\",\"name\":\"GIASSA.NET\",\"description\":\"Engineering, DIY, and Everything Else\",\"inLanguage\":\"en-US\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.giassa.net\\\/#organization\"}}]}\n\t\t<\/script>\n\t\t<!-- All in One SEO -->\n\n","aioseo_head_json":{"title":"Stacks | GIASSA.NET","description":"A stack is a simple abstract data type with a small number of operations: Push: put a new element on the top of the stack. Pop: remove the top-most element on the stack. Peek: take a look at the element on the top of the stack without removing it. The key principle behind the stack","canonical_url":"https:\/\/www.giassa.net\/?page_id=1116","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"BreadcrumbList","@id":"https:\/\/www.giassa.net\/?page_id=1116#breadcrumblist","itemListElement":[{"@type":"ListItem","@id":"https:\/\/www.giassa.net#listItem","position":1,"name":"Home","item":"https:\/\/www.giassa.net","nextItem":{"@type":"ListItem","@id":"https:\/\/www.giassa.net\/?page_id=865#listItem","name":"Projects"}},{"@type":"ListItem","@id":"https:\/\/www.giassa.net\/?page_id=865#listItem","position":2,"name":"Projects","item":"https:\/\/www.giassa.net\/?page_id=865","nextItem":{"@type":"ListItem","@id":"https:\/\/www.giassa.net\/?page_id=1075#listItem","name":"Algorithms"},"previousItem":{"@type":"ListItem","@id":"https:\/\/www.giassa.net#listItem","name":"Home"}},{"@type":"ListItem","@id":"https:\/\/www.giassa.net\/?page_id=1075#listItem","position":3,"name":"Algorithms","item":"https:\/\/www.giassa.net\/?page_id=1075","nextItem":{"@type":"ListItem","@id":"https:\/\/www.giassa.net\/?page_id=1116#listItem","name":"Stacks"},"previousItem":{"@type":"ListItem","@id":"https:\/\/www.giassa.net\/?page_id=865#listItem","name":"Projects"}},{"@type":"ListItem","@id":"https:\/\/www.giassa.net\/?page_id=1116#listItem","position":4,"name":"Stacks","previousItem":{"@type":"ListItem","@id":"https:\/\/www.giassa.net\/?page_id=1075#listItem","name":"Algorithms"}}]},{"@type":"Organization","@id":"https:\/\/www.giassa.net\/#organization","name":"GIASSA.NET","description":"Engineering, DIY, and Everything Else","url":"https:\/\/www.giassa.net\/"},{"@type":"WebPage","@id":"https:\/\/www.giassa.net\/?page_id=1116#webpage","url":"https:\/\/www.giassa.net\/?page_id=1116","name":"Stacks | GIASSA.NET","description":"A stack is a simple abstract data type with a small number of operations: Push: put a new element on the top of the stack. Pop: remove the top-most element on the stack. Peek: take a look at the element on the top of the stack without removing it. The key principle behind the stack","inLanguage":"en-US","isPartOf":{"@id":"https:\/\/www.giassa.net\/#website"},"breadcrumb":{"@id":"https:\/\/www.giassa.net\/?page_id=1116#breadcrumblist"},"datePublished":"2015-04-07T19:30:20-07:00","dateModified":"2025-08-24T08:03:52-07:00"},{"@type":"WebSite","@id":"https:\/\/www.giassa.net\/#website","url":"https:\/\/www.giassa.net\/","name":"GIASSA.NET","description":"Engineering, DIY, and Everything Else","inLanguage":"en-US","publisher":{"@id":"https:\/\/www.giassa.net\/#organization"}}]},"og:locale":"en_US","og:site_name":"GIASSA.NET | Engineering, DIY, and Everything Else","og:type":"article","og:title":"Stacks | GIASSA.NET","og:description":"A stack is a simple abstract data type with a small number of operations: Push: put a new element on the top of the stack. Pop: remove the top-most element on the stack. Peek: take a look at the element on the top of the stack without removing it. The key principle behind the stack","og:url":"https:\/\/www.giassa.net\/?page_id=1116","article:published_time":"2015-04-08T02:30:20+00:00","article:modified_time":"2025-08-24T15:03:52+00:00","twitter:card":"summary","twitter:title":"Stacks | GIASSA.NET","twitter:description":"A stack is a simple abstract data type with a small number of operations: Push: put a new element on the top of the stack. Pop: remove the top-most element on the stack. Peek: take a look at the element on the top of the stack without removing it. The key principle behind the stack"},"aioseo_meta_data":{"post_id":"1116","title":null,"description":null,"keywords":null,"keyphrases":null,"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":null,"og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"WebPage","isEnabled":true},"graphs":[]},"schema_type":null,"schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":null,"robots_max_videopreview":null,"robots_max_imagepreview":"large","priority":null,"frequency":null,"local_seo":null,"breadcrumb_settings":null,"limit_modified_date":false,"ai":null,"created":"2021-04-22 01:27:51","updated":"2025-08-24 15:39:26","seo_analyzer_scan_date":null},"aioseo_breadcrumb":"<div class=\"aioseo-breadcrumbs\"><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/www.giassa.net\" title=\"Home\">Home<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/www.giassa.net\/?page_id=865\" title=\"Projects\">Projects<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\t<a href=\"https:\/\/www.giassa.net\/?page_id=1075\" title=\"Algorithms\">Algorithms<\/a>\n\t\t<\/span><span class=\"aioseo-breadcrumb-separator\">&raquo;<\/span><span class=\"aioseo-breadcrumb\">\n\t\t\tStacks\n\t\t<\/span><\/div>","aioseo_breadcrumb_json":[{"label":"Home","link":"https:\/\/www.giassa.net"},{"label":"Projects","link":"https:\/\/www.giassa.net\/?page_id=865"},{"label":"Algorithms","link":"https:\/\/www.giassa.net\/?page_id=1075"},{"label":"Stacks","link":"https:\/\/www.giassa.net\/?page_id=1116"}],"_links":{"self":[{"href":"https:\/\/www.giassa.net\/index.php?rest_route=\/wp\/v2\/pages\/1116","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.giassa.net\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.giassa.net\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.giassa.net\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.giassa.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1116"}],"version-history":[{"count":3,"href":"https:\/\/www.giassa.net\/index.php?rest_route=\/wp\/v2\/pages\/1116\/revisions"}],"predecessor-version":[{"id":1119,"href":"https:\/\/www.giassa.net\/index.php?rest_route=\/wp\/v2\/pages\/1116\/revisions\/1119"}],"up":[{"embeddable":true,"href":"https:\/\/www.giassa.net\/index.php?rest_route=\/wp\/v2\/pages\/1075"}],"wp:attachment":[{"href":"https:\/\/www.giassa.net\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1116"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}