{"id":162,"date":"2023-03-02T00:54:57","date_gmt":"2023-03-02T00:54:57","guid":{"rendered":"https:\/\/alitousen.com\/?page_id=162"},"modified":"2025-03-14T14:36:54","modified_gmt":"2025-03-14T14:36:54","slug":"data-structure","status":"publish","type":"page","link":"https:\/\/alitousen.com\/?page_id=162","title":{"rendered":"Data Structure"},"content":{"rendered":"\n

In computer science, a data structure is a way of organizing and storing data in a computer’s memory. It provides a way to represent and manipulate data in a way that facilitates efficient access and modification of the data.<\/p>\n\n\n\n

Data structures can be implemented using various programming languages and can be classified into two main categories: primitive and non-primitive data structures.<\/p>\n\n\n\n

Primitive data structures are basic data types provided by programming languages such as integers, floating-point numbers, characters, and booleans. They are not modifiable and are used to represent simple values.<\/p>\n\n\n\n

Non-primitive data structures, on the other hand, are more complex and can be further divided into linear and nonlinear data structures. Linear data structures include arrays, linked lists, stacks, and queues, while nonlinear data structures include trees and graphs. Non-primitive data structures can be modified, and they can represent more complex relationships between data.<\/p>\n\n\n\n

Choosing the right data structure is essential to optimize the performance of algorithms that manipulate data. Data structures are a fundamental concept in computer science and are used extensively in programming and software development.<\/p>\n\n\n\n

Here are some common data structure topics that you must know:<\/p>\n\n\n\n

    \n
  1. Arrays – a collection of elements of the same type that are stored in contiguous memory locations.<\/li>\n\n\n\n
  2. Linked Lists – a data structure that consists of a sequence of nodes, each containing a reference to an object and a reference to the next node.<\/li>\n\n\n\n
  3. Stacks – a data structure that stores and retrieves elements in a “last in, first out” (LIFO) manner.<\/li>\n\n\n\n
  4. Queues – a data structure that stores and retrieves elements in a “first in, first out” (FIFO) manner.<\/li>\n\n\n\n
  5. Trees – a hierarchical data structure that consists of nodes connected by edges, with a single node called the root.<\/li>\n\n\n\n
  6. Graphs – a collection of vertices connected by edges, where each edge has a weight or cost associated with it.<\/li>\n\n\n\n
  7. Hash Tables – a data structure that uses a hash function to map keys to values, allowing for efficient lookup and insertion.<\/li>\n\n\n\n
  8. Heaps – a data structure that represents a partially ordered tree, where the value of each node is greater than or equal to (or less than or equal to) the values of its children.<\/li>\n\n\n\n
  9. Tries – a tree-like data structure that is used to store and retrieve associative arrays, where each node represents a prefix of a key.<\/li>\n\n\n\n
  10. Sorting Algorithms – algorithms that are used to sort a collection of elements in a specific order, such as ascending or descending order.<\/li>\n<\/ol>\n\n\n\n

    Arrays<\/h2>\n\n\n\n

    An array is a fundamental data structure used in computer programming to store and organize a collection of elements of the same data type. These elements are stored in contiguous memory locations, making it easy to access and manipulate them efficiently.<\/p>\n\n\n\n

    <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    #include <\/span><<\/span>iostream<\/span>><\/span><\/span>\n<\/span>\nint <\/span>main<\/span>() {<\/span><\/span>\n    <\/span>\/\/ Declare an array of integers with a size of 5<\/span><\/span>\n    int arr[<\/span>5<\/span>];<\/span><\/span>\n<\/span>\n    <\/span>\/\/ Assign values to the array elements<\/span><\/span>\n    arr[<\/span>0<\/span>] <\/span>=<\/span> <\/span>10<\/span>;<\/span><\/span>\n    arr[<\/span>1<\/span>] <\/span>=<\/span> <\/span>20<\/span>;<\/span><\/span>\n    arr[<\/span>2<\/span>] <\/span>=<\/span> <\/span>30<\/span>;<\/span><\/span>\n    arr[<\/span>3<\/span>] <\/span>=<\/span> <\/span>40<\/span>;<\/span><\/span>\n    arr[<\/span>4<\/span>] <\/span>=<\/span> <\/span>50<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>\/\/ Access and print array elements<\/span><\/span>\n    <\/span>for<\/span> (int i <\/span>=<\/span> <\/span>0<\/span>; i <\/span><<\/span> <\/span>5<\/span>; i<\/span>++<\/span>) {<\/span><\/span>\n        std::cout <\/span><<<\/span> <\/span>"<\/span>Element at index <\/span>"<\/span> <\/span><<<\/span> i <\/span><<<\/span> <\/span>"<\/span>: <\/span>"<\/span> <\/span><<<\/span> arr[i] <\/span><<<\/span> std::endl;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Linked List<\/h2>\n\n\n\n
    A linked list is a linear data structure used in computer programming to organize and store a collection of elements, called nodes. Unlike arrays, which store elements in contiguous memory locations, linked lists store elements non-contiguously in memory and connect them using pointers.<\/p>\n\n\n\n
    <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    #include<\/span><<\/span>iostream<\/span>><\/span><\/span>\nusing <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Node<\/span> {<\/span><\/span>\npublic<\/span>:<\/span><\/span>\n    <\/span>int<\/span> <\/span>data<\/span>;<\/span><\/span>\n    Node<\/span>*<\/span> next;<\/span><\/span>\n<\/span>\n    <\/span>Node<\/span>(<\/span>int<\/span> <\/span>data<\/span>) {<\/span><\/span>\n        <\/span>this<\/span>-><\/span>data <\/span>=<\/span> data;<\/span><\/span>\n        <\/span>this<\/span>-><\/span>next <\/span>=<\/span> NULL;<\/span><\/span>\n    }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>LinkedList<\/span> {<\/span><\/span>\npublic<\/span>:<\/span><\/span>\n    <\/span>Node<\/span>* <\/span>head<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>LinkedList<\/span>() {<\/span><\/span>\n        <\/span>this<\/span>-><\/span>head <\/span>=<\/span> NULL;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>void<\/span> <\/span>insert<\/span>(<\/span>int<\/span> <\/span>data<\/span>) {<\/span><\/span>\n        Node<\/span>*<\/span> newNode <\/span>=<\/span> <\/span>new<\/span> <\/span>Node<\/span>(data);<\/span><\/span>\n        <\/span>if<\/span> (head <\/span>==<\/span> NULL) {<\/span><\/span>\n            head <\/span>=<\/span> newNode;<\/span><\/span>\n        }<\/span><\/span>\n        <\/span>else<\/span> {<\/span><\/span>\n            Node<\/span>*<\/span> temp <\/span>=<\/span> head;<\/span><\/span>\n            <\/span>while<\/span> (temp<\/span>-><\/span>next <\/span>!=<\/span> NULL) {<\/span><\/span>\n                temp <\/span>=<\/span> temp<\/span>-><\/span>next;<\/span><\/span>\n            }<\/span><\/span>\n            temp<\/span>-><\/span>next <\/span>=<\/span> newNode;<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>void<\/span> <\/span>display<\/span>() {<\/span><\/span>\n        Node<\/span>*<\/span> temp <\/span>=<\/span> head;<\/span><\/span>\n        <\/span>while<\/span> (temp <\/span>!=<\/span> NULL) {<\/span><\/span>\n            cout <\/span><<<\/span> temp<\/span>-><\/span>data <\/span><<<\/span> <\/span>"<\/span> <\/span>"<\/span>;<\/span><\/span>\n            temp <\/span>=<\/span> temp<\/span>-><\/span>next;<\/span><\/span>\n        }<\/span><\/span>\n        cout <\/span><<<\/span> endl;<\/span><\/span>\n    }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nint <\/span>main<\/span>() {<\/span><\/span>\n    LinkedList linkedList;<\/span><\/span>\n<\/span>\n    linkedList.<\/span>insert<\/span>(<\/span>1<\/span>);<\/span><\/span>\n    linkedList.<\/span>insert<\/span>(<\/span>2<\/span>);<\/span><\/span>\n    linkedList.<\/span>insert<\/span>(<\/span>3<\/span>);<\/span><\/span>\n<\/span>\n    linkedList.<\/span>display<\/span>();<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Stack<\/h2>\n\n\n\n
    <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    #include <\/span><<\/span>iostream<\/span>><\/span><\/span>\nusing <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\n#define MAX_SIZE <\/span>100<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Stack<\/span> {<\/span><\/span>\nprivate<\/span>:<\/span><\/span>\n    <\/span>int<\/span> <\/span>top<\/span>;<\/span><\/span>\n    int arr[MAX_SIZE];<\/span><\/span>\n<\/span>\npublic<\/span>:<\/span><\/span>\n    <\/span>Stack<\/span>() {<\/span><\/span>\n        top <\/span>=<\/span> <\/span>-<\/span>1<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    bool <\/span>isEmpty<\/span>() {<\/span><\/span>\n        <\/span>return<\/span> (top <\/span>==<\/span> <\/span>-<\/span>1<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    bool <\/span>isFull<\/span>() {<\/span><\/span>\n        <\/span>return<\/span> (top <\/span>==<\/span> MAX_SIZE <\/span>-<\/span> <\/span>1<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>void<\/span> <\/span>push<\/span>(int value) {<\/span><\/span>\n        <\/span>if<\/span> (<\/span>isFull<\/span>()) {<\/span><\/span>\n            cout <\/span><<<\/span> <\/span>"<\/span>Stack Overflow<\/span>"<\/span> <\/span><<<\/span> endl;<\/span><\/span>\n            <\/span>return<\/span>;<\/span><\/span>\n        }<\/span><\/span>\n<\/span>\n        arr[<\/span>++<\/span>top] <\/span>=<\/span> value;<\/span><\/span>\n        cout <\/span><<<\/span> value <\/span><<<\/span> <\/span>"<\/span> pushed to stack<\/span>"<\/span> <\/span><<<\/span> endl;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    int <\/span>pop<\/span>() {<\/span><\/span>\n        <\/span>if<\/span> (<\/span>isEmpty<\/span>()) {<\/span><\/span>\n            cout <\/span><<<\/span> <\/span>"<\/span>Stack Underflow<\/span>"<\/span> <\/span><<<\/span> endl;<\/span><\/span>\n            <\/span>return<\/span> <\/span>-<\/span>1<\/span>;<\/span><\/span>\n        }<\/span><\/span>\n<\/span>\n        int value <\/span>=<\/span> arr[top<\/span>--<\/span>];<\/span><\/span>\n        <\/span>return<\/span> value;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    int <\/span>peek<\/span>() {<\/span><\/span>\n        <\/span>if<\/span> (<\/span>isEmpty<\/span>()) {<\/span><\/span>\n            cout <\/span><<<\/span> <\/span>"<\/span>Stack is empty<\/span>"<\/span> <\/span><<<\/span> endl;<\/span><\/span>\n            <\/span>return<\/span> <\/span>-<\/span>1<\/span>;<\/span><\/span>\n        }<\/span><\/span>\n<\/span>\n        <\/span>return<\/span> arr[top];<\/span><\/span>\n    }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nint <\/span>main<\/span>() {<\/span><\/span>\n    Stack stack;<\/span><\/span>\n<\/span>\n    stack.<\/span>push<\/span>(<\/span>1<\/span>);<\/span><\/span>\n    stack.<\/span>push<\/span>(<\/span>2<\/span>);<\/span><\/span>\n    stack.<\/span>push<\/span>(<\/span>3<\/span>);<\/span><\/span>\n<\/span>\n    cout <\/span><<<\/span> stack.<\/span>pop<\/span>() <\/span><<<\/span> <\/span>"<\/span> popped from stack<\/span>"<\/span> <\/span><<<\/span> endl;<\/span><\/span>\n<\/span>\n    cout <\/span><<<\/span> <\/span>"<\/span>Top element of stack: <\/span>"<\/span> <\/span><<<\/span> stack.<\/span>peek<\/span>() <\/span><<<\/span> endl;<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Queues<\/h2>\n\n\n\n
    <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    #include <\/span><<\/span>iostream<\/span>><\/span><\/span>\n<\/span>\ntemplate <\/span><<\/span>typename T<\/span>><\/span><\/span>\nclass<\/span> <\/span>Queue<\/span> {<\/span><\/span>\nprivate<\/span>:<\/span><\/span>\n    <\/span>struct<\/span> <\/span>Node<\/span> {<\/span><\/span>\n        T data;<\/span><\/span>\n        Node<\/span>*<\/span> next;<\/span><\/span>\n        <\/span>Node<\/span>(<\/span>const<\/span> <\/span>T<\/span>& <\/span>value<\/span>) <\/span>:<\/span> <\/span>data<\/span>(<\/span>value<\/span>), <\/span>next<\/span>(<\/span>nullptr<\/span>) {}<\/span><\/span>\n    };<\/span><\/span>\n<\/span>\n    Node<\/span>*<\/span> front;<\/span><\/span>\n    Node<\/span>*<\/span> rear;<\/span><\/span>\n<\/span>\npublic:<\/span><\/span>\n    <\/span>Queue<\/span>() : <\/span>front<\/span>(nullptr), <\/span>rear<\/span>(nullptr) {}<\/span><\/span>\n    <\/span>~<\/span>Queue<\/span>() {<\/span><\/span>\n        <\/span>while<\/span> (<\/span>!<\/span>isEmpty<\/span>()) {<\/span><\/span>\n            <\/span>dequeue<\/span>();<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    bool <\/span>isEmpty<\/span>() <\/span>const<\/span> {<\/span><\/span>\n        return front == nullptr;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>void<\/span> <\/span>enqueue<\/span>(const T<\/span>&<\/span> value) {<\/span><\/span>\n        Node<\/span>*<\/span> newNode <\/span>=<\/span> <\/span>new<\/span> <\/span>Node<\/span>(value);<\/span><\/span>\n<\/span>\n        <\/span>if<\/span> (<\/span>isEmpty<\/span>()) {<\/span><\/span>\n            front <\/span>=<\/span> rear <\/span>=<\/span> newNode;<\/span><\/span>\n        } <\/span>else<\/span> {<\/span><\/span>\n            rear<\/span>-><\/span>next <\/span>=<\/span> newNode;<\/span><\/span>\n            rear <\/span>=<\/span> newNode;<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>void<\/span> <\/span>dequeue<\/span>() {<\/span><\/span>\n        <\/span>if<\/span> (<\/span>isEmpty<\/span>()) {<\/span><\/span>\n            std::cout <\/span><<<\/span> <\/span>"<\/span>Queue is empty. Cannot dequeue from an empty queue.<\/span>"<\/span> <\/span><<<\/span> std::endl;<\/span><\/span>\n            <\/span>return<\/span>;<\/span><\/span>\n        }<\/span><\/span>\n<\/span>\n        Node<\/span>*<\/span> temp <\/span>=<\/span> front;<\/span><\/span>\n        front <\/span>=<\/span> front<\/span>-><\/span>next;<\/span><\/span>\n        <\/span>if<\/span> (front <\/span>==<\/span> nullptr) {<\/span><\/span>\n            rear <\/span>=<\/span> nullptr;<\/span><\/span>\n        }<\/span><\/span>\n        <\/span>delete<\/span> temp;<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    T<\/span>&<\/span> <\/span>getFront<\/span>() {<\/span><\/span>\n        <\/span>if<\/span> (<\/span>isEmpty<\/span>()) {<\/span><\/span>\n            <\/span>throw<\/span> std::<\/span>runtime_error<\/span>(<\/span>"<\/span>Queue is empty. Cannot get the front element from an empty queue.<\/span>"<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n        <\/span>return<\/span> front<\/span>-><\/span>data;<\/span><\/span>\n    }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ Example usage<\/span><\/span>\nint <\/span>main<\/span>() {<\/span><\/span>\n    Queue<\/span><<\/span>int<\/span>><\/span> myQueue;<\/span><\/span>\n    myQueue.<\/span>enqueue<\/span>(<\/span>10<\/span>);<\/span><\/span>\n    myQueue.<\/span>enqueue<\/span>(<\/span>20<\/span>);<\/span><\/span>\n    myQueue.<\/span>enqueue<\/span>(<\/span>30<\/span>);<\/span><\/span>\n<\/span>\n    std::cout <\/span><<<\/span> <\/span>"<\/span>Front element of the queue: <\/span>"<\/span> <\/span><<<\/span> myQueue.<\/span>getFront<\/span>() <\/span><<<\/span> std::endl;<\/span><\/span>\n<\/span>\n    <\/span>while<\/span> (<\/span>!<\/span>myQueue.<\/span>isEmpty<\/span>()) {<\/span><\/span>\n        std::cout <\/span><<<\/span> myQueue.<\/span>getFront<\/span>() <\/span><<<\/span> <\/span>"<\/span> <\/span>"<\/span>;<\/span><\/span>\n        myQueue.<\/span>dequeue<\/span>();<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Tree<\/h2>\n\n\n\n
    <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    #include <\/span><<\/span>iostream<\/span>><\/span><\/span>\n#include <\/span><<\/span>vector<\/span>><\/span><\/span>\n<\/span>\nusing <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\n\/\/ Tree Node<\/span><\/span>\nclass<\/span> <\/span>TreeNode<\/span> {<\/span><\/span>\npublic<\/span>:<\/span><\/span>\n    <\/span>int<\/span> <\/span>val<\/span>;<\/span><\/span>\n    vector<\/span><<\/span>TreeNode<\/span>*><\/span> children;<\/span><\/span>\n<\/span>\n    <\/span>TreeNode<\/span>(<\/span>int<\/span> <\/span>x<\/span>) <\/span>:<\/span> <\/span>val<\/span>(<\/span>x<\/span>) {}<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ Tree Traversal<\/span><\/span>\nvoid<\/span> <\/span>preOrder<\/span>(TreeNode<\/span>*<\/span> root) {<\/span><\/span>\n    <\/span>if<\/span> (root <\/span>==<\/span> nullptr) <\/span>return<\/span>;<\/span><\/span>\n<\/span>\n    cout <\/span><<<\/span> root<\/span>-><\/span>val <\/span><<<\/span> <\/span>"<\/span> <\/span>"<\/span>;<\/span><\/span>\n    <\/span>for<\/span> (TreeNode<\/span>*<\/span> child : root<\/span>-><\/span>children) {<\/span><\/span>\n        <\/span>preOrder<\/span>(child);<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint <\/span>main<\/span>() {<\/span><\/span>\n    <\/span>\/\/ Create Tree<\/span><\/span>\n    TreeNode<\/span>*<\/span> root <\/span>=<\/span> <\/span>new<\/span> <\/span>TreeNode<\/span>(<\/span>1<\/span>);<\/span><\/span>\n    <\/span><\/span>\n    TreeNode<\/span>*<\/span> node2 <\/span>=<\/span> <\/span>new<\/span> <\/span>TreeNode<\/span>(<\/span>2<\/span>);<\/span><\/span>\n    TreeNode<\/span>*<\/span> node3 <\/span>=<\/span> <\/span>new<\/span> <\/span>TreeNode<\/span>(<\/span>3<\/span>);<\/span><\/span>\n    TreeNode<\/span>*<\/span> node4 <\/span>=<\/span> <\/span>new<\/span> <\/span>TreeNode<\/span>(<\/span>4<\/span>);<\/span><\/span>\n    TreeNode<\/span>*<\/span> node5 <\/span>=<\/span> <\/span>new<\/span> <\/span>TreeNode<\/span>(<\/span>5<\/span>);<\/span><\/span>\n<\/span>\n    root<\/span>-><\/span>children.<\/span>push_back<\/span>(node2);<\/span><\/span>\n    root<\/span>-><\/span>children.<\/span>push_back<\/span>(node3);<\/span><\/span>\n    root<\/span>-><\/span>children.<\/span>push_back<\/span>(node4);<\/span><\/span>\n    node3<\/span>-><\/span>children.<\/span>push_back<\/span>(node5);<\/span><\/span>\n<\/span>\n    <\/span>\/\/ Traverse Tree (preorder)<\/span><\/span>\n    cout <\/span><<<\/span> <\/span>"<\/span>Tree traversal (preorder): <\/span>"<\/span>;<\/span><\/span>\n    <\/span>preOrder<\/span>(root);<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n","protected":false},"excerpt":{"rendered":"
    In computer science, a data structure is a way of organizing and storing data in a computer’s memory. It provides a way to represent and manipulate data in a way that facilitates efficient access and modification of the data. Data structures can be implemented using various programming languages and can be classified into two main […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/alitousen.com\/index.php?rest_route=\/wp\/v2\/pages\/162"}],"collection":[{"href":"https:\/\/alitousen.com\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/alitousen.com\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/alitousen.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/alitousen.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=162"}],"version-history":[{"count":7,"href":"https:\/\/alitousen.com\/index.php?rest_route=\/wp\/v2\/pages\/162\/revisions"}],"predecessor-version":[{"id":277,"href":"https:\/\/alitousen.com\/index.php?rest_route=\/wp\/v2\/pages\/162\/revisions\/277"}],"wp:attachment":[{"href":"https:\/\/alitousen.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=162"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}