"Cara Delevingne's Decision to Refrain from Nude Scenes: Empowerment and Boundaries in the Entertainment Industry"

The content highlights Delevingne's interview with The Times, where she talks about her early career experiences and the pressures she faced to appear nude on screen. 

4.BST

header_bst

#ifndef _INCLUDED_BST_

#define _INCLUDED_BST_

#include <stdint.h>

typedef struct _tree_node_ TreeNode;

typedef struct _bst_ BST;

struct _tree_node_

{

    int32_t key;

    TreeNode *left;

    TreeNode *right;

};

struct _bst_

{

    TreeNode *root;

    uint32_t mass;

};

BST bst_new();

BST* bst_add(BST *tree, int32_t key);

uint32_t bst_find(BST *tree, int32_t key);

uint32_t bst_mass(BST *tree);

uint32_t bst_height(BST *tree);

BST* bst_delete_recursive(BST *tree, int32_t key);

BST* bst_travesal_inorder_recursive(BST *tree);

BST* bst_travesal_preorder_recursive(BST *tree);

BST* bst_travesal_postorder_recursive(BST *tree);

BST* bst_travesal_level_order(BST *tree);

BST* bst_travesal_inorder_iterative(BST *root);

#endif // _INCLUDED_BST_

main 

#include <stdio.h>

#include <stdlib.h>

#include<assert.h>

#include"header_bst.h"

#include"header.h"

#include"queue_header.h"

int main()

{

    BST tree = bst_new();

    bst_add(&tree,55);

    assert(tree.root!=NULL);

    assert(tree.root->key == 55);

    assert(tree.root->left == NULL);

    assert(tree.root->right == NULL);

    bst_add(&tree,100);

    bst_add(&tree,23);

    bst_add(&tree,45);

    assert(bst_find(&tree,11)==0);

    assert(bst_find(&tree,100)!=0);

    assert(bst_height(&tree)==3);

    bst_add(&tree,60);

    bst_add(&tree,22);

    assert(bst_height(&tree)==3);

    bst_add(&tree,2);

    assert(bst_height(&tree)==4);

    bst_add(&tree,11);

    bst_delete_recursive(&tree,23);

    assert(bst_find(&tree,23)==0);

    bst_delete_recursive(&tree,100);

    assert(bst_find(&tree,100)==0);

    bst_travesal_inorder_recursive(&tree);

    bst_travesal_preorder_recursive(&tree);

    bst_travesal_postorder_recursive(&tree);

    bst_travesal_inorder_iterative(&tree);

    bst_travesal_level_order(&tree);

    return 0;

}

ops_bst

#include<stdio.h>

#include<stdlib.h>

#include<stddef.h>

#include<assert.h>

#include"header_bst.h"

#include"header.h"

#include"queue_header.h"

BST bst_new()

{

    BST tree = {NULL,0};

    return tree;

}

static TreeNode* _make_treeNode_(int32_t key)

{

    TreeNode *tnode= (TreeNode*)malloc(sizeof(TreeNode));

    tnode->key=key;

    tnode->left=tnode->right=NULL;

    return tnode;

}

BST* bst_add(BST *tree , int32_t key)

{

    TreeNode *root, *parent ;

    root=parent=tree->root;

    while(root!=NULL && root->key!=key)

    {

        parent=root;

        if(key<root->key)

        {

            root=root->left;

        }

        else if(key>root->key)

        {

            root=root->right;

        }

    }

    if(root==NULL)

    {

        TreeNode *tnode = _make_treeNode_(key);

        if(parent==NULL)

        {

            tree->root=tnode;

        }

        else if(key<parent->key)

        {

            parent->left=tnode;

        }

        else

            {

                parent->right=tnode;

            }

        ++tree->mass;

    }

    return tree;

}

uint32_t bst_find(BST* tree , int32_t key)

{

    TreeNode *root= tree->root;

    while(root!=NULL)

    {

        if(key<root->key)

        {

            root=root->left;

        }

        else if(key>root->key)

        {

            root=root->right;

        }

        else

        {

            break;

        }

    }

    return root!=NULL;

}

uint32_t bst_mass(BST* tree)

{

    return tree->mass;

}

static uint32_t _height_(TreeNode* node)

{

    uint32_t height;

    uint32_t lheight, rheight;

    if(node==NULL)

    {

        height =0;

    }

    else

    {

        lheight= _height_ (node->left);

        rheight= _height_(node->right);

        if(lheight>rheight)

        {

            height=lheight+1;

        }

        else

        {

            height=rheight+1;

        }

    }

    return height;

}

uint32_t bst_height(BST* tree)

{

    return(_height_(tree->root));

}

static TreeNode* _find_min_(TreeNode*root)

{

    if(root->left==NULL)

    {

        return root;

    }

    else

    {

        return(_find_min_(root->left));

    }

}

static TreeNode* _bst_delete(BST* tree, TreeNode* root,int32_t key)

{

    TreeNode* temp;

    if(root==NULL)

    {

        return root;

    }

    else if (key <root->key)

    {

        root->left= _bst_delete(tree,root->left,key);

    }

    else if(key>root->key)

    {

        root->right=_bst_delete(tree,root->right,key);

    }

    else if(root->left&&root->right)

    {

        temp= _find_min_(root->right);

        root->key=temp->key;

        root->right=_bst_delete(tree,root->right,root->key);

    }

    else

    {

        temp=root;

        if(root->left==NULL)

        {

            root=root->right;

        }

        else

        {

            root=root->left;

        }

        free(temp);

        --tree->mass;

    }

return root;

}

BST* bst_delete_recursive(BST*tree,int32_t key)

{

    TreeNode* root= _bst_delete(tree,tree->root,key);

    tree->root=root;

    return tree;

}

static void _inorder_(TreeNode* root)

{

    if(root)

    {

        _inorder_(root->left);

        printf("%d\t",root->key);

        _inorder_(root->right);

    }

}

BST* bst_travesal_inorder_recursive(BST*tree)

{

    _inorder_(tree->root);

    printf("\n");

    return tree;

}

static void _preorder_(TreeNode *root)

{

    if(root)

    {

        printf("%d\t",root->key);

        _preorder_(root->left);

        _preorder_(root->right);

    }

}

BST* bst_travesal_preorder_recursive(BST*tree)

{

    _preorder_(tree->root);

    printf("\n");

    return tree;

}

static void _postorder_(TreeNode* root)

{

    if(root)

    {

        _postorder_(root->left);

        _postorder_(root->right);

        printf("%d\t",root->key);

    }

}

BST* bst_travesal_postorder_recursive(BST* tree)

{

    _postorder_(tree->root);

    printf("\n");

    return tree;

}

BST* bst_travesal_inorder_iterative(BST* tree)

{

    Stack stk = stack_new(0);

    StackResult res;

    TreeNode* current = tree->root;

    while((current!=NULL)||!stack_empty(&stk))

    {

        if(current!=NULL)

        {

            stack_push(&stk,(uintptr_t)current,&res);

            current=current->left;

        }

        else

        {

            stack_pop(&stk,&res);

            current=(TreeNode*)(uintptr_t) res.data;

            printf("%d\t",current->key);

            current=current->right;

        }

    }

printf("\n");

return tree;

}

BST* bst_travesal_level_order(BST*tree)

{

    Queue q = queue_new(0);

    QueueResult res;

    TreeNode *root = tree->root;

    if (root == NULL) return tree;

    queue_add(&q, (uintptr_t)root, &res);

    for(;;)

    {

        if (queue_empty(&q))

            break;

        queue_remove(&q, &res);

        root = (TreeNode*)(uintptr_t)res.data;

        if (root != NULL)

        {

            printf("%d\t", root->key);

            if (root->left)

                queue_add(&q, (uintptr_t)root->left, &res);

            if (root->right)

                queue_add(&q, (uintptr_t)root->right, &res);

        }

    }

    printf("\n");

    return tree;

}

GRAPH

graph_head

#ifndef _INCLUDED_GRAPH

#define _INCLUDED_GRAPH

#include<stdint.h>

#define MAX  20

#define TRUE 1

#define FALSE 0

typedef struct _graph_node_ Node;

typedef struct _graph_list_ Graph;

struct _graph_node_

{

    int32_t node_id;

    Node * next;

};

struct _graph_list_

{

    uint32_t max_nodes;

    Node ** neighbours;

};

uint32_t visited[MAX] = {0};

Graph graph_new(uint32_t max);

Graph * graph_adjacency_list(Graph * graph);

Graph * graph_dfs(Graph * graph, int32_t v);

#endif // _INCLUDED_GRAPH

graph_main

#include <stdio.h>

#include <stdint.h>

#include "graph_op.c"

int main()

