notebook/Unit6-A-Data_Structure_C.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Data Structure  in C/C++\n",
    "\n",
    "*  Stack\n",
    "\n",
    "*  Queue\n",
    "\n",
    "*  Hash Table "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Introduction to Data Structures\n",
    "\n",
    "A data structure is a model where data is organized, managed and stored in a format that enables efficient access and modification of data.\n",
    "\n",
    "More precisely,\n",
    "\n",
    "a data structure is a collection of data values, the relationships  them, and the functions or operations that can be applied to the data\n",
    "There are various types of data structures commonly available. It is up to the programmer to choose which data structure to use depending on the data.\n",
    "\n",
    "The choice of a particular one can be considered based on the following points:\n",
    "\n",
    "* It must be able to represent the inherent relationship of the data in the real world.\n",
    "\n",
    "* It must be able to process the data efficiently when necessary.\n",
    "\n",
    ">**数据结构**:相互之间存在一种或多种特定关系的数据元素的集合及其相应算法\n",
    ">\n",
    ">**结构**:指数据元素之间存在的关系，分为逻辑结构和存储结构\n",
    ">\n",
    "> * **逻辑结构**:反映数据元素之间的前后间关系\n",
    ">\n",
    "> * **存储结构**:数据逻辑结构在计算机存储空间的存放形式\n",
    ">\n",
    ">数据元素之间的关系有两种不同的表示方法：顺序映象和非顺序映象，并由此得到两种不同的存储结构：**顺序存储结构**和**链式存储结构**\n",
    "\n",
    "**Classification of data structure**\n",
    "\n",
    "A data structure can be broadly classified into 2 types(逻辑结构):\n",
    "\n",
    "* Linear Data Structures(线性）\n",
    "* Non-Linear Data Structures(非线性）\n",
    "\n",
    "**A linear data structure**’s elements form a sequence. Every element in the structure has some element before and after it.\n",
    "\n",
    ">**线性数据结构**中的元素存在**一对一**的相互关系,如：栈、队列\n",
    "\n",
    "**The non-linear data structure**’s elements do not form a sequence. Every element may not have a unique element before and after it.\n",
    "\n",
    ">**非线性数据结构**中的元素具有多个对应关系,如：图、散列表\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  2 Single Linked list\n",
    "\n",
    "### 2.1 Single Linked List\n",
    "\n",
    "**The Single linked list(单向链表）** consists of a series of structures, which are not necessarily adjacent in memory.\n",
    "\n",
    "Each structure, known as a node， contains the element and a pointer to a structure containing its successor. We call this the next pointer.\n",
    "\n",
    "![single-linked-list-stack](./img/ds/linked-list-stack.png)\n",
    "\n",
    ">**链表**是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。\n",
    ">\n",
    ">链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。\n",
    ">\n",
    ">每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。\n",
    ">\n",
    ">**单向链表** ：链表的链接方向是单向的，head指针指向第一个成为表头结点，而终止于最后一个指向NULL的指针,对链表的访问要通过顺序读取从头部开始\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Stack\n",
    "\n",
    "* push(入栈): add a new item on the top of the linked list `Stack`\n",
    "\n",
    "\n",
    "* pop(出栈）: the element gets popped off from the top of the stack\n",
    "\n",
    "![linked-list-stack](./img/ds/linked-list-stack.png)\n",
    "\n",
    "#### 2.2.1 The implementation of Stack using the single linked list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file ./demo/src/demo_linkedlist_stack.c\n",
    "#include <stdio.h>\n",
    "#include <stdlib.h>\n",
    "#include <limits.h>\n",
    "\n",
    "typedef struct _node\n",
    "{\n",
    "\tint val;\n",
    "\tstruct _node *next;\n",
    "} node;\n",
    "\n",
    "void push(node **head, int val)\n",
    "/* add a new item on the top of the linked list*/\n",
    "{\n",
    "\tnode *new_node=(node *)malloc(sizeof(node));\n",
    "\tnew_node->val = val;\n",
    "\tnew_node->next = *head;\n",
    "\t*head = new_node;\n",
    "}\n",
    "\n",
    "int pop(node **head)\n",
    "{   if (*head==NULL)\n",
    "        return INT_MIN;\n",
    "    int popped = (*head)->val;\n",
    "    node* temp = *head;  \n",
    "    *head = (*head)->next;\n",
    "    free(temp);\n",
    "    return popped;\n",
    "}\n",
    "\n",
    "void print_list(node *head)\n",
    "{\n",
    "\tnode *current = head;\n",
    "\twhile (current != NULL)\n",
    "\t{\n",
    "\t\tprintf(\"%d\\n\", current->val);\n",
    "\t\tcurrent = current->next;\n",
    "\t}\n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "\tnode *stack = NULL;\n",
    "  \tpush(&stack, 7);\n",
    "\tpush(&stack, 9);\n",
    "    push(&stack, 2);\n",
    "\tprint_list(stack);\n",
    "    printf(\"%d\\n\",pop(&stack));\n",
    "    printf(\"%d\\n\",pop(&stack));\n",
    "    printf(\"%d\\n\",pop(&stack));\n",
    "    printf(\"%d\\n\",pop(&stack));\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!gcc -o ./demo/bin/demo_linkedlist_stack ./demo/src/demo_linkedlist_stack.c "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!.\\demo\\bin\\demo_linkedlist_stack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2.2 Stack in C++ STL\n",
    "\n",
    "The functions associated with stack are: \n",
    "* empty() – Returns whether the stack is empty – Time Complexity : O(1) \n",
    "* size() – Returns the size of the stack – Time Complexity : O(1) \n",
    "* top() – Returns a reference to the top most element of the stack – Time Complexity : O(1) \n",
    "* push(g) – Adds the element ‘g’ at the top of the stack – Time Complexity : O(1) \n",
    "* pop() – Deletes the top most element of the stack – Time Complexity : O(1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file ./demo/src/demo_stl_stack.cpp\n",
    "#include <iostream> \n",
    "#include <stack> \n",
    "using namespace std;\n",
    "int main() {\n",
    "    stack<int> stack;\n",
    "    stack.push(21);\n",
    "    stack.push(22);\n",
    "    stack.push(24);\n",
    "    stack.push(25);\n",
    "      \n",
    "    stack.pop();\n",
    "    stack.pop();\n",
    "  \n",
    "    while (!stack.empty()) {\n",
    "        cout << ' ' << stack.top();\n",
    "        stack.pop();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!g++ -o ./demo/bin/demo_stl_stack ./demo/src/demo_stl_stack.cpp "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!.\\demo\\bin\\demo_stl_stack "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Queue\n",
    "\n",
    "\n",
    "* add(Enqueue-入队）: Add an item to the end of the list queue\n",
    "* pop(Dequeue-出队）: Remove an item from the front of a queue\n",
    "\n",
    "![](./img/ds/linked-list-queue.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " #### 2.3.1 The implementation of Queue using the single linked list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file ./demo/src/demo_linkedlist_queue.c\n",
    "#include <stdio.h>\n",
    "#include <stdlib.h>\n",
    "#include <limits.h>\n",
    "\n",
    "typedef struct _node\n",
    "{\n",
    "\tint val;\n",
    "\tstruct _node *next;\n",
    "} node;\n",
    "\n",
    "void push(node **head, node **tail, int val)\n",
    "/*Adding an item to the end of the list*/\n",
    "{\n",
    "\tnode *new_node  = (node *)malloc(sizeof(node));\n",
    "\tnew_node->val = val;\n",
    "\tnew_node->next = NULL;\n",
    "\tif (*head == NULL)\n",
    "\t{\n",
    "\t\t*head = new_node;\n",
    "        *tail = new_node;\n",
    "\t}\n",
    "\telse\n",
    "\t{\n",
    "        (*tail)->next = new_node;\n",
    "        *tail = new_node;\n",
    "    }\t\t\n",
    "}\n",
    "\n",
    "int pop(node **head)\n",
    "/* Remove an item from the front of a queue */\n",
    "{   if (*head==NULL)\n",
    "        return INT_MIN;\n",
    "    node* temp = *head;  \n",
    "    int popped = (*head)->val;\n",
    "    *head = (*head)->next;\n",
    "    free(temp);\n",
    "    return popped;\n",
    "}\n",
    "\n",
    "void print_list(node *head)\n",
    "{\n",
    "\tnode *current = head;\n",
    "\twhile (current != NULL)\n",
    "\t{\n",
    "\t\tprintf(\"%d\\n\", current->val);\n",
    "\t\tcurrent = current->next;\n",
    "\t}\n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "\tnode *queue = NULL;\n",
    "    node *tail = NULL;\n",
    "    push(&queue, &tail,2);\n",
    "    push(&queue, &tail,4);\n",
    "    push(&queue, &tail,6);\n",
    "    push(&queue, &tail,8);\n",
    "    print_list(queue);\n",
    "    printf(\"%d\\n\",pop(&queue));\n",
    "    printf(\"%d\\n\",pop(&queue));\n",
    "    printf(\"%d\\n\",pop(&queue));\n",
    "    printf(\"%d\\n\",pop(&queue));\n",
    "    printf(\"%d\\n\",pop(&queue));   \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!gcc -o ./demo/bin/demo_linkedlist_queue ./demo/src/demo_linkedlist_queue.c "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!.\\demo\\bin\\demo_linkedlist_queue "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.2 Queue in C++ STL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file ./demo/src/demo_stl_queue.cpp\n",
    "#include <iostream>\n",
    "#include <queue>\n",
    "using namespace std;\n",
    " \n",
    "int main()\n",
    "{\n",
    "    // Empty Queue\n",
    "    queue<int> myqueue;\n",
    "    myqueue.push(0);\n",
    "    myqueue.push(1);\n",
    "    myqueue.push(2);\n",
    "    // queue becomes 0, 1, 2\n",
    " \n",
    "    myqueue.pop();\n",
    "    myqueue.pop();\n",
    "    // queue becomes 2\n",
    " \n",
    "    // Printing content of queue\n",
    "    while (!myqueue.empty()) {\n",
    "        cout << ' ' << myqueue.front();\n",
    "        myqueue.pop();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!g++ -o ./demo/bin/demo_stl_queue ./demo/src/demo_stl_queue.cpp "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!.\\demo\\bin\\demo_stl_queue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 3  Hash Table\n",
    "\n",
    "Hash Table with Separate Chaining\n",
    "\n",
    "* key is integer\n",
    "* value is char\n",
    "\n",
    "### 3.1 Hash Table  in C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file ./demo/include/intDict.h\n",
    "#ifndef INTDICT_H\n",
    "#define INTDICT_H\n",
    "\n",
    "typedef struct _node\n",
    "{\n",
    "\tint key;\n",
    "\tchar value;\n",
    "\tstruct _node *next;\n",
    "} Node;\n",
    "\n",
    "typedef struct _hashtable\n",
    "{\n",
    "\tint numBuckets;\n",
    "\tNode **buckets; //the linked list stack\n",
    "} Hashtable;\n",
    "\n",
    "// Create hash table\n",
    "Hashtable *createHash(int numBuckets);\n",
    "\n",
    "// free hash table\n",
    "void *freeHash(Hashtable *hTable);\n",
    "\n",
    "// hash function for int keys\n",
    "int inthash(int key, int numBuckets);\n",
    "\n",
    "// Add Entry to table - keyed by int\n",
    "void addEntry(Hashtable *hTable, int key, char value);\n",
    "\n",
    "// Lookup  by int key\n",
    "Node *searchEntry(Hashtable *hTable, int key);\n",
    "\n",
    "// Get by int key\n",
    "char getValue(Hashtable *hTable, int key);\n",
    "\n",
    "#endif\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file ./demo/src/intDict.c\n",
    "\n",
    "#include <stdio.h>\n",
    "#include <stdlib.h>\n",
    "#include \"intDict.h\"\n",
    "\n",
    "// Create hash table\n",
    "Hashtable *createHash(int numBuckets)\n",
    "{\n",
    "\tHashtable *table = (Hashtable *)malloc(sizeof(Hashtable *));\n",
    "\tif (!table)\n",
    "\t{\n",
    "\t\treturn NULL;\n",
    "\t}\n",
    "\n",
    "\ttable->buckets = (Node **)malloc(sizeof(Node) * numBuckets);\n",
    "\tif (!table->buckets)\n",
    "\t{\n",
    "\t\tfree(table);\n",
    "\t\treturn NULL;\n",
    "\t}\n",
    "\n",
    "\ttable->numBuckets = numBuckets;\n",
    "\t// initialize the head pointer of the bucket stack to NULL\n",
    "\tfor (int i = 0; i < table->numBuckets; i++)\n",
    "\t\ttable->buckets[i] = NULL;\n",
    "\n",
    "\treturn table;\n",
    "}\n",
    "\n",
    "void *freeHash(Hashtable *hTable)\n",
    "{\n",
    "\tNode *b, *p;\n",
    "\tfor (int i = 0; i < hTable->numBuckets; i++)\n",
    "\t{\n",
    "\t\tb = hTable->buckets[i];\n",
    "\t\twhile (b != NULL)\n",
    "\t\t{\n",
    "\t\t\tp = b->next;\n",
    "\t\t\tfree(b);\n",
    "\t\t\tb = p;\n",
    "\t\t}\n",
    "\t}\n",
    "\tfree(hTable->buckets);\n",
    "\tfree(hTable);\n",
    "}\n",
    "\n",
    "// hash function for int key\n",
    "int inthash(int key, int numBuckets)\n",
    "{\n",
    "\treturn key % numBuckets;\n",
    "}\n",
    "\n",
    "// Lookup by int key\n",
    "Node *searchEntry(Hashtable *hTable, int key)\n",
    "{\n",
    "\tNode *p;\n",
    "\tint addr = inthash(key, hTable->numBuckets);\n",
    "\tp = hTable->buckets[addr];\n",
    "\n",
    "\twhile (p && p->key != key)\n",
    "\t\tp = p->next;\n",
    "\n",
    "\treturn p;\n",
    "}\n",
    "\n",
    "// Add Entry to table - keyed by int\n",
    "void addEntry(Hashtable *hTable, int key, char value)\n",
    "{\n",
    "\tint addr;\n",
    "\tNode *p, *entry;\n",
    "\tp = searchEntry(hTable, key);\n",
    "\tif (p)\n",
    "\t{\n",
    "\t\treturn;\n",
    "\t}\n",
    "\telse\n",
    "\t{ /*\n",
    "          add a new item on the top of the linked list stack \n",
    "          and a pointer to the top element.  \n",
    "       */\n",
    "\t\taddr = inthash(key, hTable->numBuckets);\n",
    "\t\tentry = (Node *)malloc(sizeof(Node));\n",
    "\t\tentry->key = key;\n",
    "\t\tentry->value = value;\n",
    "\t\tentry->next = hTable->buckets[addr];\n",
    "\t\thTable->buckets[addr] = entry;\n",
    "\t}\n",
    "}\n",
    "\n",
    "// Get by int key\n",
    "char getValue(Hashtable *hTable, int key)\n",
    "{\n",
    "\tNode *p;\n",
    "\tp = searchEntry(hTable, key);\n",
    "\tif (p)\n",
    "\t{\n",
    "\t\treturn p->value;\n",
    "\t}\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file ./demo/src/mainintDict.c\n",
    "#include <stdio.h>\n",
    "#include <stdlib.h>\n",
    "#include <time.h>\n",
    "#include \"intDict.h\"\n",
    "\n",
    "int main()\n",
    "{\n",
    "\tint key[8]={36,18,72,43,6,10,5,15};\n",
    "\tchar value[8]={'A','B','C','D','E','F','G','H'};\n",
    "\n",
    "   \tint numBuckets = 8;\n",
    "\tint numEntries = 8;\n",
    "\tHashtable *hTable;\n",
    "\n",
    "\thTable = createHash(numBuckets);\n",
    "\tfor (int i = 0; i < numEntries; i++)\n",
    "\t{\n",
    "\t\taddEntry(hTable, key[i], value[i]);\n",
    "\t\tprintf(\"(%d %c)\\n\", key[i], value[i]);\n",
    "\t}\n",
    "\n",
    "\tprintf(\"\\nThe buckets(the linked list stack) are: \\n\");\n",
    "\tfor (int i = 0; i < hTable->numBuckets; i++)\n",
    "\t{\n",
    "\t\tNode *b, *p;\n",
    "\t\tb = hTable->buckets[i];\n",
    "\t\tprintf(\"bucket %d :\", i);\n",
    "\t\tif (b)\n",
    "\t\t{\n",
    "\t\t\tfor (p = b; p != NULL; p = p->next)\n",
    "\t\t\t\tprintf(\" (%d %c) \", p->key, p->value);\n",
    "\t\t\tprintf(\"\\n\");\n",
    "\t\t}\n",
    "\t\telse\n",
    "\t\t\tprintf(\"\\n\");\n",
    "\t}\n",
    "\n",
    "\tprintf(\"\\nHash search:\");\n",
    "    int curkey=18;\n",
    "    char curval = getValue(hTable,curkey);\n",
    "\tprintf(\"%d -> %c \\n\", curkey,curval);\n",
    "\n",
    "\tfreeHash(hTable);\n",
    "\treturn 0;\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!gcc -o ./demo/bin/mainintDict ./demo/src/mainintDict.c ./demo/src/intDict.c -I./demo/include"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!.\\demo\\bin\\mainintDict "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Unordered Map in C++ STL \n",
    "\n",
    "**Unordered maps(C++11)** are associative containers that store \n",
    "\n",
    "* elements formed by the combination of a **key** value and a **mapped value**, and which \n",
    "\n",
    "* allows for fast **retrieval** of individual **elements** based on their **keys**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file ./demo/src/demo_stl_unordered_map.cpp\n",
    "\n",
    "#include <iostream>\n",
    "#include <string>\n",
    "#include <tuple>\n",
    "#include <unordered_map>\n",
    " \n",
    "using namespace std;\n",
    "\n",
    "typedef tuple<string,string,float> tupTag;\n",
    " \n",
    "int main()\n",
    "{  \n",
    "    unordered_map<string, tupTag> tags;\n",
    "    \n",
    "    // inserting values by using [] operator\n",
    "    tags[\"CompressorIPortM\"]=(tupTag){\"压缩机入口质量流量\",\"kg/s\",0.08 };\n",
    "    tags[\"CompressorOPortP\"]=(tupTag){\"压缩机出口压力\", \"MPa\", 0.8};\n",
    "   \n",
    "    // inserting value by insert function\n",
    "    tags.insert(make_pair(\"CompressorOPortT\",(tupTag){\"压缩机出口温度\",\"°C\",50}));\n",
    "    \n",
    "    // Traversing an unordered map\n",
    "    for (auto x : tags)\n",
    "       cout << x.first << \":\" << get<0>(x.second) <<\"\\t\"<<get<1>(x.second) <<\"\\t\"<<get<2>(x.second) << endl;\n",
    "      \n",
    "    string key=\"CompressorOPortP\";\n",
    "    tupTag value =tags[key];\n",
    "    cout <<\"Tag \"<<key<<\" : \"<<get<0>(value)<<\"\\t\"<<get<1>(value)<<\"\\t\"<<get<2>(value)<<endl;\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!g++ -fexec-charset=GBK  -o ./demo/bin/demo_stl_unordered_map.exe ./demo/src/demo_stl_unordered_map.cpp "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!.\\demo\\bin\\demo_stl_unordered_map "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> -fexec-charset=GBK : Chinese charset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference\n",
    "\n",
    "* 严蔚敏，李冬梅，吴伟民. 数据结构（C语言版），人民邮电出版社,2015年2月  \n",
    "\n",
    "* Mark Allen Weiss. Data Structures and Algorithm Analysis in C\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "304.475px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}