double *getNewValues(double *x, int n, list *blocks, double *y)
{
    int i=0, j;
    list *node = blocks;
    while(i<n)
    {
        if(node != NULL && checkBoundires(node, i))
        {
            for(j=i;j<=node->blockEndIndex;j++)
                y[j] = node->avg;
            
            i = node->blockEndIndex+1;
            node = node->next;
        }
        else
        {
            y[i] = x[i];
            i++;
        }
    }
    
    
    deleteList(blocks);
    
    return y;
}

 static void deleteList(ListNode * l)
 {
     if(! l -> next)
         delete l;
     deleteList(l -> next);
     delete l;
 }

int main() {
    linknode *flist,*rlist,*find;
    int index; char value;
    rlist=(linknode*)malloc(sizeof(linknode));
    rlist->next=NULL;
    printf("plase input a sting,end with the KEY_Enter \n");
    //flist=CreateListF();
    //printLinkList(flist);
    CreateListR(rlist);
    printLinkList(rlist);
    printf("list length=%d \n",getLength(rlist));
    printf("set insert node:index,value:");
    scanf("%d,%c",&index,&value);
    printf("insert a element!");
    insertList(rlist,value,index);
    printLinkList(rlist);
    printf("list length=%d \n",getLength(rlist));
    printf("set delete node index:");
    scanf("%d",&index);
    deleteList(rlist,index);
    printf("delete a element!");
    printLinkList(rlist);
    printf("list length=%d \n",getLength(rlist));
    printf("set visit node index:");
    scanf("%d",&index);
    find=getNode(rlist,index);
    if(find!=NULL)
    {
        printf("this node value=%c \n",find->data);
    }
    
    return 0;
}

void AppleMacIO::publishBelow( IORegistryEntry * root )
{
    OSCollectionIterator *	kids;
    IORegistryEntry *		next;
    IOService *			nub;

    // infanticide
    kids = IODTFindMatchingEntries( root, kIODTRecursive, deleteList() );
    if( kids) {
	while( (next = (IORegistryEntry *)kids->getNextObject())) {
	    next->detachAll( gIODTPlane);
	}
	kids->release();
    }

    // publish everything below, minus excludeList
    kids = IODTFindMatchingEntries( root, kIODTRecursive | kIODTExclusive,
					excludeList());
    if( kids) {
	while( (next = (IORegistryEntry *)kids->getNextObject())) {

            if( 0 == (nub = createNub( next )))
                continue;

            nub->attach( this );
	    
	    processNub(nub);
	    
            nub->registerService();
        }
	kids->release();
    }
}

//
// tries to make an exit parse var
PARSE_VAR *use_one_parse_token_exit(CHAR_DATA *looker, PARSE_TOKEN *tok, 
				    const char *name) {
  int    type = FOUND_NONE;
  void *found = find_specific(looker, name, "", "", FIND_TYPE_EXIT, tok->scope,
			      tok->all_ok, &type);

  // make sure we found something
  if(found == NULL)
    return NULL;
  else {
    PARSE_VAR *var = newParseVar(PARSE_VAR_EXIT);

    // if multiple vals were possible, flag it
    var->multiple_possible = tok->all_ok;

    // Is it a single exit?
    if(type == FOUND_EXIT)
      var->ptr_val = found;

    // or is it multiple exits?
    else if(type == FOUND_LIST) {
      if(listSize(found) > 1) {
	var->ptr_val = found;
	var->multiple = TRUE;
      }
      else if(listSize(found) == 1) {
	var->ptr_val = listPop(found);
	deleteList(found);
      }
      else {
	deleteList(found);
	deleteParseVar(var);
	var = NULL;
      }
    }

    // We should never reach this case
    else {
      deleteParseVar(var);
      var = NULL;
    }

    // return whatever we found
    return var;
  }
}

/***********************************************************************
     * ExchangeWindow
     * init

***********************************************************************/
void fired::ExchangeWindow::init(fired::MapObjectCollector *collector) {
	deleteList(exchange);
	sf::Vector2f winOffset = win->offset;

	for (int i = 0; i < 10; i++)
		for (int j = 0; j < 5; j++)
			exchange.push_back(new fired::InventoryWindowItem(winOffset + sf::Vector2f(380.0f + 35.0f * i, 185.0f + 35.0f * j), &collector->items[i][j], itAny));
}

// This destructor destroys a list and frees the associated nodes.
void deleteList(List l)
{
    if (l == 0)
		return;
    List rest = l->nextPtr;
	free(l);
	deleteList(rest);
};

void deleteList(struct xTEDSQualifierListNode* p)
{
	if(p==NULL) return;
	deleteList(p->next);
	if(p->data!=NULL)
		delete(p->data);
	free(p);
}

void deleteList(Node *head)
{
	if(!head)
		return ;

	deleteList(head->next) ;
	free(head) ;
}

int _tmain(int argc, _TCHAR* argv[])
{
	printf("0 - exit\n");
    printf("1 - add value to sorted list\n");
    printf("2 - remove value from list\n");
    printf("3 - print list\n");

	IntList *head = newList(-1);

	while(true)
	{
		printf("Input command:\n");
		int command = 0;
		scanf("%d", &command);
		int val = 0;
		switch (command)
		{
			case 0:
				deleteList(head);
				return 0;
			case 1:
				printf("Input value:\n");
				
				scanf("%d", &val);
				addToSortedList(head, val);
				break;
			case 2:
				printf("Input value:\n");
				
				scanf("%d", &val);
				removeValue(head, val);
				break;
			case 3:
				printList(head);
				break;
		};

	}
	
	deleteList(head);

	scanf("%*s");
	return 0;
}

