/** get item and remove it from any position
*/
void* list_remove (linked_list* _this, int position) {
// list is empty
if (_this->size == 0) {
//NODE_DBG("LinkedList#_remove: The list is empty.");
return NULL;
} else if (position >= _this->size) {
// out of bound
//NODE_DBG("LinkedList#_remove: Index out of bound");
return NULL;
}
// remove from head
if (position == 0) {
return list_remove_first(_this);
} else if (position+1 == _this->size) {
// remove from tail
return list_remove_last(_this);
} else {
node* n = _this->head;
node* prev;
node* next;
int i = 0;
void* item;
// loop until position
while (i < position) {
n = n->next;
i++;
}
item = n->item;
// remove node from list
prev = n->prev;
next = n->next;
prev->next = next;
next->prev = prev;
os_free(n);
_this->size--;
return item ;
}
}
int main()
{
list* list1 = list_create();
list* list2 = list_create();
list* list3 = list_create();
int data[] = {1, 2, 3, 4, 5};
char* strings[] = {"a", "b", "c", "d", "e", "f"};
int data_size = 5;
for(int i = 0; i < data_size; i++) {
list_append(list1, &data[i]);
}
int string_size = 6;
for(int i = 0; i < string_size; i++) {
list_append(list2, strings[i]);
}
iterator* iter1 = iter_create(list1);
printf("Data List Print Test....\n");
printf("Data List: ");
while(!iter_at_end(iter1)) {
node* n = iter_get(iter1);
int* val = n->data;
printf("%d ", *val);
iter_advance(iter1);
}
printf("\n");
printf("Removing 2nd Element From Data\n");
iter1 = iter_create(list1);
iter_advance(iter1);
iter_remove(iter1);
printf("Data List: ");
while(!iter_at_end(iter1)) {
node* n = iter_get(iter1);
int* val = n->data;
printf("%d ", *val);
iter_advance(iter1);
}
printf("\n");
printf("\n");
printf("String List Print Test.......\n");
iterator* iter2 = iter_create(list2);
printf("Strings List: ");
while(!iter_at_end(iter2)) {
node* n = iter_get(iter2);
char* val = n->data;
printf("%s ", val);
iter_advance(iter2);
}
printf("\n");
list_remove_last(list2);
iter2 = iter_create(list2);
printf("Removing Last Element from String List\n");
printf("Strings List: ");
while(!iter_at_end(iter2)) {
node* n = iter_get(iter2);
char* val = n->data;
printf("%s ", val);
iter_advance(iter2);
}
printf("\n");
printf("\n");
printf("Done Printing\n");
return 0;
}
void test_list(void)
{
int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
list me = list_init(sizeof(int));
assert(me);
assert(list_size(me) == 0);
assert(list_is_empty(me));
for (int i = 0; i < 10; i++) {
list_add_first(me, &val[i]);
assert(list_size(me) == i + 1);
int get = 0;
list_get_first(&get, me);
assert(get == val[i]);
}
assert(list_size(me) == 10);
assert(!list_is_empty(me));
int get_arr[10] = {0};
list_copy_to_array(get_arr, me);
for (int i = 0; i < 10; i++) {
int get = 0;
list_get_at(&get, me, i);
assert(get == val[9 - i]);
assert(get_arr[i] == val[9 - i]);
}
for (int i = 0; i < 7; i++) {
list_remove_last(me);
}
int trimmed[5] = {0};
list_copy_to_array(trimmed, me);
assert(list_size(me) == 3);
for (int i = 0; i < 3; i++) {
assert(10 - i == trimmed[i]);
}
int add = 3;
list_add_last(me, &add);
add = -1;
list_add_at(me, 1, &add);
add = -2;
list_add_last(me, &add);
assert(list_size(me) == 6);
int get = 0xdeadbeef;
list_get_first(&get, me);
assert(get == 10);
get = 0xdeadbeef;
list_get_at(&get, me, 0);
assert(get == 10);
list_get_at(&get, me, 1);
assert(get == -1);
list_get_at(&get, me, 2);
assert(get == 9);
list_get_at(&get, me, 3);
assert(get == 8);
list_get_at(&get, me, 4);
assert(get == 3);
list_get_at(&get, me, 5);
assert(get == -2);
get = 0xdeadbeef;
list_get_last(&get, me);
assert(get == -2);
list_remove_first(me);
list_remove_at(me, 2);
list_remove_last(me);
assert(list_size(me) == 3);
get = 345;
list_get_first(&get, me);
assert(get == -1);
list_get_at(&get, me, 1);
assert(get == 9);
list_get_last(&get, me);
assert(get == 3);
int set = 12;
list_set_first(me, &set);
set = 13;
list_set_at(me, 1, &set);
set = 14;
list_set_last(me, &set);
int arr[3] = {0};
list_copy_to_array(arr, me);
assert(arr[0] == 12);
assert(arr[1] == 13);
assert(arr[2] == 14);
set = -5;
list_set_at(me, 0, &set);
set = -6;
list_set_at(me, 1, &set);
set = -7;
list_set_at(me, 2, &set);
list_copy_to_array(arr, me);
assert(arr[0] == -5);
assert(arr[1] == -6);
assert(arr[2] == -7);
assert(list_set_at(me, 4, &set) == -EINVAL);
assert(list_get_at(&set, me, 4) == -EINVAL);
assert(list_remove_at(me, 4) == -EINVAL);
assert(list_add_at(me, 5, &set) == -EINVAL);
assert(list_set_at(me, -1, &set) == -EINVAL);
assert(list_get_at(&set, me, -1) == -EINVAL);
assert(list_remove_at(me, -1) == -EINVAL);
assert(list_add_at(me, -1, &set) == -EINVAL);
list_clear(me);
assert(list_size(me) == 0);
assert(list_is_empty(me));
assert(list_remove_first(me) == -EINVAL);
assert(list_remove_last(me) == -EINVAL);
me = list_destroy(me);
assert(!me);
}
hany list_pop(hlist_t list,InvokeTickDeclare){
hany v = list_last(list, InvokeTickArg);
list_remove_last(list, InvokeTickArg);
return v;
}
void
slipS_collapse(slip_Stack* stack){
void* p = list_remove_last(GET_LIST_NODE(stack->block_head));
free(p);
stack->stack_size -= BLOCK_SIZE;
} /* 塌缩栈, 减少一个Block, 建议在空余空间大于BLOCK_SIZE*2的时候塌缩 */