{

    int32_t start_vertex;

    uint32_t max_nodes;

    printf("Enter the number of nodes in the graph: ");

    scanf("%u", &max_nodes);

    // Create new graph

    Graph graph = graph_new(max_nodes);

    printf("\nEnter adjacency list for each vertex:\n");

    printf("(Enter 9999 when there are no more neighbours for that vertex)\n\n");

    graph_adjacency_list(&graph);

    printf("\nGraph created successfully!\n");

    printf("\nEnter the starting vertex for DFS traversal: ");

    scanf("%d", &start_vertex);

    printf("\nDepth First Search (DFS) traversal starting from node %d:\n", start_vertex);

    graph_dfs(&graph, start_vertex);

    printf("\n\nTraversal complete.\n");

    return 0;

}

graph_op

#include <assert.h>

#include <stdlib.h>

#include <stddef.h>

#include <stdint.h>

#include <string.h>

#include <stdio.h>

#include "graph_head.h"

Graph graph_new(uint32_t max)

{

    Graph graph;

    int i;

    graph.max_nodes = max;

    graph.neighbours = (Node **) malloc(graph.max_nodes * sizeof(Node *));

    for (i = 0; i < graph.max_nodes; i++)

        graph.neighbours[i] = NULL;

    return graph;

}

static Node * _get_node_(int32_t data)

{

    Node *node = (Node *) malloc(sizeof(Node));

    node->node_id = data;

    node->next = NULL;

    return node;

}

static int32_t _get_neighbour_(int32_t vertex)

{

    int32_t node_id;

    printf("Enter the neighbouring node of %d, if none enter 9999: ", vertex);

    scanf("%d", &node_id);

    return node_id;

}

Graph * graph_adjacency_list(Graph *graph)

{

    Node *vertex, *last_vertex;

    int32_t i, neighbour_id;

    for (i = 0; i < graph->max_nodes; i++)

    {

        graph->neighbours[i] = _get_node_(i);

        neighbour_id = _get_neighbour_(i);

        while(neighbour_id != 9999)

        {

            vertex = _get_node_(neighbour_id);

            if(graph->neighbours[i]->next == NULL)

                graph->neighbours[i]->next = vertex;

            else

                last_vertex->next = vertex;

            last_vertex = vertex;

            neighbour_id = _get_neighbour_(i);

        }

    }

    return graph;

}

static void _dfs_(Graph *graph, int32_t v)

{

    Node *vertex;

    visited[v] = TRUE;

    printf("%d\t", v);

    for (vertex = graph->neighbours[v]; vertex != NULL; vertex = vertex->next)

    {

        if (!visited[vertex->node_id])

            _dfs_(graph, vertex->node_id);

    }

}

Graph * graph_dfs(Graph *graph, int32_t v)

{

    int i;

    for (i = 0; i < graph->max_nodes; i++)

        visited[i] = FALSE;

    _dfs_(graph, v);

    return graph;

}

HEAP

heap_head

#ifndef _INCLUDED_HEAP

#define _INCLUDED_HEAP

#include <stdint.h>

#define MAX_HEAP_SIZE 16

typedef struct _heap_ Heap;

struct _heap_

{

    uint32_t size;

    int32_t data[MAX_HEAP_SIZE];

};

Heap heap_new(int32_t data[], uint32_t len);

void heap_delete(Heap *heap);

Heap *heap_sort(Heap *heap);

Heap *heap_insert(Heap *heap, int32_t key);

int32_t heap_get_max(Heap *heap);

int32_t heap_extract_max(Heap *heap);

uint32_t heap_size(Heap *heap);

#endif // _INCLUDED_HEAP

heap_main

#include <stdio.h>

#include <stdint.h>

#include "heap_op.c"

int main()

{

    int32_t data[] = {0, 20, 15, 30, 5, 10}; // index 0 unused

    uint32_t len = 5;

    printf("Creating heap with elements: 20, 15, 30, 5, 10\n");

    Heap heap = heap_new(data, len);

    printf("Heap created. Current max element: %d\n", heap_get_max(&heap));

    printf("\nInserting 40 into heap...\n");

    heap_insert(&heap, 40);

    printf("After insertion, max element: %d\n", heap_get_max(&heap));

    printf("\nHeap elements before sort:\n");

    for (uint32_t i = 1; i <= heap.size; ++i)

        printf("%d ", heap.data[i]);

    printf("\n");

    printf("\nPerforming heap sort...\n");

    heap_sort(&heap);

    printf("Heap elements after sort (descending order):\n");

    for (uint32_t i = 1; i <= len + 1; ++i)

        printf("%d ", heap.data[i]);

    printf("\n");

    printf("\nExtracting max element...\n");

    int32_t max_val = heap_extract_max(&heap);

    printf("Extracted max: %d\n", max_val);

    printf("Heap after extraction:\n");

    for (uint32_t i = 1; i <= heap.size; ++i)

        printf("%d ", heap.data[i]);

    printf("\n");

    printf("\nDeleting heap...\n");

    heap_delete(&heap);

    printf("Heap deleted. Current size: %u\n", heap_size(&heap));

    return 0;

}

