Added linkedlist implmentation.
This commit is contained in:
HyperAssembler
parent
8d80b24adc
commit
ab103126b6
|
|
@ -1,44 +0,0 @@
|
|||
#ifndef _LINKED_LIST_H_
|
||||
#define _LINKED_LIST_H_
|
||||
typedef struct _linked_list_node
|
||||
{
|
||||
struct _linked_list_node* prev;
|
||||
struct _linked_list_node* next;
|
||||
void* data;
|
||||
} linked_list_node;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
linked_list_node* head;
|
||||
linked_list_node* tail;
|
||||
int size;
|
||||
} linked_list;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
linked_list_node* current;
|
||||
} linked_list_iterator;
|
||||
|
||||
linked_list* linked_list_create();
|
||||
|
||||
void linked_list_insert(linked_list * list, void* data);
|
||||
|
||||
void linked_list_insert_at(linked_list * list, int position, void* data);
|
||||
|
||||
void* linked_list_get(linked_list * list, int index);
|
||||
|
||||
void linked_list_delete(linked_list * list, void* data, int(*compare)(int*,int*));
|
||||
|
||||
void linked_list_delete_at(linked_list * list, int index);
|
||||
|
||||
linked_list_iterator* linked_list_create_iterator(linked_list* list);
|
||||
|
||||
void linked_list_delete_iterator(linked_list_iterator* it);
|
||||
|
||||
void linked_list_prev(linked_list_iterator* it);
|
||||
|
||||
void linked_list_next(linked_list_iterator* it);
|
||||
|
||||
void linked_list_free(linked_list* list, void(*delete_data)(void*));
|
||||
|
||||
#endif
|
||||
|
|
@ -5,19 +5,19 @@
|
|||
#define MAX(a, b) (((a) > (b) ? (a) : (b)))
|
||||
|
||||
// internal
|
||||
int NATIVE64 _get_height(avl_tree_node *node)
|
||||
int NATIVE64 _avl_tree_get_height(avl_tree_node *node)
|
||||
{
|
||||
return node == NULL ? -1 : node->height;
|
||||
}
|
||||
|
||||
int NATIVE64 _balance_factor(avl_tree_node *node)
|
||||
int NATIVE64 _avl_tree_get_balance_factor(avl_tree_node *node)
|
||||
{
|
||||
if (node == NULL)
|
||||
return 0;
|
||||
return _get_height(node->left) - _get_height(node->right);
|
||||
return _avl_tree_get_height(node->left) - _avl_tree_get_height(node->right);
|
||||
}
|
||||
|
||||
avl_tree_node * NATIVE64 _right_rotate(avl_tree_node *root)
|
||||
avl_tree_node * NATIVE64 _avl_tree_right_rotate(avl_tree_node *root)
|
||||
{
|
||||
avl_tree_node *left_children = root->left;
|
||||
//adjust parents first
|
||||
|
|
@ -29,12 +29,12 @@ avl_tree_node * NATIVE64 _right_rotate(avl_tree_node *root)
|
|||
root->left = root->left->right;
|
||||
left_children->right = root;
|
||||
//adjust height
|
||||
root->height = MAX(_get_height(root->left), _get_height(root->right)) + 1;
|
||||
left_children->height = MAX(_get_height(left_children->left), _get_height(left_children->right)) + 1;
|
||||
root->height = MAX(_avl_tree_get_height(root->left), _avl_tree_get_height(root->right)) + 1;
|
||||
left_children->height = MAX(_avl_tree_get_height(left_children->left), _avl_tree_get_height(left_children->right)) + 1;
|
||||
return left_children;
|
||||
}
|
||||
|
||||
avl_tree_node * NATIVE64 _left_rotate(avl_tree_node *root)
|
||||
avl_tree_node * NATIVE64 _avl_tree_left_rotate(avl_tree_node *root)
|
||||
{
|
||||
avl_tree_node *right_children = root->right;
|
||||
//adjust parents
|
||||
|
|
@ -46,41 +46,41 @@ avl_tree_node * NATIVE64 _left_rotate(avl_tree_node *root)
|
|||
root->right = root->right->left;
|
||||
right_children->left = root;
|
||||
|
||||
root->height = MAX(_get_height(root->left), _get_height(root->right)) + 1;
|
||||
right_children->height = MAX(_get_height(right_children->left), _get_height(right_children->right)) + 1;
|
||||
root->height = MAX(_avl_tree_get_height(root->left), _avl_tree_get_height(root->right)) + 1;
|
||||
right_children->height = MAX(_avl_tree_get_height(right_children->left), _avl_tree_get_height(right_children->right)) + 1;
|
||||
return right_children;
|
||||
}
|
||||
|
||||
avl_tree_node * NATIVE64 _balance_node(avl_tree_node *node)
|
||||
avl_tree_node * NATIVE64 _avl_tree_balance_node(avl_tree_node *node)
|
||||
{
|
||||
const int bf = _balance_factor(node);
|
||||
const int bf = _avl_tree_get_balance_factor(node);
|
||||
|
||||
if (bf > 1)
|
||||
{
|
||||
const int left_bf = _balance_factor(node->left);
|
||||
const int left_bf = _avl_tree_get_balance_factor(node->left);
|
||||
if (left_bf >= 0)
|
||||
//left left
|
||||
return _right_rotate(node);
|
||||
return _avl_tree_right_rotate(node);
|
||||
else
|
||||
{
|
||||
//left right
|
||||
node->left = _left_rotate(node->left);
|
||||
return _right_rotate(node);
|
||||
node->left = _avl_tree_left_rotate(node->left);
|
||||
return _avl_tree_right_rotate(node);
|
||||
}
|
||||
}
|
||||
else if (bf < -1)
|
||||
{
|
||||
const int right_bf = _balance_factor(node->right);
|
||||
const int right_bf = _avl_tree_get_balance_factor(node->right);
|
||||
if (right_bf <= 0)
|
||||
{
|
||||
// right right
|
||||
return _left_rotate(node);
|
||||
return _avl_tree_left_rotate(node);
|
||||
}
|
||||
else
|
||||
{
|
||||
// right left
|
||||
node->right = _right_rotate(node->right);
|
||||
return _left_rotate(node);
|
||||
node->right = _avl_tree_right_rotate(node->right);
|
||||
return _avl_tree_left_rotate(node);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -89,27 +89,27 @@ avl_tree_node * NATIVE64 _balance_node(avl_tree_node *node)
|
|||
}
|
||||
|
||||
|
||||
void * NATIVE64 _search(avl_tree_node *root, void *data, int(*compare)(void *, void *))
|
||||
void * NATIVE64 _avl_tree_search(avl_tree_node *root, void *data, int(*compare)(void *, void *))
|
||||
{
|
||||
if(root == NULL)
|
||||
return NULL;
|
||||
const int comp = compare(root->data, data);
|
||||
if (comp < 0)
|
||||
return _search(root->right, data, compare);
|
||||
return _avl_tree_search(root->right, data, compare);
|
||||
else if (comp == 0)
|
||||
return root->data;
|
||||
else
|
||||
return _search(root->left, data, compare);
|
||||
return _avl_tree_search(root->left, data, compare);
|
||||
}
|
||||
|
||||
void * NATIVE64 avl_search(avl_tree *root, void *data, int(*compare)(void *, void *))
|
||||
void * NATIVE64 avl_tree_search(avl_tree *root, void *data, int(*compare)(void *, void *))
|
||||
{
|
||||
if(root == NULL || data == NULL)
|
||||
return NULL;
|
||||
return _search(root->root,data,compare);
|
||||
return _avl_tree_search(root->root, data, compare);
|
||||
}
|
||||
|
||||
avl_tree_node * NATIVE64 _create()
|
||||
avl_tree_node * NATIVE64 _avl_tree_create_node()
|
||||
{
|
||||
avl_tree_node *tree = (avl_tree_node *) (kmalloc(sizeof(avl_tree_node)));
|
||||
tree->parent = NULL;
|
||||
|
|
@ -120,13 +120,13 @@ avl_tree_node * NATIVE64 _create()
|
|||
return tree;
|
||||
}
|
||||
|
||||
avl_tree_node * NATIVE64 _insert(avl_tree_node *root, void *data, int(*compare)(void *, void *), avl_tree_node *parent)
|
||||
avl_tree_node * NATIVE64 _avl_tree_insert(avl_tree_node *root, void *data, int(*compare)(void *, void *), avl_tree_node *parent)
|
||||
{
|
||||
if (data == NULL)
|
||||
return root;
|
||||
if (root == NULL)
|
||||
{
|
||||
avl_tree_node *tree = _create();
|
||||
avl_tree_node *tree = _avl_tree_create_node();
|
||||
tree->data = data;
|
||||
tree->parent = parent;
|
||||
return tree;
|
||||
|
|
@ -135,40 +135,40 @@ avl_tree_node * NATIVE64 _insert(avl_tree_node *root, void *data, int(*compare)(
|
|||
const int comp = compare(root->data, data);
|
||||
if (comp < 0)
|
||||
{
|
||||
root->right = _insert(root->right, data, compare, root);
|
||||
root->right = _avl_tree_insert(root->right, data, compare, root);
|
||||
}
|
||||
else if (comp == 0)
|
||||
return root;
|
||||
else
|
||||
root->left = _insert(root->left, data, compare, root);
|
||||
root->left = _avl_tree_insert(root->left, data, compare, root);
|
||||
|
||||
root->height = MAX(_get_height(root->left), _get_height(root->right)) + 1;
|
||||
root->height = MAX(_avl_tree_get_height(root->left), _avl_tree_get_height(root->right)) + 1;
|
||||
|
||||
return _balance_node(root);
|
||||
return _avl_tree_balance_node(root);
|
||||
}
|
||||
|
||||
void NATIVE64 avl_insert(avl_tree *tree, void *data, int (*compare)(void *, void *))
|
||||
void NATIVE64 avl_tree_insert(avl_tree *tree, void *data, int (*compare)(void *, void *))
|
||||
{
|
||||
if(tree != NULL && data != NULL && compare != NULL)
|
||||
{
|
||||
if(avl_search(tree,data,compare) == NULL)
|
||||
if(avl_tree_search(tree, data, compare) == NULL)
|
||||
{
|
||||
tree->root = _insert(tree->root, data, compare, NULL);
|
||||
tree->root = _avl_tree_insert(tree->root, data, compare, NULL);
|
||||
tree->size++;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
avl_tree_node * NATIVE64 _delete(avl_tree_node *root, void *data, int (*compare)(void *, void *))
|
||||
avl_tree_node * NATIVE64 _avl_tree_delete(avl_tree_node *root, void *data, int (*compare)(void *, void *))
|
||||
{
|
||||
if (root == NULL || data == NULL)
|
||||
return root;
|
||||
const int comp = compare(root->data, data);
|
||||
if (comp < 0)
|
||||
root->right = _delete(root->right, data, compare);
|
||||
root->right = _avl_tree_delete(root->right, data, compare);
|
||||
else if(comp > 0)
|
||||
root->left = _delete(root->left, data, compare);
|
||||
root->left = _avl_tree_delete(root->left, data, compare);
|
||||
else
|
||||
{
|
||||
// node with only one child or no child
|
||||
|
|
@ -204,52 +204,52 @@ avl_tree_node * NATIVE64 _delete(avl_tree_node *root, void *data, int (*compare)
|
|||
root->data = temp->data;
|
||||
|
||||
// Delete the inorder successor
|
||||
root->right = _delete(root->right, temp->data, compare);
|
||||
root->right = _avl_tree_delete(root->right, temp->data, compare);
|
||||
}
|
||||
}
|
||||
if (root == NULL)
|
||||
return root;
|
||||
root->height = MAX(_get_height(root->left), _get_height(root->right)) + 1;
|
||||
root = _balance_node(root);
|
||||
root->height = MAX(_avl_tree_get_height(root->left), _avl_tree_get_height(root->right)) + 1;
|
||||
root = _avl_tree_balance_node(root);
|
||||
return root;
|
||||
}
|
||||
|
||||
void NATIVE64 avl_delete(avl_tree *tree, void *data, int (*compare)(void *, void *))
|
||||
void NATIVE64 avl_tree_delete(avl_tree *tree, void *data, int (*compare)(void *, void *))
|
||||
{
|
||||
if(tree != NULL && data != NULL && compare != NULL && tree->size != 0)
|
||||
{
|
||||
if(avl_search(tree,data,compare) != NULL)
|
||||
if(avl_tree_search(tree, data, compare) != NULL)
|
||||
{
|
||||
tree->root = _delete(tree->root, data, compare);
|
||||
tree->root = _avl_tree_delete(tree->root, data, compare);
|
||||
tree->size--;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void NATIVE64 _free(avl_tree_node * root, void (*delete_data)(void*))
|
||||
void NATIVE64 _avl_tree_free(avl_tree_node *root, void (*delete_data)(void *))
|
||||
{
|
||||
if(root != NULL)
|
||||
{
|
||||
_free(root->left, delete_data);
|
||||
_free(root->right, delete_data);
|
||||
_avl_tree_free(root->left, delete_data);
|
||||
_avl_tree_free(root->right, delete_data);
|
||||
if (delete_data != NULL)
|
||||
delete_data(root->data);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void NATIVE64 avl_free(avl_tree *tree, void (*delete_data)(void*))
|
||||
void NATIVE64 avl_tree_free(avl_tree *tree, void (*delete_data)(void *))
|
||||
{
|
||||
if(tree != NULL)
|
||||
{
|
||||
_free(tree->root, delete_data);
|
||||
_avl_tree_free(tree->root, delete_data);
|
||||
kfree(tree);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
avl_tree * NATIVE64 avl_create()
|
||||
avl_tree * NATIVE64 avl_tree_create()
|
||||
{
|
||||
avl_tree* new_tree = kmalloc(sizeof(avl_tree));
|
||||
new_tree->root = NULL;
|
||||
|
|
@ -260,7 +260,7 @@ avl_tree * NATIVE64 avl_create()
|
|||
|
||||
//iterator
|
||||
|
||||
avl_tree_node * NATIVE64 _smallest(avl_tree_node *root)
|
||||
avl_tree_node * NATIVE64 _avl_tree_smallest(avl_tree_node *root)
|
||||
{
|
||||
if (root == NULL)
|
||||
return NULL;
|
||||
|
|
@ -269,16 +269,16 @@ avl_tree_node * NATIVE64 _smallest(avl_tree_node *root)
|
|||
return root;
|
||||
}
|
||||
|
||||
avl_tree_iterator* NATIVE64 avl_iterator(avl_tree* tree)
|
||||
avl_tree_iterator* NATIVE64 avl_tree_create_iterator(avl_tree *tree)
|
||||
{
|
||||
if(tree == NULL)
|
||||
return NULL;
|
||||
avl_tree_iterator* it = (avl_tree_iterator*)kmalloc(sizeof(avl_tree_iterator));
|
||||
it->current = _smallest(tree->root);
|
||||
it->current = _avl_tree_smallest(tree->root);
|
||||
return it;
|
||||
}
|
||||
|
||||
void NATIVE64 avl_next(avl_tree_iterator *it)
|
||||
void NATIVE64 avl_tree_next(avl_tree_iterator *it)
|
||||
{
|
||||
if (it == NULL || it->current == NULL)
|
||||
return;
|
||||
|
|
@ -309,7 +309,7 @@ void NATIVE64 avl_next(avl_tree_iterator *it)
|
|||
}
|
||||
}
|
||||
|
||||
void NATIVE64 avl_prev(avl_tree_iterator *it)
|
||||
void NATIVE64 avl_tree_prev(avl_tree_iterator *it)
|
||||
{
|
||||
if (it == NULL || it->current == NULL)
|
||||
return;
|
||||
|
|
@ -339,19 +339,19 @@ void NATIVE64 avl_prev(avl_tree_iterator *it)
|
|||
|
||||
// TESTS
|
||||
|
||||
int NATIVE64 avl_test_calculate_height(avl_tree_node * tree)
|
||||
int NATIVE64 avl_tree_test_calculate_height(avl_tree_node *tree)
|
||||
{
|
||||
if (tree == NULL)
|
||||
return -1;
|
||||
return MAX(avl_test_calculate_height(tree->left), avl_test_calculate_height(tree->right)) + 1;
|
||||
return MAX(avl_tree_test_calculate_height(tree->left), avl_tree_test_calculate_height(tree->right)) + 1;
|
||||
}
|
||||
|
||||
int NATIVE64 avl_test(avl_tree_node *tree)
|
||||
int NATIVE64 avl_tree_test(avl_tree_node *tree)
|
||||
{
|
||||
if (tree == NULL)
|
||||
return 1;
|
||||
if (_balance_factor(tree) < -1 || _balance_factor(tree) > 1 || avl_test_calculate_height(tree) != tree->height)
|
||||
if (_avl_tree_get_balance_factor(tree) < -1 || _avl_tree_get_balance_factor(tree) > 1 || avl_tree_test_calculate_height(tree) != tree->height)
|
||||
return 0;
|
||||
return avl_test(tree->left) && avl_test(tree->right);
|
||||
return avl_tree_test(tree->left) && avl_tree_test(tree->right);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,24 +22,24 @@ typedef struct __attribute__((packed))
|
|||
avl_tree_node * current;
|
||||
} avl_tree_iterator;
|
||||
|
||||
void NATIVE64 ert(avl_tree *tree, void *data, int (*compare)(void *, void *));
|
||||
void NATIVE64 avl_tree_insert(avl_tree *tree, void *data, int (*compare)(void *, void *));
|
||||
|
||||
void NATIVE64 avl_delete(avl_tree *tree, void *data, int (*compare)(void *, void *));
|
||||
void NATIVE64 avl_tree_delete(avl_tree *tree, void *data, int (*compare)(void *, void *));
|
||||
|
||||
void NATIVE64 avl_free(avl_tree *tree, void (*delete_data)(void*));
|
||||
void NATIVE64 avl_tree_free(avl_tree *tree, void (*delete_data)(void *));
|
||||
|
||||
void NATIVE64 *avl_search(avl_tree *tree, void *data, int(*compare)(void *, void *));
|
||||
void NATIVE64 *avl_tree_search(avl_tree *tree, void *data, int(*compare)(void *, void *));
|
||||
|
||||
avl_tree * NATIVE64 avl_create();
|
||||
avl_tree * NATIVE64 avl_tree_create();
|
||||
|
||||
avl_tree_iterator* NATIVE64 avl_iterator(avl_tree* tree);
|
||||
avl_tree_iterator* NATIVE64 avl_tree_create_iterator(avl_tree *tree);
|
||||
|
||||
void NATIVE64 avl_next(avl_tree_iterator *it);
|
||||
void NATIVE64 avl_tree_next(avl_tree_iterator *it);
|
||||
|
||||
void NATIVE64 avl_prev(avl_tree_iterator *it);
|
||||
void NATIVE64 avl_tree_prev(avl_tree_iterator *it);
|
||||
|
||||
int NATIVE64 avl_test_calculate_height(avl_tree_node * tree);
|
||||
int NATIVE64 avl_tree_test_calculate_height(avl_tree_node *tree);
|
||||
|
||||
int NATIVE64 avl_test(avl_tree_node *tree);
|
||||
int NATIVE64 avl_tree_test(avl_tree_node *tree);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,9 +1,9 @@
|
|||
#include <malloc.h>
|
||||
#include "mm.h"
|
||||
#include "linked_list.h"
|
||||
|
||||
//internal
|
||||
|
||||
linked_list_node* _get_by_index(linked_list_node *head, int index)
|
||||
linked_list_node* NATIVE64 _linked_list_get_by_index(linked_list_node *head, int index)
|
||||
{
|
||||
while(1)
|
||||
{
|
||||
|
|
@ -14,7 +14,7 @@ linked_list_node* _get_by_index(linked_list_node *head, int index)
|
|||
}
|
||||
}
|
||||
|
||||
linked_list_node* _get_by_element(linked_list_node* head, void* data, int(*compare)(int*,int*))
|
||||
linked_list_node* NATIVE64 _linked_list_get_by_element(linked_list_node *head, void *data, int(*compare)(int *, int *))
|
||||
{
|
||||
while(1)
|
||||
{
|
||||
|
|
@ -25,16 +25,16 @@ linked_list_node* _get_by_element(linked_list_node* head, void* data, int(*compa
|
|||
}
|
||||
|
||||
|
||||
linked_list_node* _create()
|
||||
linked_list_node* NATIVE64 _linked_list_create_node()
|
||||
{
|
||||
linked_list_node* node = (linked_list_node*)malloc(sizeof(linked_list_node));
|
||||
linked_list_node* node = (linked_list_node*)kmalloc(sizeof(linked_list_node));
|
||||
node->data = NULL;
|
||||
node->prev = NULL;
|
||||
node->next = NULL;
|
||||
return node;
|
||||
}
|
||||
|
||||
void _delete(linked_list* list, linked_list_node* node)
|
||||
void NATIVE64 _linked_list_delete_node(linked_list *list, linked_list_node *node)
|
||||
{
|
||||
if(list != NULL && node != NULL)
|
||||
{
|
||||
|
|
@ -53,22 +53,22 @@ void _delete(linked_list* list, linked_list_node* node)
|
|||
if (node->next != NULL)
|
||||
node->next->prev = node->prev;
|
||||
list->size--;
|
||||
free(node);
|
||||
kfree(node);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
//interface
|
||||
linked_list* linked_list_create()
|
||||
linked_list* NATIVE64 linked_list_create()
|
||||
{
|
||||
linked_list* list = (linked_list*)malloc(sizeof(linked_list));
|
||||
linked_list* list = (linked_list*)kmalloc(sizeof(linked_list));
|
||||
list->size = 0;
|
||||
list->tail = NULL;
|
||||
list->head = NULL;
|
||||
return list;
|
||||
}
|
||||
|
||||
void linked_list_free(linked_list* list, void(*delete_data)(void*))
|
||||
void NATIVE64 linked_list_free(linked_list* list, void(*delete_data)(void*))
|
||||
{
|
||||
if(list == NULL)
|
||||
return;
|
||||
|
|
@ -79,17 +79,17 @@ void linked_list_free(linked_list* list, void(*delete_data)(void*))
|
|||
head = head->next;
|
||||
if(delete_data != NULL)
|
||||
delete_data(temp->data);
|
||||
free(temp);
|
||||
kfree(temp);
|
||||
}
|
||||
free(list);
|
||||
kfree(list);
|
||||
return;
|
||||
}
|
||||
|
||||
void linked_list_insert(linked_list * list, void* data)
|
||||
void NATIVE64 linked_list_insert(linked_list * list, void* data)
|
||||
{
|
||||
if(list == NULL)
|
||||
return;
|
||||
linked_list_node* node = _create();
|
||||
linked_list_node* node = _linked_list_create_node();
|
||||
node->data = data;
|
||||
if(list->tail != NULL)
|
||||
{
|
||||
|
|
@ -109,11 +109,11 @@ void linked_list_insert(linked_list * list, void* data)
|
|||
return;
|
||||
}
|
||||
|
||||
void linked_list_insert_at(linked_list * list, int position, void* data)
|
||||
void NATIVE64 linked_list_insert_at(linked_list * list, int position, void* data)
|
||||
{
|
||||
if(list != NULL && position >= 0 && position <= list->size)
|
||||
{
|
||||
linked_list_node* target = _get_by_index(list->head,position);
|
||||
linked_list_node* target = _linked_list_get_by_index(list->head, position);
|
||||
if(target == NULL)
|
||||
{
|
||||
//tail case
|
||||
|
|
@ -122,7 +122,7 @@ void linked_list_insert_at(linked_list * list, int position, void* data)
|
|||
else
|
||||
{
|
||||
//head or normal case
|
||||
linked_list_node* node = _create();
|
||||
linked_list_node* node = _linked_list_create_node();
|
||||
node->data = data;
|
||||
if (list->head == target) {
|
||||
list->head = node;
|
||||
|
|
@ -138,55 +138,55 @@ void linked_list_insert_at(linked_list * list, int position, void* data)
|
|||
return;
|
||||
}
|
||||
|
||||
void* linked_list_get(linked_list * list, int index)
|
||||
void* NATIVE64 linked_list_get(linked_list * list, int index)
|
||||
{
|
||||
if(list == NULL || list->head == NULL || index < 0 || list->size <= index)
|
||||
return NULL;
|
||||
linked_list_node* node = _get_by_index(list->head, index);
|
||||
linked_list_node* node = _linked_list_get_by_index(list->head, index);
|
||||
return node == NULL ? NULL : node->data;
|
||||
}
|
||||
|
||||
void linked_list_delete(linked_list * list, void* data, int(*compare)(int*,int*))
|
||||
void NATIVE64 linked_list_delete(linked_list * list, void* data, int(*compare)(int*,int*))
|
||||
{
|
||||
if(list == NULL || list->head == NULL || compare == NULL)
|
||||
return;
|
||||
linked_list_node* node = _get_by_element(list->head,data,compare);
|
||||
_delete(list,node);
|
||||
linked_list_node* node = _linked_list_get_by_element(list->head, data, compare);
|
||||
_linked_list_delete_node(list, node);
|
||||
return;
|
||||
}
|
||||
|
||||
void linked_list_delete_at(linked_list * list, int index)
|
||||
void NATIVE64 linked_list_delete_at(linked_list * list, int index)
|
||||
{
|
||||
if(list == NULL || list->head == NULL || index < 0 || list->size <= index)
|
||||
return;
|
||||
linked_list_node* node = _get_by_index(list->head, index);
|
||||
_delete(list,node);
|
||||
linked_list_node* node = _linked_list_get_by_index(list->head, index);
|
||||
_linked_list_delete_node(list, node);
|
||||
return;
|
||||
}
|
||||
|
||||
// iterator
|
||||
linked_list_iterator* linked_list_create_iterator(linked_list* list)
|
||||
linked_list_iterator* NATIVE64 linked_list_create_iterator(linked_list* list)
|
||||
{
|
||||
if(list == NULL)
|
||||
return NULL;
|
||||
linked_list_iterator* it = (linked_list_iterator*)malloc(sizeof(linked_list_iterator));
|
||||
linked_list_iterator* it = (linked_list_iterator*)kmalloc(sizeof(linked_list_iterator));
|
||||
it->current = list->head;
|
||||
return it;
|
||||
}
|
||||
|
||||
void linked_list_delete_iterator(linked_list_iterator* it)
|
||||
void NATIVE64 linked_list_delete_iterator(linked_list_iterator* it)
|
||||
{
|
||||
free(it);
|
||||
kfree(it);
|
||||
return;
|
||||
}
|
||||
|
||||
void linked_list_prev(linked_list_iterator* it)
|
||||
void NATIVE64 linked_list_prev(linked_list_iterator* it)
|
||||
{
|
||||
it->current = it->current->prev;
|
||||
return;
|
||||
}
|
||||
|
||||
void linked_list_next(linked_list_iterator* it)
|
||||
void NATIVE64 linked_list_next(linked_list_iterator* it)
|
||||
{
|
||||
it->current = it->current->next;
|
||||
return;
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#ifndef _LINKED_LIST_H_
|
||||
#define _LINKED_LIST_H_
|
||||
typedef struct _linked_list_node
|
||||
{
|
||||
struct _linked_list_node* prev;
|
||||
struct _linked_list_node* next;
|
||||
void* data;
|
||||
} linked_list_node;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
linked_list_node* head;
|
||||
linked_list_node* tail;
|
||||
int size;
|
||||
} linked_list;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
linked_list_node* current;
|
||||
} linked_list_iterator;
|
||||
|
||||
linked_list* NATIVE64 linked_list_create();
|
||||
|
||||
void NATIVE64 linked_list_insert(linked_list * list, void* data);
|
||||
|
||||
void NATIVE64 linked_list_insert_at(linked_list * list, int position, void* data);
|
||||
|
||||
void* NATIVE64 linked_list_get(linked_list * list, int index);
|
||||
|
||||
void NATIVE64 linked_list_delete(linked_list * list, void* data, int(*compare)(int*,int*));
|
||||
|
||||
void NATIVE64 linked_list_delete_at(linked_list * list, int index);
|
||||
|
||||
linked_list_iterator* NATIVE64 linked_list_create_iterator(linked_list* list);
|
||||
|
||||
void NATIVE64 linked_list_delete_iterator(linked_list_iterator* it);
|
||||
|
||||
void NATIVE64 linked_list_prev(linked_list_iterator* it);
|
||||
|
||||
void NATIVE64 linked_list_next(linked_list_iterator* it);
|
||||
|
||||
void NATIVE64 linked_list_free(linked_list* list, void(*delete_data)(void*));
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue