void testDelete (void){
printf("Testing delete!\n");
List l = setUpList();
assert(listLength(l) == START_LENGTH);
//Delete the first element of the list
deleteElement(l, 0);
assert(getElement(l, 0) == 8);
assert(listLength(l) == START_LENGTH - 1);
//Delete an element from the middle of the list
deleteElement(l, 1);
assert(getElement(l, 1) == 4);
assert(listLength(l) == START_LENGTH - 2);
//Delete an element from the end of the list
deleteElement(l, listLength(l) - 1);
assert(getElement(l, 0) == 8);
assert(listLength(l) == START_LENGTH - 3);
disposeList(l);
printf("Deleting tests passed!\n");
}
bool
Device::destroyMixer() {
bool ret = true;
debugOutput(DEBUG_LEVEL_VERBOSE, "destroy mixer...\n");
if (m_MixerContainer == NULL) {
debugOutput(DEBUG_LEVEL_VERBOSE, "no mixer to destroy...\n");
} else
if (!deleteElement(m_MixerContainer)) {
debugError("Mixer present but not registered to the avdevice\n");
ret = false;
} else {
// remove and delete (as in free) child control elements
m_MixerContainer->clearElements(true);
delete m_MixerContainer;
m_MixerContainer = NULL;
}
// remove control container
if (m_ControlContainer == NULL) {
debugOutput(DEBUG_LEVEL_VERBOSE, "no controls to destroy...\n");
} else
if (!deleteElement(m_ControlContainer)) {
debugError("Controls present but not registered to the avdevice\n");
ret = false;
} else {
// remove and delete (as in free) child control elements
m_ControlContainer->clearElements(true);
delete m_ControlContainer;
m_ControlContainer = NULL;
}
return false;
}
struct node *deleteElement(struct node *tree,int val){
struct node *ptr;
if(tree==NULL)
printf("\n %d is not present in the tree",val);
else if(val<tree->data)
deleteElement(tree->left,val);
else if(val<tree->data)
deleteElement(tree->right,val);
else
{
if(tree->left&&tree->right){
ptr=findLargestElement(tree->left);
tree->data=ptr->data;
deleteElement(tree->left,ptr->data);
}
else{
ptr=tree;
if(tree->left==NULL&&tree->right==NULL)
tree=NULL;
else if(tree->left!=NULL)
tree=tree->left;
else
tree=tree->right;
free(ptr);
}
}
return tree;
}
void deleteElement(Tree *&t, int value)
{
if (t == NULL)
return;
if (value < t->value)
deleteElement(t->left, value);
else
if (value > t->value)
deleteElement(t->right, value);
else
if (t->left == NULL && t->right == NULL)
{
delete t;
t = NULL;
}
else
if (t->left == NULL)
{
t = t->right;
delete t->right;
t->right = NULL;
}
else
if (t->right == NULL)
{
t = t->left;
delete t->left;
t->left = NULL;
}
else
t->value = deleteMin(t->right);
}
static void
cancelOperation (Element *operationElement) {
OperationEntry *operation = getElementItem(operationElement);
if (operation->active) {
operation->cancel = 1;
} else {
FunctionEntry *function = operation->function;
int isFirstOperation = operationElement == getActiveOperationElement(function);
if (isFirstOperation) {
if (!operation->finished) {
if (operation->function->methods->cancelOperation) {
operation->function->methods->cancelOperation(operation);
}
}
}
if (getQueueSize(function->operations) == 1) {
deleteElement(findElementWithItem(getFunctionQueue(0), function));
} else {
deleteElement(operationElement);
if (isFirstOperation) {
operationElement = getActiveOperationElement(function);
operation = getElementItem(operationElement);
if (!operation->finished) startOperation(operation);
}
}
}
}
int main(){
int testcase,no_freinds,priority;
node head;
head = createNode();
addNode(head,1);
addNode(head,2);
addNode(head,3);
addNode(head,4);
deleteElement(head);
deleteElement(head);
printList(head);
return 0;
}
int FEM_Adapt::vertex_remove_help(int e1, int e2, int n1, int n2, int e1_n1,
int e1_n2, int e1_n3, int n3, int edge1,
int e1nbr)
{
int e3 = theMesh->e2e_getNbr(e1, get_edge_index(e1_n1, e1_n3));
int e4 = e1nbr;
int e5=-1, e6=-1, n4=-1, n5=-1;
if (e2 > -1) {
int e2_n1, e2_n2, e2_n3;
e2_n1 = find_local_node_index(e2, n1);
e2_n2 = find_local_node_index(e2, n2);
e2_n3 = 3 - e2_n1 - e2_n2;
e5 = theMesh->e2e_getNbr(e2, get_edge_index(e2_n1, e2_n3));
e6 = theMesh->e2e_getNbr(e2, get_edge_index(e2_n2, e2_n3));
n4 = theMesh->e2n_getNode(e2, e2_n3);
}
// find n5
int *nbrNodes, nnsize;
theMesh->n2n_getAll(n1, &nbrNodes, &nnsize);
for (int i=0; i<nnsize; i++) {
if ((nbrNodes[i] != n2) && (nbrNodes[i] != n3) && (nbrNodes[i] != n4)) {
n5 = nbrNodes[i];
break;
}
}
// Element-to-node updates
theMesh->e2n_replace(e3, n1, n2);
theMesh->e2n_replace(e5, n1, n2);
// Element-to-element updates
theMesh->e2e_replace(e3, e1, e4);
theMesh->e2e_replace(e5, e2, e6);
theMesh->e2e_replace(e4, e1, e3);
theMesh->e2e_replace(e6, e2, e5);
// Node-to-node updates
theMesh->n2n_remove(n3, n1);
theMesh->n2n_remove(n4, n1);
theMesh->n2n_replace(n2, n1, n5);
theMesh->n2n_replace(n5, n1, n2);
// Node-to-element updates
theMesh->n2e_replace(n2, e1, e3);
theMesh->n2e_replace(n2, e2, e5);
theMesh->n2e_remove(n3, e1);
theMesh->n2e_remove(n4, e2);
deleteNode(n1);
deleteElement(e1);
deleteElement(e2);
return 1;
}
/*
ѕротестированные ситуации: добавление в пустой список, добавление элемента меньшего head, добавление в список, содержащий только
head, вывод на экран всех случаев, удаление элемента, содержащегос¤ в списке, и нет.
*/
int main()
{
setlocale(LC_ALL, "Russian");
List list = createList();
char option = '4';
printf("¬ыберите операцию:\n 0 - выход\n 1 - добавить значение в сортированный список\n 2 - удалить значение из списка\n 3 - распечатать список\n");
while (option != '0')
{
scanf("%c", &option);
if (option == '1')
{
int value = 0;
printf("¬ведите значение, которое вы хотите добавить.\n");
scanf("%d", &value);
addElement(&list, value);
}
if (option == '2')
{
int value = 0;
printf("¬ведите значение, которое вы хотите удалить.\n");
scanf("%d", &value);
deleteElement(&list, value);
}
if (option == '3')
printList(list);
}
deleteList(&list);
return 0;
}
bool deleteElement(List & list, ListEl * currentElement, int deletedNumber)
{
if (deletedNumber == list.first->number)
{
if (list.first == list.last)
{
delete currentElement;
currentElement = nullptr;
constrList(list);
}
else
{
list.first = currentElement->next;
delete currentElement;
currentElement = nullptr;
}
return 0;
}
if (currentElement->next != nullptr)
{
if (currentElement -> next -> number == deletedNumber)
{
if (currentElement -> next == list.last)
{
list.last = currentElement;
}
ListEl * tmp = currentElement -> next -> next;
delete currentElement -> next;
currentElement -> next = tmp;
return 0;
}
return deleteElement(list, currentElement -> next, deletedNumber);
}
return 1;
}
void TableView::keyPressEvent(QKeyEvent *event)
{
if (event->key() == Qt::Key_Delete)
{
deleteElement();
}
}
EntryValue ArrayEntryType::internalizeValue(std::string& key, ComplexData& externalRepresentation, EntryValue currentInteralValue) {
// TODO: Argument 'key' appears unused.
ArrayData& externalArrayData = (ArrayData&)externalRepresentation;
EntryValue eValue = currentInteralValue;
ArrayEntryData* internalArray = (ArrayEntryData*) currentInteralValue.ptr;
if(internalArray == NULL) {
internalArray = (ArrayEntryData*)malloc(sizeof(ArrayEntryData));
internalArray->length = 0;
internalArray->array = NULL;
eValue.ptr = internalArray;
}
if(internalArray->length==externalArrayData.size()) {
for(int i = 0; i<internalArray->length; ++i) {
deleteElement(internalArray->array[i]);
internalArray->array[i] = copyElement(externalArrayData._get(i));
}
}
else {
if(internalArray->array != NULL)
free(internalArray->array);
internalArray->length = externalArrayData.size();
if(internalArray->length == 0)
internalArray->array = NULL;
else
internalArray->array = (EntryValue*)malloc(externalArrayData.size()*sizeof(EntryValue));
for (int i = 0; i < internalArray->length; ++i) {
internalArray->array[i] = copyElement(externalArrayData._get(i));
}
}
return eValue;
}
bool connectionDeleteTaskMap(conn_type type, map_id id)
{
uint16 match_index;
if (findMatchInMap(type, id, &match_index))
{
/* Found entry */
if (mapSize == 1)
{
/* Only one element in the array so delete it */
free(map);
map = 0;
mapSize = 0;
}
else
{
/* Remove element from the array */
deleteElement(match_index);
}
return TRUE;
}
else
/* Entry not in map so not delelted */
return FALSE;
}
bool detectCollision(jrPlanet *pFirstPlanet, jrPlanet *pSecondPlanet, float afDistance[3]) {
float afSimplifiedDistance[3];
vecInit(afSimplifiedDistance); //we can simplify the distance to not include negative values
for (int i = 0; i < 3; i++) {
if (afDistance[i] < 0.0f) {
afSimplifiedDistance[i]= afDistance[i] * -1;
}
else {
afSimplifiedDistance[i] = afDistance[i];
}
}
bool bCollideX = afSimplifiedDistance[0] < pFirstPlanet->fSize;
bool bCollideY = afSimplifiedDistance[1] < pFirstPlanet->fSize;
bool bCollideZ = afSimplifiedDistance[2] < pFirstPlanet->fSize;
if (bCollideX && bCollideY && bCollideZ) {
pFirstPlanet->fSize = pFirstPlanet->fSize + (pSecondPlanet->fSize / 2);
pFirstPlanet->fMass = pFirstPlanet->fMass + (pSecondPlanet->fMass / 2);
if (pSecondPlanet == g_pFollowing) {
resetFollow();
}
deleteElement(pSecondPlanet);
pSecondPlanet = 0;
return true;
}
return false;
}
FFADODevice::~FFADODevice()
{
if (!deleteElement(&getConfigRom())) {
debugWarning("failed to remove ConfigRom from Control::Container\n");
}
// remove generic controls if present
if(m_genericContainer) {
if (!deleteElement(m_genericContainer)) {
debugError("Generic controls present but not registered to the avdevice\n");
}
// remove and delete (as in free) child control elements
m_genericContainer->clearElements(true);
delete m_genericContainer;
}
}
void CMapCmdElementDelete::redo()
{
QStringList groupList = properties->groupList();
for (QStringList::Iterator it = groupList.begin(); it != groupList.end(); ++it)
{
if (*it == "<default>") continue;
CMapElement *element = manager->findElement(properties->group(*it));
if (!element) properties->deleteGroup(*it);
}
for (QStringList::Iterator it = groupList.begin(); it != groupList.end(); ++it)
{
if (*it == "<default>") continue;
// ignore elements that already got deleted - this is because deletion of multiple rooms can include the same exit twice
// also mark them as ignored, so that undo doesn't create these twice
KConfigGroup group = properties->group(*it);
CMapElement *element = manager->findElement(group);
if (!element) {
group.writeEntry("Deleted", "1");
continue;
}
for (CMapPluginBase *plugin = manager->getPluginList()->first(); plugin!=0; plugin = manager->getPluginList()->next())
plugin->beforeElementDeleted(element);
deleteElement(properties->group(*it),m_delOpsite);
}
}
//deleteElementI() removes the ith element of the list
//list : a pointer to the LinkedList to delete the data from
//i : the data will be deleted from the ith element of the list
//returns : a status code as defined in linklist.h
int deleteElementI(LinkedList list, int i){
ListElement* toDelete = iterate(list,i);
if(toDelete==NULL) return LLOVERRUN;
if(toDelete->prevElement==NULL) list->begining = toDelete->nextElement;
if(toDelete->nextElement==NULL) list->end = toDelete->prevElement;
return deleteElement(toDelete);
}
int main(void)
{
element* html = readDocument();
printDocument(html);
deleteElement(html);
return 0;
}
int main()
{
int num, d;
printf("enter number of elements to insert: ");
scanf("%d", &num);
while(num > 0){
printf("Enter Data: ");
scanf("%d", &d);
insertElement(d, 1);
num--;
}
printf("count is %d\n", countElements(head));
deleteElement(1);
deleteElement(3);
printf("count is %d\n", countElements(head));
return 0;
}
//deleteLastElement() removes the last element of the list
//list : a pointer to the LinkedList to delete the data from
//returns : a status code as defined in linklist.h
int deleteLastElement(LinkedList list) {
ListElement* toDelete = list->end;
if(toDelete == NULL) return LLOVERRUN;
list->end = list->end->prevElement;
if(list->end!=NULL) list->end->nextElement = NULL;
if(list->end==NULL) list->begining = NULL;
return deleteElement(toDelete);;
}
bool medTree::deleteElement(myLL* node,int num2del)
{
if (node == NULL)
{
printf("Element not found \n");
return false;
}
else if (node->value == num2del)
{
printf("Node with num 2 be deleted found \n");
deleteNode(node);
return true;
}
else if (node->value > num2del)
return (deleteElement(node->left,num2del)); //num to search is less than root..so check left sub-tree.
else if (node->value < num2del)
return (deleteElement(node->right,num2del));//num to search is more than root..so check right sub tree.
}
void LinkedList::deleteList()
{
int length = this->length();
while(length > 0)
{
deleteElement(0);
length--;
}
}
int
deleteItem (Queue *queue, const void *item) {
Element *element = findElement(queue, testItemAddress, item);
if (!element) return 0;
element->item = NULL;
deleteElement(element);
return 1;
}
void deleteList(SortedList *list) {
while (list->head->next != nullptr) {
deleteElement(list->head->next, list->head, list->head->next->next);
}
delete list->head;
delete list;
}
//deleteFirstElement() removes the first element of the list
//list : a pointer to the LinkedList to delete the data from
//returns : a status code as defined in linklist.h
int deleteFirstElement(LinkedList list) {
ListElement* toDelete = list->begining;
if(toDelete == NULL) return LLUNDERRUN;
list->begining = toDelete->nextElement;
if(list->begining!=NULL) list->begining->prevElement = NULL;
if(list->begining==NULL) list->end = NULL;
return deleteElement(toDelete);
}
bool
Container::clearElements(bool delete_pointers)
{
while(m_Children.size()) {
Element *e=m_Children[0];
deleteElement(e);
if (delete_pointers) delete e;
}
return true;
}
static void
cancelAlarm (Element *element) {
AlarmEntry *alarm = getElementItem(element);
if (alarm->active) {
alarm->cancel = 1;
} else {
deleteElement(element);
}
}
// ***************************************************************************************************
void CPSSound::removeAllSources(void)
{
NL_PS_FUNC(CPSSound_removeAllSources)
const sint32 size = _Sounds.getSize();
// delete all sounds, and rebuild them all
for (sint32 k = size - 1; k >= 0; --k)
{
deleteElement(k);
}
}
void *
dequeueItem (Queue *queue) {
void *item;
Element *element;
if (!(element = queue->head)) return NULL;
item = element->item;
element->item = NULL;
deleteElement(element);
return item;
}
void ArrayEntryType::deleteValue(EntryValue value) {
ArrayEntryData* dataArray = (ArrayEntryData*) value.ptr;
if(dataArray!=NULL) {
for (int i = 0; i < dataArray->length; ++i) {
deleteElement(dataArray->array[i]);
}
if(dataArray->array != NULL)
free(dataArray->array);
free(dataArray);
}
}
void delK(List* list, int k)
{
ListElement *tmp = list->head;
ListElement *start = tmp;
while (list->size != 1)
{
for (int i = 1; i < k; i++)
tmp = tmp->next;
start = tmp->next;
deleteElement(list, tmp);
tmp = start;
}
}