heap_op

#include <stddef.h>

#include <assert.h>

#include <string.h>

#include "heap_head.h"

static void _swap_(int32_t *data1, int32_t *data2)

{

    int32_t temp = *data1;

    *data1 = *data2;

    *data2 = temp;

}

static void _heapify_(int32_t data[], uint32_t len, uint32_t parent)

{

    assert(len > 0 && len < MAX_HEAP_SIZE && parent > 0);

    uint32_t child = 2 * parent;

    while (child <= len)

    {

        if (child + 1 <= len && data[child + 1] > data[child])

            ++child;

        if (data[parent] > data[child])

            break;

        _swap_(&data[parent], &data[child]);

        parent = child;

        child = 2 * parent;

    }

}

Heap heap_new(int32_t data[], uint32_t len)

{

    assert(len > 0 && len < MAX_HEAP_SIZE);

    Heap heap;

    for (uint32_t i = len / 2; i > 0; --i)

        _heapify_(data, len, i);

    heap.size = len;

    memcpy(heap.data, data, (len + 1) * sizeof(int32_t));

    return heap;

}

uint32_t heap_size(Heap *heap)

{

    assert(heap != NULL);

    return heap->size;

}

Heap *heap_sort(Heap *heap)

{

    assert(heap != NULL && heap->size > 0 && heap->size < MAX_HEAP_SIZE);

    uint32_t len ;

    for (len = heap->size; len > 1; len--)

    {

        _swap_(&heap->data[1], &heap->data[len]);

        _heapify_(heap->data, len-1, 1);

    }

    return heap;

}

int32_t heap_get_max(Heap *heap)

{

    assert(heap != NULL && heap->size > 0);

    return heap->data[1];

}

int32_t heap_extract_max(Heap * heap)

{

    int32_t max = heap->data[heap->size];

    --heap->size;

    _heapify_(heap->data, heap->size, 1);

    return max;

}

Heap *heap_insert(Heap *heap, int32_t key)

{

    assert(heap != NULL && heap->size + 1 < MAX_HEAP_SIZE);

    ++heap->size;

    uint32_t i = heap->size;

    while (i > 1 && heap->data[i / 2] < key)

    {

        heap->data[i] = heap->data[i / 2];

        i = i / 2;

    }

    heap->data[i] = key;

    return heap;

}

void heap_delete(Heap *heap)

{

    assert(heap != NULL);

    heap->size = 0;

    memset(heap->data, 0, MAX_HEAP_SIZE * sizeof(int32_t));

}

The content highlights Delevingne's interview with The Times, where she talks about her early career experiences and the pressures she faced to appear nude on screen. Delevingne expresses her concerns about the industry's objectification of women and the expectation for them to conform to certain standards.

Delevingne explains that early in her career, she felt she had no choice but to comply with the demands of appearing nude in certain roles. However, she has grown more confident in herself and her beliefs, leading her to assert her boundaries and prioritize her comfort. She emphasizes the importance of setting limits and making choices that align with one's personal values.

The actress acknowledges the positive impact that the #MeToo movement has had in bringing awareness to issues of consent and respect in the entertainment industry. She hopes that her decision to step away from nude scenes will contribute to the ongoing dialogue and inspire others to stand up for themselves and their own boundaries.

The information provides insight into Delevingne's journey of self-discovery and her decision to take control of her own narrative. It sheds light on the challenges faced by actors and models in the industry and the need for more discussions surrounding consent, boundaries, and respect.

Delevingne's choice to no longer participate in nude scenes reflects a growing trend in the entertainment industry where actors are asserting their agency and refusing to be objectified. This shift signifies a broader cultural awakening and a push for greater inclusivity and empowerment.

In summary, the information explores Cara Delevingne's decision to no longer participate in nude scenes, emphasizing her desire to combat exploitation and prioritize her own comfort. It highlights the actress's growth and determination to set boundaries that align with her personal values, with the hope of inspiring others in the process. The content also recognizes the broader societal movement toward respecting actors' autonomy and challenging industry norms.