int main()
{
    constexpr unsigned N = 5;
    list listx = nullptr;

    createCircularList(listx,N);
    printList(listx);
    deleteList(listx);
    return 0;
}

/* deletes list */
void deleteList(element head,int is_nodes,int recursivly){
	if(head==NULL){
		return;
	}
	deleteList(head->next,is_nodes,recursivly);
	if (recursivly==1){
		remove_tree(head->node,0,recursivly);
	}
	free(head);
}

void destroyHashTable(hash_t *hashTable) {
   // Free all of the lists
   for (int i = 0; i < hashTable->capacity; i++) {
        if (hashTable->buckets[i] != NULL) {
            deleteList(hashTable->buckets[i]);
        }
   }
   free(hashTable->buckets);
   free(hashTable);
}

/// Function name  : deleteScriptGenerator
// Description     : Destroys a ScriptGenerator
// 
// SCRIPT_GENERATOR*  &ScriptGenerator   : [in] ScriptGenerator to destroy
// 
VOID  deleteScriptGenerator(SCRIPT_GENERATOR*  &pGenerator)
{
   // Delete Arguments/Variables list
   deleteList(pGenerator->pVariablesList);

   // Delete XML Tree
   if (pGenerator->pXMLTree)
      deleteXMLTree(pGenerator->pXMLTree);

   // Zero Layout
   utilZeroObject(&pGenerator->oLayout, XML_SCRIPT_LAYOUT);

   // Delete INPUT and OUTPUT
   deleteList(pGenerator->pInputList);
   deleteCommandStream(pGenerator->pOutputStream);
   
   // Delete Generator
   utilDeleteObject(pGenerator);
}

List& List::operator =(
		const List& other) {

	if (this != &other) {
		deleteList();
		copyList(other);
	}

	return *this;
}

void deleteHashSet(struct HashSet *hashset)
{
	int index;

	for (index = 0; index < hashset->numberBuckets; index++)
		deleteList(hashset->buckets[index]);

	free(hashset->buckets);
	free(hashset);
}

void main()

{

	node *head,*tail;

	createList(&head);

	insertAtBeginning(&head,4);

	insertAtBeginning(&head,3);

	insertAtBeginning(&head,2);

	insertAtBeginning(&head,5);

	insertAtBeginning(&head,6);

	insertAtBeginning(&head,10);

	insertAtEnd(&head,1);

    insertInBetween(&head,9,2);

    traverseList(head);

    printf("\n");

    reverseTraversal(head);

    reverseList(&head);

    traverseList(head);

    deleteEnd(&head);

    traverseList(head);

    deleteBeginning(&head);

    traverseList(head);

    deleteAfter(&head,2);

    traverseList(head);

    deleteList(&head);

    traverseList(head);

//	tail= getTail(head);

//	printf("\nTail= %d",tail->info);

}

int main() {
	int data1,data2,data3,data4,data5;
	int nonData = 6;
	int * pFind = NULL;
	List test = NULL;
	initList(&test);

	data1 = 10;data2 = 20;data3 = 30;data4 = 40;data5 = 50;
	addToList(test, (void*)&data1);
	addToList(test, (void*)&data2);
	addToList(test, (void*)&data3);
	addToList(test, (void*)&data4);
	addToList(test, (void*)&data5);
	displayList(test);

	printf("%s","Searching for 30");
	pFind = (int*)findInList(test, (void*)&data3, intGreater);

	if (pFind)
	{
		printf("%s%d","\nFound data value: ", *pFind);
	}
	else {
		printf("%s","\nData not found");
	}

	printf("%s","\nSearching for 99 (shouldn't be in list)");
	pFind = (int*)findInList(test, (void*)&nonData, intGreater);

	if (pFind)
	{
		printf("%s%d","\nFound data value: ", *pFind);
	}
	else {
		printf("%s","\nData not found");
	}

	printf("%s","\nremoving one item then displaying\n");
	removeFirst(test);
	displayList(test);

	printf("%s","removing all items then displaying\n");
	deleteList(test);
	displayList(test);

	printf("%s","Attempting to remove from an empty list\n");
	removeFirst(test);
	displayList(test);

	cleanupList(&test);

	printf("%s","All tests complete\n");

	return 0;
}

List* merge(List* newList1, List* newList2)
{
	Position head1 = first(newList1);
	Position head2 = first(newList2);
	List* newList = createList();
	while (head1 != NULL && head2 != NULL)
	{
		if (retrieve(head1, newList1) <= retrieve(head2, newList2))
		{
			add(newList, retrieve(head1, newList1));
			head1 = next(head1, newList1);
		}
		else
		{
			add(newList, retrieve(head2, newList2));
			head2 = next(head2, newList2);
		}
	}
	if (head2 == NULL)
		while (head1 != NULL)
		{
			add(newList, retrieve(head1, newList1));
			head1 = next(head1, newList1);
		}
	if (head1 == NULL)
		while (head2 != NULL)
		{
			add(newList, retrieve(head2, newList2));
			head2 = next(head2, newList2);
		}
	deleteList(newList1);
	deleteList(newList2);
	List* newNewList = createList();
	head1 = first(newList);
	while (head1 != NULL)
	{
		add(newNewList, retrieve(head1, newList));
		head1 = next(head1, newList);
	}
	deleteList(newList);
	return newNewList;
}

	void deleteHashTable(HashTable &hashT)
	{
		for (int i = 0; i < hashT.size; ++i)
		{
		//	cout << "deleted list ";
		//	printList(hashT.arr[i]);
		//	cout << "\n";
			deleteList(hashT.arr[i]);
		}
		delete[] hashT.arr;
	}