[
  {
    "path": "BFS/README.md",
    "content": "Поиск в ширину (англ. breadth-first search, BFS) — метод обхода графа и поиска пути в графе"
  },
  {
    "path": "BFS/bfs.go",
    "content": "package main\n\nimport \"fmt\"\n\nvar nodes = map[int][]int{\n\t1:  []int{2, 3, 4},\n\t2:  []int{1, 5, 6},\n\t3:  []int{1},\n\t4:  []int{1, 7, 8},\n\t5:  []int{2, 9, 10},\n\t6:  []int{2},\n\t7:  []int{4, 11, 12},\n\t8:  []int{4},\n\t9:  []int{5},\n\t10: []int{5},\n\t11: []int{7},\n\t12: []int{7},\n}\n\nfunc main() {\n\tvisited := []int{}\n\tbfs(1, nodes, func(node int) {\n\t\tvisited = append(visited, node)\n\t})\n\tfmt.Println(visited)\n}\n\nfunc bfs(start int, nodes map[int][]int, fn func(int)) {\n\tfrontier := []int{start}\n\tvisited := map[int]bool{}\n\tnext := []int{}\n\n\tfor 0 < len(frontier) {\n\t\tnext = []int{}\n\t\tfor _, node := range frontier {\n\t\t\tvisited[node] = true\n\t\t\tfn(node)\n\t\t\tfor _, n := range bfsFrontier(node, nodes, visited) {\n\t\t\t\tnext = append(next, n)\n\t\t\t}\n\t\t}\n\t\tfrontier = next\n\t}\n}\n\nfunc bfsFrontier(node int, nodes map[int][]int, visited map[int]bool) []int {\n\tnext := []int{}\n\titer := func(n int) bool { _, ok := visited[n]; return !ok }\n\tfor _, n := range nodes[node] {\n\t\tif iter(n) {\n\t\t\tnext = append(next, n)\n\t\t}\n\t}\n\treturn next\n}\n"
  },
  {
    "path": "BST/README.md",
    "content": "Двоичное дерево поиска (англ. binary search tree, BST) — это двоичное дерево, для которого выполняются следующие дополнительные условия (свойства дерева поиска):\n* Оба поддерева — левое и правое — являются двоичными деревьями поиска.\n* У всех узлов левого поддерева произвольного узла X значения ключей данных меньше, нежели значение ключа данных самого узла X.\n* У всех узлов правого поддерева произвольного узла X значения ключей данных больше либо равны, нежели значение ключа данных самого узла X.\n\n![IMAGE](/img/bst.png)\n\nBinary Search Tree ADT Operations:\n* Insert(k): вставка элемента k в дерево.\n* Delete(k): удаление элемента k.\n* Search(k): поиск значения элемента k в структуре, есть он или нет.\n* FindMax(): поиск максимального значения.\n* FindMin(): поиск минимального значения."
  },
  {
    "path": "BST/bst.go",
    "content": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ttree := New()\n\tfmt.Println(\"Insert 15 1 2\")\n\ttree.Insert(15)\n\ttree.Insert(1)\n\ttree.Insert(2)\n\tfmt.Println(\"Size: \", tree.Size())\n\tfmt.Println(\"Show: \")\n\ttree.Show()\n\tfmt.Println(\"Insert 3 1 3\")\n\ttree.Insert(3)\n\ttree.Insert(1)\n\ttree.Insert(3)\n\tfmt.Println(\"Size: \", tree.Size())\n\tfmt.Println(\"Show: \")\n\ttree.Show()\n\tfmt.Println(\"Search 4: \", tree.Search(4))\n\tfmt.Println(\"Search 3: \", tree.Search(3))\n\tfmt.Println(\"Insert 14 17 31\")\n\ttree.Insert(14)\n\ttree.Insert(17)\n\ttree.Insert(31)\n\tfmt.Println(\"Size: \", tree.Size())\n\tfmt.Println(\"Show: \")\n\ttree.Show()\n\tfmt.Println(\"Min element: \")\n\ttree.FindMin()\n\tfmt.Println(\"Max element: \")\n\ttree.FindMax()\n\tfmt.Println(\"Delete 31: \", tree.Delete(31))\n\tfmt.Println(\"Delete 5: \", tree.Delete(5))\n\tfmt.Println(\"Delete 5: \", tree.Delete(1))\n\tfmt.Println(\"Size: \", tree.Size())\n\tfmt.Println(\"Show: \")\n\ttree.Show()\n\tfmt.Println(\"Min element: \")\n\ttree.FindMin()\n\tfmt.Println(\"Max element: \")\n\ttree.FindMax()\n}\n\n// Node is a representation of a single node in tree. (recursive ADT)\ntype Node struct {\n\tkey   int\n\tleft  *Node\n\tright *Node\n}\n\n// Bst is a struct of a nodes in tree.\ntype Bst struct {\n\troot *Node\n\tsize int\n}\n\n/*\nBinary Search Tree ADT Operations\n* + Insert(k): вставка элемента k в дерево.\n* + Delete(k): удаление элемента k.\n* + Search(k): поиск значения элемента k в структуре, есть он или нет.\n* + FindMax(): поиск максимального значения.\n* + FindMin(): поиск минимального значения.\n* + Show & Size(): печать дерева и размер.\n*/\n\n// New - Construtor BST\nfunc New() *Bst {\n\treturn &Bst{nil, 0}\n}\n\n// Insert elements in tree\nfunc (tree *Bst) Insert(value int) {\n\tif tree.root == nil {\n\t\ttree.root = &Node{value, nil, nil}\n\t}\n\ttree.size++\n\ttree.root.insert(&Node{value, nil, nil})\n}\n\n// insert is a recursive method for node insertion\nfunc (root *Node) insert(newNode *Node) {\n\n\t//if data exists, skip\n\tif root.key == newNode.key {\n\t\treturn\n\t}\n\n\t// to right-subtree\n\tif root.key < newNode.key {\n\t\tif root.right == nil {\n\t\t\troot.right = newNode\n\t\t} else {\n\t\t\troot.right.insert(newNode)\n\t\t}\n\t} else {\n\t\tif root.left == nil {\n\t\t\troot.left = newNode\n\t\t} else {\n\t\t\troot.left.insert(newNode)\n\t\t}\n\t}\n}\n\n// Size - return size tree\nfunc (tree *Bst) Size() int {\n\treturn tree.size\n}\n\n// Search element on tree\nfunc (tree *Bst) Search(value int) bool {\n\ttree.size--\n\treturn searchElement(tree.root, value)\n}\n\n// search element\nfunc searchElement(root *Node, value int) bool {\n\tif root != nil {\n\t\tif value == root.key {\n\t\t\treturn true\n\t\t} else if value > root.key {\n\t\t\treturn searchElement(root.right, value)\n\t\t} else {\n\t\t\treturn searchElement(root.left, value)\n\t\t}\n\t}\n\treturn false\n}\n\n// Show the tree (Print the tree in-order)\nfunc (tree *Bst) Show() {\n\tprintNode(tree.root)\n}\n\n// Print the tree in-order\n// Traverse the left sub-tree, root, right sub-tree\nfunc printNode(root *Node) {\n\tif root != nil {\n\t\tprintNode(root.left)\n\t\tfmt.Println(root.key)\n\t\tprintNode(root.right)\n\t}\n}\n\n// FindMin - print min element tree\nfunc (tree *Bst) FindMin() {\n\tfmt.Println(minValue(tree.root))\n}\n\nfunc minValue(root *Node) int {\n\tif root != nil {\n\t\tif root.left == nil {\n\t\t\treturn root.key\n\t\t}\n\t\treturn minValue(root.left)\n\t}\n\treturn root.key\n}\n\n// FindMax - print max element tree\nfunc (tree *Bst) FindMax() {\n\tfmt.Println(maxValue(tree.root))\n}\n\nfunc maxValue(root *Node) int {\n\tif root != nil {\n\t\tif root.right == nil {\n\t\t\treturn root.key\n\t\t}\n\t\treturn maxValue(root.right)\n\t}\n\treturn root.key\n}\n\n// Delete element tree\nfunc (tree *Bst) Delete(value int) bool {\n\tif !tree.Search(value) || tree.root == nil {\n\t\treturn false\n\t}\n\n\tif tree.root.key == value {\n\t\ttempRoot := &Node{0, nil, nil}\n\t\ttempRoot.left = tree.root\n\t\tr := del(tree.root, tempRoot, value)\n\t\ttree.root = tempRoot.left\n\t\treturn r\n\t}\n\treturn del(tree.root.left, tree.root, value) || del(tree.root.right, tree.root, value)\n}\n\nfunc del(root *Node, parent *Node, value int) bool {\n\tswitch {\n\tcase root.key == value:\n\t\tif root.left != nil && root.right != nil {\n\t\t\troot.key = minValue(root.right)\n\t\t\treturn del(root.right, root, root.key)\n\t\t}\n\t\tlink(parent, root)\n\t\treturn true\n\tcase root.key > value:\n\t\tif root.left == nil {\n\t\t\treturn false\n\t\t}\n\t\treturn del(root.left, root, value)\n\tcase root.key < value:\n\t\tif root.right == nil {\n\t\t\treturn false\n\t\t}\n\t\treturn del(root.right, root, value)\n\t}\n\treturn false\n}\n\nfunc link(parent *Node, root *Node) {\n\tif parent.left == root {\n\t\tif root.left != nil {\n\t\t\tparent.left = root.left\n\t\t} else {\n\t\t\tparent.left = root.right\n\t\t}\n\t} else if parent.right == root {\n\t\tif root.left != nil {\n\t\t\tparent.right = root.left\n\t\t} else {\n\t\t\tparent.right = root.right\n\t\t}\n\t}\n}\n"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "content": "## Code of conduct\nWelcomes any kind of contribution, please follow the [how to write GO code](https://golang.org/doc/code.html)  "
  },
  {
    "path": "CONTRIBUTING.md",
    "content": "## Contribute\nWelcomes any kind of contribution, please follow the next steps:\n\n- Fork the project on github.com.\n- Create a new branch.\n- Commit changes to the new branch.\n- Send a pull request."
  },
  {
    "path": "ISSUE_TEMPLATE.md",
    "content": "### Issue and Steps to Reproduce\n<!-- Describe your issue and tell us how to reproduce it (include any useful information). -->\n\n### Versions or filename\n\n### Screenshots\n\n#### Expected\n\n#### Actual\n\n### Additional Details\n* Installed packages:\n"
  },
  {
    "path": "LICENSE.md",
    "content": "Copyright 2018 Viktor Solovev  \n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  \n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  \nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.`  \n"
  },
  {
    "path": "README.md",
    "content": "[![Go Report Card](https://goreportcard.com/badge/github.com/dreddsa5dies/algorithm)](https://goreportcard.com/report/github.com/dreddsa5dies/algorithm) ![License](https://img.shields.io/badge/License-MIT-blue.svg)  \n\n## The repository algorithms implemented on the Go:  \n### Sort:\n* [Sort by simple exchange, bubble sort (Сортировка простыми обменами, сортиро́вка пузырько́м)](https://github.com/dreddsa5dies/algorithm/tree/master/bubbleSort)   \n* [Cocktail sort (Сортировка перемешиванием, или Шейкерная сортировка, или двунаправленная)](https://github.com/dreddsa5dies/algorithm/tree/master/bubleSortV2)   \n* [Shell Sort (Сортировка Шелла)](https://github.com/dreddsa5dies/algorithm/tree/master/shellSort)   \n* [Insertion sort (Сортировка вставками)](https://github.com/dreddsa5dies/algorithm/tree/master/insertionSort)   \n* [Fast sorting, sorting Hoare (Quicksort) (Быстрая сортировка, сортировка Хоара)](https://github.com/dreddsa5dies/algorithm/tree/master/quickSort)    \n* [Selection sort (Сортировка выбором)](https://github.com/dreddsa5dies/algorithm/tree/master/selectionSort)   \n* [Heap sort (Пирамидальная сортировка, «Сортировка кучей»)](https://github.com/dreddsa5dies/algorithm/tree/master/heapSort)   \n* [Merge sort (Сортировка слиянием)](https://github.com/dreddsa5dies/algorithm/tree/master/mergeSort)   \n* [Radix sort (Поразрядная сортировка)](https://github.com/dreddsa5dies/algorithm/tree/master/radixSort)  \n* [Counting sort (Сортировка подсчётом)](https://github.com/dreddsa5dies/algorithm/tree/master/countingSort)  \n### Search:\n* [Binary search (Бинарный поиск)](https://github.com/dreddsa5dies/algorithm/tree/master/binarySearch)   \n* [Breadth-first search, BFS (Поиск в ширину (англ. breadth-first search, BFS) — метод обхода графа и поиска пути в графе)](https://github.com/dreddsa5dies/algorithm/tree/master/BFS) \n* [Linear search (Линейный, последовательный поиск)](https://github.com/dreddsa5dies/algorithm/tree/master/linearSearch) \n* [Interpolation search (Интерполяционный, интерполирующий поиск)](https://github.com/dreddsa5dies/algorithm/tree/master/interpolationSearch)  \n\n### ADT:\n* [Stack (абстрактный тип данных, представляющий собой список элементов, организованных по принципу LIFO)](https://github.com/dreddsa5dies/algorithm/tree/master/stack) \n* [Queue (абстрактный тип данных, представляющий собой список элементов, организованных по принципу FIFO)](https://github.com/dreddsa5dies/algorithm/tree/master/queue) \n* [Binary search tree, BST (Двоичное дерево поиска)](https://github.com/dreddsa5dies/algorithm/tree/master/BST) \n* [HEAP (Ку́ча - динамически распределяемая память приложения)](https://golang.org/pkg/container/heap/)  \n* [Doubly linked list (Двунаправленный список)](https://golang.org/pkg/container/list/)  \n* [Circular lists (Круговой связанный список)](https://golang.org/pkg/container/ring/)  \n\n## The code contains comments in Russian\n\n## License\nThis project is licensed under MIT license. Please read the [LICENSE](https://github.com/dreddsa5dies/algorithm/tree/master/LICENSE.md) file.\n\n## Contribute\nWelcomes any kind of contribution. Please read the [CONTRIBUTING](https://github.com/dreddsa5dies/algorithm/tree/master/CONTRIBUTING.md), [ISSUE TEMPLATE](https://github.com/dreddsa5dies/algorithm/tree/master/ISSUE_TEMPLATE.md) and [CODE_OF_CONDUCT](https://github.com/dreddsa5dies/algorithm/tree/master/CODE_OF_CONDUCT.md) file.  \n\n[![Anurag's github stats](https://github-readme-stats.vercel.app/api?username=dreddsa5dies)](https://github.com/anuraghazra/github-readme-stats)\n"
  },
  {
    "path": "binarySearch/README.md",
    "content": "Двоичный (бинарный) поиск (также известен как метод деления пополам и дихотомия) — классический алгоритм поиска элемента в отсортированном массиве (векторе), использующий дробление массива на половины."
  },
  {
    "path": "binarySearch/binarySearch.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"sort\"\n\n\t\"os\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tsort.Ints(s1)\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n\ta := util.Integer(\"Inter number\")\n\tbinSearch(s1, a)\n}\n\nfunc binSearch(list []int, item int) {\n\tlow := 0\n\thigh := len(list) - 1\n\n\tfor low <= high {\n\t\tmid := (low + high) / 2\n\t\tguess := list[mid]\n\t\tif guess == item {\n\t\t\tfmt.Printf(\"Position:\\t%v\\n\", mid)\n\t\t\tos.Exit(0)\n\t\t}\n\t\tif guess > item {\n\t\t\thigh = mid - 1\n\t\t} else {\n\t\t\tlow = mid + 1\n\t\t}\n\t}\n\tfmt.Println(\"Not found\")\n}\n"
  },
  {
    "path": "bubbleSort/README.md",
    "content": "Сортировка простыми обменами, сортиро́вка пузырько́м (англ. bubble sort) — простой алгоритм сортировки. Для понимания и реализации этот алгоритм — простейший, но эффективен он лишь для небольших массивов. Сложность алгоритма: O (n^{2}).\n\nАлгоритм считается учебным и практически не применяется вне учебной литературы, вместо него на практике применяются более эффективные алгоритмы сортировки. В то же время метод сортировки обменами лежит в основе некоторых более совершенных алгоритмов, таких как шейкерная сортировка, пирамидальная сортировка и быстрая сортировка."
  },
  {
    "path": "bubbleSort/bubbleSort.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\t// sort on the right\n\ts1 := util.RandomInt() // срез int\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", s1)\n\tfmt.Println(\"\")\n\tlength := len(s1)\n\tfor i := 0; i < (length - 1); i++ {\n\t\tfor j := 0; j < ((length - 1) - i); j++ {\n\t\t\tif s1[j] > s1[j+1] {\n\t\t\t\ts1[j], s1[j+1] = s1[j+1], s1[j]\n\t\t\t}\n\t\t}\n\t\tfmt.Printf(\"Sorting ...:\\t%v\\n\", s1)\n\t}\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n}\n"
  },
  {
    "path": "bubleSortV2/README.md",
    "content": "Сортировка перемешиванием, или Шейкерная сортировка, или двунаправленная (англ. Cocktail sort) — разновидность пузырьковой сортировки. "
  },
  {
    "path": "bubleSortV2/bubleSortV2.go",
    "content": "// Cocktail sort\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\t// sort on the left\n\ts1 := util.RandomInt() // срез int\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", s1)\n\tfmt.Println(\"\")\n\tlength := len(s1)\n\tfor i := 0; i < (length - 1); i++ {\n\t\tfor j := (length - 1); j > i; j-- {\n\t\t\tif s1[j] < s1[j-1] {\n\t\t\t\ts1[j], s1[j-1] = s1[j-1], s1[j]\n\t\t\t}\n\t\t}\n\t\tfmt.Printf(\"Sorting ...:\\t%v\\n\", s1)\n\t}\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n}\n"
  },
  {
    "path": "countingSort/README.md",
    "content": "Сортировка подсчётом (англ. counting sort; сортировка посредством подсчёта англ. sorting by counting) — алгоритм сортировки, в котором используется диапазон чисел сортируемого массива (списка) для подсчёта совпадающих элементов. Применение сортировки подсчётом целесообразно лишь тогда, когда сортируемые числа имеют (или их можно отобразить в) диапазон возможных значений, который достаточно мал по сравнению с сортируемым множеством, например, миллион натуральных чисел меньших 1000."
  },
  {
    "path": "countingSort/countingSort.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\tarr := util.RandomInt() // срез int\n\n\tfmt.Println(\"Unsorted List:\", arr)\n\n\tk := getK(arr)\n\ttmpArr := make([]int, k)\n\n\tfor i := 0; i < len(arr); i++ {\n\t\ttmpArr[arr[i]]++\n\t}\n\n\tfor i, j := 0, 0; i < k; i++ {\n\t\tfor {\n\t\t\tif tmpArr[i] > 0 {\n\t\t\t\tarr[j] = i\n\t\t\t\tj++\n\t\t\t\ttmpArr[i]--\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\t}\n\n\tfmt.Println(\"Sorted List: \", arr)\n}\n\nfunc getK(arr []int) int {\n\tif len(arr) == 0 {\n\t\treturn 1\n\t}\n\n\tk := arr[0]\n\n\tfor _, v := range arr {\n\t\tif v > k {\n\t\t\tk = v\n\t\t}\n\t}\n\n\treturn k + 1\n}\n"
  },
  {
    "path": "go.mod",
    "content": "module algorithm\n\ngo 1.17\n\nrequire github.com/dreddsa5dies/algorithm v0.0.0-20210807072651-68e310fc4e7c\n"
  },
  {
    "path": "go.sum",
    "content": "github.com/dreddsa5dies/algorithm v0.0.0-20210807072651-68e310fc4e7c h1:+IsVypOBnNZpGvjI4ryPEU0ybiMiAxtDLJLnIBjCB+c=\ngithub.com/dreddsa5dies/algorithm v0.0.0-20210807072651-68e310fc4e7c/go.mod h1:GGavcA9TE70M+HEmeEx2UTTitaMvUbwQ4r1apSyHln0=\n"
  },
  {
    "path": "heapSort/README.md",
    "content": "Пирамидальная сортировка (англ. Heapsort, «Сортировка кучей») — алгоритм сортировки, работающий в худшем, в среднем и в лучшем случае (то есть гарантированно) за Θ(n log n) операций при сортировке n элементов. Количество применяемой служебной памяти не зависит от размера массива (то есть, O(1))."
  },
  {
    "path": "heapSort/heapSort.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nvar maxChild int\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", s1)\n\tfmt.Println(\"\")\n\n\ti := 0\n\ttmp := 0\n\n\tfor i = len(s1)/2 - 1; i >= 0; i-- {\n\t\ts1 = heapSort(s1, i, len(s1))\n\t}\n\n\tfor i = len(s1) - 1; i >= 1; i-- {\n\t\ttmp = s1[0]\n\t\ts1[0] = s1[i]\n\t\ts1[i] = tmp\n\t\ts1 = heapSort(s1, 0, i)\n\t}\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n}\n\nfunc heapSort(s1 []int, i int, s1Len int) []int {\n\tdone := false\n\n\ttmp := 0\n\tmaxChild := 0\n\n\tfor (i*2+1 < s1Len) && (!done) {\n\t\tif i*2+1 == s1Len-1 {\n\t\t\tmaxChild = i*2 + 1\n\t\t} else if s1[i*2+1] > s1[i*2+2] {\n\t\t\tmaxChild = i*2 + 1\n\t\t} else {\n\t\t\tmaxChild = i*2 + 2\n\t\t}\n\n\t\tif s1[i] < s1[maxChild] {\n\t\t\ttmp = s1[i]\n\t\t\ts1[i] = s1[maxChild]\n\t\t\ts1[maxChild] = tmp\n\t\t\ti = maxChild\n\t\t} else {\n\t\t\tdone = true\n\t\t}\n\t\tfmt.Printf(\"Sorting ...:\\t%v\\n\", s1)\n\t}\n\n\treturn s1\n}\n"
  },
  {
    "path": "insertionSort/README.md",
    "content": "Сортировка вставками (англ. Insertion sort) — алгоритм сортировки, в котором элементы входной последовательности просматриваются по одному, и каждый новый поступивший элемент размещается в подходящее место среди ранее упорядоченных элементов[1]. Вычислительная сложность — O(n^{2})."
  },
  {
    "path": "insertionSort/insertionSort.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", s1)\n\tfmt.Println(\"\")\n\tfor i := 1; i < len(s1); i++ {\n\t\tfor j := i; j != 0 && s1[j] < s1[j-1]; j-- {\n\t\t\ts1[j-1], s1[j] = s1[j], s1[j-1]\n\t\t}\n\t\tfmt.Printf(\"Sorting ...:\\t%v\\n\", s1)\n\t}\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n}\n"
  },
  {
    "path": "insertionSortImpruving/insertionSortImpruving.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", s1)\n\tfmt.Println(\"\")\n\tfor i := 1; i < len(s1); i++ {\n\t\tvalue := s1[i]\n\t\tfor j := i; j != 0 && value < s1[j-1]; s1[j] = value {\n\t\t\ts1[j] = s1[j-1]\n\t\t\tj--\n\t\t}\n\t\tfmt.Printf(\"Sorting ...:\\t%v\\n\", s1)\n\t}\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n}\n"
  },
  {
    "path": "interpolationSearch/README.md",
    "content": "Интерполяционный поиск (интерполирующий поиск) основан на принципе поиска в телефонной книге или, например, в словаре. Вместо сравнения каждого элемента с искомым, как при линейном поиске, данный алгоритм производит предсказание местонахождения элемента: поиск происходит подобно двоичному поиску, но вместо деления области поиска на две части, интерполирующий поиск производит оценку новой области поиска по расстоянию между ключом и текущим значением элемента. Другими словами, бинарный поиск учитывает лишь знак разности между ключом и текущим значением, а интерполирующий ещё учитывает и модуль этой разности и по данному значению производит предсказание позиции следующего элемента для проверки. В среднем интерполирующий поиск производит log(log(N)) операций, где N есть число элементов, среди которых производится поиск. Число необходимых операций зависит от равномерности распределения значений среди элементов. В плохом случае (например, когда значения элементов экспоненциально возрастают) интерполяционный поиск может потребовать до O(N) операций."
  },
  {
    "path": "interpolationSearch/interSearch.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\n\t\"sort\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tsort.Ints(s1)\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n\ta := util.Integer(\"Inter number\")\n\tinterSearch(s1, a)\n}\n\nfunc interSearch(sortedArray []int, toFind int) {\n\tvar mid int\n\tlow := 0\n\thigh := len(sortedArray) - 1\n\n\tfor sortedArray[low] < toFind && sortedArray[high] > toFind {\n\t\tmid = low + ((toFind-sortedArray[low])*(high-low))/(sortedArray[high]-sortedArray[low])\n\n\t\tif sortedArray[mid] < toFind {\n\t\t\tlow = mid + 1\n\t\t} else if sortedArray[mid] > toFind {\n\t\t\thigh = mid - 1\n\t\t} else {\n\t\t\tfmt.Println(\"Found: \", mid)\n\t\t\tos.Exit(0)\n\t\t}\n\t}\n\n\tif sortedArray[low] == toFind {\n\t\tfmt.Println(\"Found: \", low)\n\t\tos.Exit(0)\n\t} else if sortedArray[high] == toFind {\n\t\tfmt.Println(\"Found: \", high)\n\t\tos.Exit(0)\n\t} else {\n\t\tfmt.Println(\"Not found\")\n\t}\n}\n"
  },
  {
    "path": "linearSearch/README.md",
    "content": "Линейный, последовательный поиск — алгоритм нахождения заданного значения произвольной функции на некотором отрезке. Данный алгоритм является простейшим алгоритмом поиска и, в отличие, например, от двоичного поиска, не накладывает никаких ограничений на функцию и имеет простейшую реализацию. Поиск значения функции осуществляется простым сравнением очередного рассматриваемого значения (как правило, поиск происходит слева направо, то есть от меньших значений аргумента к большим) и, если значения совпадают (с той или иной точностью), то поиск считается завершённым."
  },
  {
    "path": "linearSearch/linearSearch.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"os\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tfmt.Printf(\"List:\\t%v\\n\", s1)\n\ta := util.Integer(\"Inter number\")\n\tlinearSearch(s1, a)\n}\n\nfunc linearSearch(list []int, item int) {\n\tfor index, value := range list {\n\t\tif value == item {\n\t\t\tfmt.Printf(\"Position:\\t%v\\n\", index)\n\t\t\tos.Exit(0)\n\t\t}\n\t}\n\tfmt.Println(\"Not found\")\n}\n"
  },
  {
    "path": "mergeSort/README.md",
    "content": "Сортировка слиянием (англ. merge sort) — алгоритм сортировки, который упорядочивает списки (или другие структуры данных, доступ к элементам которых можно получать только последовательно, например — потоки) в определённом порядке. Эта сортировка — хороший пример использования принципа «разделяй и властвуй». Сначала задача разбивается на несколько подзадач меньшего размера. Затем эти задачи решаются с помощью рекурсивного вызова или непосредственно, если их размер достаточно мал. Наконец, их решения комбинируются, и получается решение исходной задачи. "
  },
  {
    "path": "mergeSort/mergeSort.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\tnoSort := util.RandomInt() // срез int\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", noSort)\n\tsorted := sort(noSort)\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", sorted)\n}\n\nfunc sort(m []int) []int {\n\tif len(m) <= 1 {\n\t\treturn m\n\t}\n\n\tmid := len(m) / 2\n\tleft := m[:mid]\n\tright := m[mid:]\n\n\tleft = sort(left)\n\tright = sort(right)\n\n\treturn merge(left, right)\n}\n\nfunc merge(left, right []int) []int {\n\tvar result []int\n\tfor len(left) > 0 || len(right) > 0 {\n\t\tif len(left) > 0 && len(right) > 0 {\n\t\t\tif left[0] <= right[0] {\n\t\t\t\tresult = append(result, left[0])\n\t\t\t\tfmt.Printf(\"Sorting:\\t%v\\n\", result)\n\t\t\t\tleft = left[1:]\n\t\t\t} else {\n\t\t\t\tresult = append(result, right[0])\n\t\t\t\tfmt.Printf(\"Sorting:\\t%v\\n\", result)\n\t\t\t\tright = right[1:]\n\t\t\t}\n\t\t} else if len(left) > 0 {\n\t\t\tresult = append(result, left[0])\n\t\t\tfmt.Printf(\"Sorting:\\t%v\\n\", result)\n\t\t\tleft = left[1:]\n\t\t} else if len(right) > 0 {\n\t\t\tresult = append(result, right[0])\n\t\t\tfmt.Printf(\"Sorting:\\t%v\\n\", result)\n\t\t\tright = right[1:]\n\t\t}\n\t}\n\n\treturn result\n}\n"
  },
  {
    "path": "queue/README.md",
    "content": "О́чередь — абстрактный тип данных с дисциплиной доступа к элементам «первый пришёл — первый вышел» (FIFO, англ. first in, first out). Добавление элемента (принято обозначать словом enqueue — поставить в очередь) возможно лишь в конец очереди, выборка — только из начала очереди (что принято называть словом dequeue — убрать из очереди), при этом выбранный элемент из очереди удаляется. \n\n![IMAGE](/img/Queue.png)\n\nQueue ADT Operations:  \n* Enqueue(): Добавить новый элемент в конец очереди.\n* Dequeue(): Удаление элемента из передней части очереди и возврат его значения.\n* Peek(): Вернуть значение элемента в начале очереди.\n* Len(): Возвращает количество элементов внутри очереди."
  },
  {
    "path": "queue/queue.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n\t\"github.com/dreddsa5dies/algorithm/util/queue\"\n)\n\nfunc main() {\n\tlist := util.RandomInt() // срез int\n\tfmt.Printf(\"List:\\t%v\\n\", list)\n\n\tq := queue.New()\n\tfmt.Println(\"Len Queue: \", q.Len())\n\n\tfmt.Println(\"Enqueue:\")\n\tfor i := 0; i < len(list); i++ {\n\t\tfmt.Print(list[i], \" \")\n\t\tq.Enqueue(list[i])\n\t}\n\tfmt.Println(\"\")\n\n\tfmt.Println(\"Len Queue: \", q.Len())\n\tfmt.Println(\"Peek Queue: \", q.Peek())\n\n\tfmt.Println(\"Dequeue:\")\n\tfor q.Len() != 0 {\n\t\tval := q.Dequeue()\n\t\tfmt.Print(val, \" \")\n\t}\n}\n"
  },
  {
    "path": "quickSort/README.md",
    "content": "Быстрая сортировка, сортировка Хоара (англ. quicksort), часто называемая qsort (по имени в стандартной библиотеке языка Си) — широко известный алгоритм сортировки, разработанный английским информатиком Чарльзом Хоаром во время его работы в МГУ в 1960 году.\n\nОдин из самых быстрых известных универсальных алгоритмов сортировки массивов: в среднем O(n\\log n) обменов при упорядочении n элементов; из-за наличия ряда недостатков на практике обычно используется с некоторыми доработками."
  },
  {
    "path": "quickSort/quickSort.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nvar index, start, end int\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", s1)\n\tfmt.Println(\"\")\n\tsort(s1, 0, len(s1)-1)\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n}\n\nfunc sort(s1 []int, start, end int) {\n\tif start >= end {\n\t\treturn\n\t}\n\n\tpivot := s1[start]\n\ti := start + 1\n\n\tfor j := start; j <= end; j++ {\n\t\tif pivot > s1[j] {\n\t\t\ts1[i], s1[j] = s1[j], s1[i]\n\t\t\ti++\n\t\t}\n\t\tfmt.Printf(\"Sorting ...:\\t%v\\n\", s1)\n\t}\n\n\ts1[start], s1[i-1] = s1[i-1], s1[start]\n\n\tsort(s1, start, i-2)\n\tsort(s1, i, end)\n}\n"
  },
  {
    "path": "radixSort/README.md",
    "content": "Поразрядная сортировка (англ. radix sort) — алгоритм сортировки, который выполняется за линейное время."
  },
  {
    "path": "radixSort/radixSort.go",
    "content": "// Thanks https://austingwalters.com/radix-sort-in-go/\npackage main\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\n\tfmt.Println(\"Unsorted List:\", s1)\n\n\tsortedList := radixSort(s1)\n\n\tfmt.Println(\"Sorted List:\", sortedList)\n}\n\n// Finds the largest number in an array\nfunc findLargestNum(array []int) int {\n\tlargestNum := 0\n\n\tfor i := 0; i < len(array); i++ {\n\t\tif array[i] > largestNum {\n\t\t\tlargestNum = array[i]\n\t\t}\n\t}\n\treturn largestNum\n}\n\n// Radix Sort\nfunc radixSort(array []int) []int {\n\n\tfmt.Println(\"Running Radix Sort on Unsorted List\")\n\n\t// Base 10 is used\n\tlargestNum := findLargestNum(array)\n\tsize := len(array)\n\tsignificantDigit := 1\n\tsemiSorted := make([]int, size, size)\n\n\t// Loop until we reach the largest significant digit\n\tfor largestNum/significantDigit > 0 {\n\n\t\tfmt.Println(\"\\tSorting: \"+strconv.Itoa(significantDigit)+\"'s place\", array)\n\n\t\tbucket := [10]int{0}\n\n\t\t// Counts the number of \"keys\" or digits that will go into each bucket\n\t\tfor i := 0; i < size; i++ {\n\t\t\tbucket[(array[i]/significantDigit)%10]++\n\t\t}\n\n\t\t// Add the count of the previous buckets\n\t\t// Acquires the indexes after the end of each bucket location in the array\n\t\t// Works similar to the count sort algorithm\n\t\tfor i := 1; i < 10; i++ {\n\t\t\tbucket[i] += bucket[i-1]\n\t\t}\n\n\t\t// Use the bucket to fill a \"semiSorted\" array\n\t\tfor i := size - 1; i >= 0; i-- {\n\t\t\tbucket[(array[i]/significantDigit)%10]--\n\t\t\tsemiSorted[bucket[(array[i]/significantDigit)%10]] = array[i]\n\t\t}\n\n\t\t// Replace the current array with the semisorted array\n\t\tfor i := 0; i < size; i++ {\n\t\t\tarray[i] = semiSorted[i]\n\t\t}\n\n\t\tfmt.Println(\"\\n\\tBucket: \", bucket)\n\n\t\t// Move to next significant digit\n\t\tsignificantDigit *= 10\n\t}\n\n\treturn array\n}\n"
  },
  {
    "path": "selectionSort/README.md",
    "content": "Сортировка выбором (Selection sort) — алгоритм сортировки. Может быть как устойчивый, так и неустойчивый. На массиве из n элементов имеет время выполнения в худшем, среднем и лучшем случае Θ(n2), предполагая что сравнения делаются за постоянное время."
  },
  {
    "path": "selectionSort/selectionSort.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", s1)\n\tfmt.Println(\"\")\n\tfor i := 0; i < len(s1); i++ {\n\t\tminIndex := i\n\t\tj := i + 1\n\t\tfor j < len(s1) {\n\t\t\tif s1[j] < s1[minIndex] {\n\t\t\t\tminIndex = j\n\t\t\t}\n\t\t\tj = j + 1\n\t\t}\n\t\ts1[i], s1[minIndex] = s1[minIndex], s1[i]\n\t\tfmt.Printf(\"Sorting list:\\t%v\\n\", s1)\n\t}\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n}\n"
  },
  {
    "path": "shellSort/README.md",
    "content": "Сортировка Шелла (англ. Shell sort) — алгоритм сортировки, являющийся усовершенствованным вариантом сортировки вставками. Идея метода Дональда Шелла состоит в сравнении элементов, стоящих не только рядом, но и на определённом расстоянии друг от друга; иными словами — это сортировка вставками, но с предварительными «грубыми» проходами.\n\nАналогичный метод усовершенствования «пузырьковой» сортировки называется «сортировка расчёской»."
  },
  {
    "path": "shellSort/shellSort.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", s1)\n\tfmt.Println(\"\")\n\tlength := len(s1)\n\tgap := int(length / 2)\n\tfor gap >= 1 {\n\t\tfor i := gap; i < length; i++ {\n\t\t\tvalue := s1[i]\n\t\t\tfor j := i; (j-gap) >= 0 && value < s1[j-gap]; s1[j] = value {\n\t\t\t\ts1[j] = s1[j-gap]\n\t\t\t\tj = j - gap\n\t\t\t\tfmt.Printf(\"Sorting ...:\\t%v\\n\", s1)\n\t\t\t}\n\t\t}\n\t\tgap = int(gap / 2)\n\t}\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n}\n"
  },
  {
    "path": "shellSortUpgrade/shellSortGap.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n)\n\nfunc main() {\n\ts1 := util.RandomInt() // срез int\n\tshellSort(s1)\n}\n\nfunc shellSort(s1 []int) {\n\tfmt.Printf(\"Unsorted list:\\t%v\\n\", s1)\n\tfmt.Println(\"\")\n\tlength := len(s1)\n\tgap := int(length / 3) // modify gap by 3\n\tif gap == 0 {\n\t\tgap = 1\n\t}\n\tfor gap >= 1 {\n\t\tfor i := gap; i < length; i++ {\n\t\t\tvalue := s1[i]\n\t\t\tfor j := i; (j-gap) >= 0 && value < s1[j-gap]; s1[j] = value {\n\t\t\t\ts1[j] = s1[j-gap]\n\t\t\t\tj = j - gap\n\t\t\t}\n\t\t}\n\t\tfmt.Printf(\"gap:\\t%v\\n\", gap)\n\t\tgap = int(gap / 3) // modify gap by 3\n\t\tfmt.Printf(\"Sorting ...:\\t%v\\n\", s1)\n\t}\n\tfmt.Println(\"\")\n\tfmt.Printf(\"Sorted list:\\t%v\\n\", s1)\n}\n"
  },
  {
    "path": "stack/README.md",
    "content": "Стек (англ. stack — стопка; читается стэк) — абстрактный тип данных, представляющий собой список элементов, организованных по принципу LIFO (англ. last in — first out, «последним пришёл — первым вышел»).  \n\n![IMAGE](/img/Lifo_stack.png)\n\nStack ADT Operations:\n* Push(): Добавляет новый элемент в начало стека.  \n* Pop(): Удаление элемента из верхней части стека и возврат его значения.  \n* Peek(): Возвращает значение элемента в верхней части стека, не удаляя его.  \n* Len(): Возвращает количество элементов в стеке.  "
  },
  {
    "path": "stack/stack.go",
    "content": "package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/dreddsa5dies/algorithm/util\"\n\t\"github.com/dreddsa5dies/algorithm/util/stack\"\n)\n\nfunc main() {\n\tlist := util.RandomInt() // срез int\n\tfmt.Printf(\"List:\\t%v\\n\", list)\n\n\ts := stack.New()\n\tfmt.Println(\"Len Stack: \", s.Len())\n\n\tfmt.Println(\"Push:\")\n\tfor i := 0; i < len(list); i++ {\n\t\tfmt.Print(list[i], \" \")\n\t\ts.Push(list[i])\n\t}\n\tfmt.Println(\"\")\n\n\tfmt.Println(\"Len Stack: \", s.Len())\n\tfmt.Println(\"Peek Stack: \", s.Peek())\n\n\tfmt.Println(\"Pop:\")\n\tfor s.Len() != 0 {\n\t\tval := s.Pop()\n\t\tfmt.Print(val, \" \")\n\t}\n}\n"
  },
  {
    "path": "util/queue/queue.go",
    "content": "package queue\n\ntype (\n\t// Queue -  Очередь представляется в качестве линейного списка,\n\t// в котором добавление/удаление элементов идет строго с соответствующих его концов.\n\tQueue struct {\n\t\tstart, end *node\n\t\tlength     int\n\t}\n\tnode struct {\n\t\tvalue interface{}\n\t\tnext  *node\n\t}\n)\n\n// New - создание новой очереди\nfunc New() *Queue {\n\treturn &Queue{nil, nil, 0}\n}\n\n// Dequeue - Удаление элемента из передней части очереди и возврат его значения.\nfunc (que *Queue) Dequeue() interface{} {\n\tif que.length == 0 {\n\t\treturn nil\n\t}\n\tn := que.start\n\tif que.length == 1 {\n\t\tque.start = nil\n\t\tque.end = nil\n\t} else {\n\t\tque.start = que.start.next\n\t}\n\tque.length--\n\treturn n.value\n}\n\n// Enqueue - Добавить новый элемент в конец очереди.\nfunc (que *Queue) Enqueue(value interface{}) {\n\tn := &node{value, nil}\n\tif que.length == 0 {\n\t\tque.start = n\n\t\tque.end = n\n\t} else {\n\t\tque.end.next = n\n\t\tque.end = n\n\t}\n\tque.length++\n}\n\n// Len - Возвращает количество элементов внутри очереди.\nfunc (que *Queue) Len() int {\n\treturn que.length\n}\n\n// Peek - Вернуть значение элемента в начале очереди, не удаляя его\nfunc (que *Queue) Peek() interface{} {\n\tif que.length == 0 {\n\t\treturn nil\n\t}\n\treturn que.start.value\n}\n"
  },
  {
    "path": "util/randomInt.go",
    "content": "package util\n\nimport (\n\t\"fmt\"\n\t\"math/rand\"\n)\n\n// RandomInt create random array []int, len()=20\nfunc RandomInt() []int {\n\tlist := rand.Perm(20)\n\tfor i := 0; i < len(list); i++ {\n\t\tj := rand.Intn(i + 1)\n\t\tlist[i], list[j] = list[j], list[i]\n\t}\n\treturn list\n}\n\n// Integer ввод целого числа в stdin\nfunc Integer(msg string) int {\n\tfmt.Print(msg + \" > \")\n\tvar num int\n\t_, err := fmt.Scanf(\"%d\", &num)\n\tif err != nil {\n\t\tpanic(\"Ввод неверных данных\")\n\t}\n\treturn num\n}\n"
  },
  {
    "path": "util/stack/stack.go",
    "content": "package stack\n\ntype (\n\t// Stack - список элементов\n\t// Зачастую стек реализуется в виде однонаправленного списка\n\t// (каждый элемент в списке содержит помимо хранимой информации в стеке указатель\n\t// на следующий элемент стека).\n\tStack struct {\n\t\ttop    *node\n\t\tlength int\n\t}\n\tnode struct {\n\t\tvalue interface{}\n\t\tprev  *node\n\t}\n)\n\n// New - создание нового стэка\nfunc New() *Stack {\n\treturn &Stack{nil, 0}\n}\n\n// Len - возврат количества элементов в стеке\nfunc (st *Stack) Len() int {\n\treturn st.length\n}\n\n// Peek - возврат верхнего элемента\nfunc (st *Stack) Peek() interface{} {\n\tif st.length == 0 {\n\t\treturn nil\n\t}\n\treturn st.top.value\n}\n\n// Pop - возврат элемента и удаление его\nfunc (st *Stack) Pop() interface{} {\n\tif st.length == 0 {\n\t\treturn nil\n\t}\n\n\tn := st.top\n\tst.top = n.prev\n\tst.length--\n\treturn n.value\n}\n\n// Push - значение в верхней части стека\nfunc (st *Stack) Push(value interface{}) {\n\tn := &node{value, st.top}\n\tst.top = n\n\tst.length++\n}\n"
  }
]