psblas2-dev:
Changelog base/internals/Makefile base/internals/avltree.c base/internals/avltree.h base/internals/psi_bld_tmphalo.f90 base/internals/psi_fnd_owner.f90 base/internals/psi_idx_cnv.f90 base/internals/psi_idx_ins_cnv.f90 base/internals/srcht.c base/modules/Makefile base/modules/psb_avl_mod.f90 base/modules/psb_desc_type.f90 base/tools/psb_cd_inloc.f90 base/tools/psb_cdals.f90 base/tools/psb_cdalv.f90 base/tools/psb_cdins.f90 base/tools/psb_icdasb.F90 Merged AVL changes.psblas3-type-indexed
Salvatore Filippone
17 years ago
parent
44cffb0d36
commit
d616b83f6f
@ -1,822 +0,0 @@
|
||||
/*
|
||||
* Parallel Sparse BLAS version 2.2
|
||||
* (C) Copyright 2006/2007/2008
|
||||
* Salvatore Filippone University of Rome Tor Vergata
|
||||
* Alfredo Buttari University of Rome Tor Vergata
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions, and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. The name of the PSBLAS group or the names of its contributors may
|
||||
* not be used to endorse or promote products derived from this
|
||||
* software without specific written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PSBLAS GROUP OR ITS CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
/*****************************************************************/
|
||||
/* */
|
||||
/* avltree.c: balanced AVL tree search and insertion */
|
||||
/* written by: Salvatore Filippone */
|
||||
/* */
|
||||
/* Last updated: Mar 09 2004 */
|
||||
/* */
|
||||
/* Referrences: [1] D. E. Knuth */
|
||||
/* The Art of Computer Programming */
|
||||
/* Vol. 3: Sorting and Searching, sec. 6.2.3 */
|
||||
/* Addison-Wesley */
|
||||
/* */
|
||||
/* General description: */
|
||||
/* */
|
||||
/* Build and maintain a balanced binary search tree with */
|
||||
/* arbitrary keys. The user is responsible for providing */
|
||||
/* compare functions operating on the keys themselves. */
|
||||
/* Key pointers are stored into nodes that are managed */
|
||||
/* by the subroutine calls; the user should never examine */
|
||||
/* nodes directly. */
|
||||
/* The nodes for user items are allocated in batches, */
|
||||
/* and the batches are kept as a doubly linked list. */
|
||||
/* */
|
||||
/* Data types: */
|
||||
/* AVLTree: structure containing pointers to the list */
|
||||
/* of node batches and to the root of the binary tree */
|
||||
/* structure */
|
||||
/* */
|
||||
/* AVLNode: binary tree node, containing link pointers */
|
||||
/* a reserved field, and a pointer to user data */
|
||||
/* */
|
||||
/* */
|
||||
/* User callable functions: */
|
||||
/* */
|
||||
/* AVLTreePtr GetAVLTree() */
|
||||
/* Purpose: allocate a new tree; */
|
||||
/* Function value: a fresh AVL tree pointer; */
|
||||
/* returns NULL in case of a memory failure*/
|
||||
/* */
|
||||
/* */
|
||||
/* int AVLTreeReInit(AVLTreePtr Tree) */
|
||||
/* Purpose: reinitialize an existing AVL Tree, reusing */
|
||||
/* node batches already allocated. */
|
||||
/* Input: 1. Tree */
|
||||
/* A pointer to an existing tree structure */
|
||||
/* Function value: 0 Normal termination */
|
||||
/* -1 Invalid input pointer */
|
||||
/* -3 Memory allocation failure */
|
||||
/* */
|
||||
/* AVLNodePtr AVLTreeSearch(AVLTreePtr Tree, void *key, */
|
||||
/* int (*comp)(void*, void*)) */
|
||||
/* Purpose: search an existing AVL Tree for a key */
|
||||
/* Input: 1. Tree */
|
||||
/* A valid pointer to a Tree */
|
||||
/* 2. key */
|
||||
/* The item being searched for */
|
||||
/* 3. comp */
|
||||
/* A comparison function: */
|
||||
/* a<b => comp(a,b)<0 */
|
||||
/* a==b => comp(a,b)=0 */
|
||||
/* a>b => comp(a,b)>0 */
|
||||
/* The function is always invoked as: */
|
||||
/* comp(user_key,tree_key); */
|
||||
/* */
|
||||
/* */
|
||||
/* Function value: NULL: input error or item not found */
|
||||
/* valid pointer: pointer to a node */
|
||||
/* containing the key */
|
||||
/* */
|
||||
/* int AVLTreeInsert(AVLTreePtr Tree, void *key, */
|
||||
/* int (*comp)(void*,void*), */
|
||||
/* void (*update)(void*,void*,void*), */
|
||||
/* void *data) */
|
||||
/* Purpose: Insert an item into an existing (possibly */
|
||||
/* empty) tree. */
|
||||
/* */
|
||||
/* Input: 1. Tree */
|
||||
/* The (existing) tree */
|
||||
/* 2. key */
|
||||
/* The (new) item to be inserted */
|
||||
/* 3. comp */
|
||||
/* comparison function (as in AVLTreeSearch) */
|
||||
/* 4. update */
|
||||
/* A user provided function to be called when */
|
||||
/* the key is already present in the tree */
|
||||
/* with the calling sequence: */
|
||||
/* update(new_key,existing_key) */
|
||||
/* enables the user to specify an arbitrary */
|
||||
/* update procedure. */
|
||||
/* */
|
||||
/* */
|
||||
/* */
|
||||
/* AVLNodePtr AVLTreeUserInsert(AVLTreePtr Tree, void *key, */
|
||||
/* int (*comp)(void*,void*)) */
|
||||
/* */
|
||||
/* Purpose: Insert an item into an existing (possibly */
|
||||
/* empty) tree; returns a pointer to a node */
|
||||
/* containing the item, even when that node */
|
||||
/* was already existing; does no update */
|
||||
/* */
|
||||
/* Input: 1. Tree */
|
||||
/* The (existing) tree */
|
||||
/* 2. key */
|
||||
/* The (new) item to be inserted */
|
||||
/* 3. comp */
|
||||
/* comparison function (as in AVLTreeSearch) */
|
||||
/* */
|
||||
/* Function value: Valid pointer: pointer to a node */
|
||||
/* containing the item (possibly */
|
||||
/* was already there) */
|
||||
/* NULL input error or memory failure */
|
||||
/* */
|
||||
/* */
|
||||
/* int HowManyKeys(AVLTreePtr Tree) */
|
||||
/* Purpose: how many keys does Tree contain? */
|
||||
/* Function value: >=0 */
|
||||
/* */
|
||||
/* */
|
||||
/* void AVLTreeInorderTraverse(AVLTreePtr Tree, */
|
||||
/* void (*func)( void*, void*), void *data) */
|
||||
/* */
|
||||
/* Purpose: visit the nodes of the binary tree in their */
|
||||
/* natural order, performing an arbitrary */
|
||||
/* task upon visit. */
|
||||
/* Input: 1. Tree */
|
||||
/* A tree pointer */
|
||||
/* 2. func */
|
||||
/* A function performing a user specified */
|
||||
/* task on each node; the fuction is invoked as */
|
||||
/* func( key,data) */
|
||||
/* where data is parm. 3 */
|
||||
/* 3. data */
|
||||
/* Auxiliary data to be passed to func upon */
|
||||
/* each visit */
|
||||
/* */
|
||||
/* int AVLTreeInorderTraverseWithDelims(AVLTreePtr Tree, */
|
||||
/* void *first, void *last, int (*comp)(void*,void*) */
|
||||
/* void (*func)( void*, void*), void *data) */
|
||||
/* */
|
||||
/* Purpose: visit the nodes of the binary tree in their */
|
||||
/* natural order, performing an arbitrary */
|
||||
/* task upon visit, but only on nodes */
|
||||
/* with their key within a specified range. */
|
||||
/* */
|
||||
/* Input: 1. Tree */
|
||||
/* A tree pointer */
|
||||
/* 2. first */
|
||||
/* Visit nodes with first <= node->key */
|
||||
/* 3. last */
|
||||
/* Visit nodes with node->key <= last */
|
||||
/* 4. comp */
|
||||
/* comparison function (as in AVLTreeSearch) */
|
||||
/* 5. func */
|
||||
/* A function performing a user specified */
|
||||
/* task on each node; the fuction is invoked as */
|
||||
/* func( key,data) */
|
||||
/* where data is parm. 3 */
|
||||
/* 6. data */
|
||||
/* Auxiliary data to be passed to func upon */
|
||||
/* each visit */
|
||||
/* Function value: total number of nodes visited (>=0) */
|
||||
/* */
|
||||
/* */
|
||||
/* */
|
||||
/* void AVLTreeFree(AVLTreePtr Tree, void (*ffree)(void*)) */
|
||||
/* Purpose: free up tree data storage */
|
||||
/* Does NOT free the Tree pointer itself, */
|
||||
/* rather all the structures that it points to */
|
||||
/* Input: 1. Tree */
|
||||
/* A tree pointer */
|
||||
/* 2. ffree */
|
||||
/* A user specified function invoked on each */
|
||||
/* key pointer contained in the tree to free */
|
||||
/* its memory (if necessary). Can be NULL. */
|
||||
/* */
|
||||
/* */
|
||||
/*****************************************************************/
|
||||
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "avltree.h"
|
||||
|
||||
#define POOLSIZE 1024
|
||||
#define MAXSTACK 64
|
||||
#define MAX(a,b) ((a)>=(b) ? (a) : (b))
|
||||
|
||||
typedef struct avltvect {
|
||||
AVLNode pool[POOLSIZE];
|
||||
int avail;
|
||||
AVLTVectPtr previous, next;
|
||||
} AVLTVect;
|
||||
|
||||
|
||||
int HowManyItems(AVLTreePtr Tree)
|
||||
{
|
||||
if (Tree==NULL) {
|
||||
return(0);
|
||||
} else {
|
||||
return(Tree->nnodes);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
AVLTreePtr GetAVLTree()
|
||||
{
|
||||
AVLTreePtr tree;
|
||||
if ((tree=(AVLTreePtr) malloc(sizeof(AVLTree)))!=NULL){
|
||||
memset(tree,'\0',sizeof(AVLTree));
|
||||
AVLTreeInit(tree);
|
||||
}
|
||||
return(tree);
|
||||
}
|
||||
|
||||
int AVLTreeInit(AVLTreePtr Tree)
|
||||
{
|
||||
/* AVLTVectPtr current; */
|
||||
if (Tree==NULL) {
|
||||
fprintf(stderr,"Cannot initialize a NULL Tree pointer\n");
|
||||
return(-1);
|
||||
}
|
||||
|
||||
if (Tree->first!=NULL) {
|
||||
fprintf(stderr,"Cannot initialize a nonempty Tree: call AVLTreeFree first\n");
|
||||
return(-2);
|
||||
}
|
||||
|
||||
/* if ((current=(AVLTVectPtr)malloc(sizeof(AVLTVect)))==NULL) { */
|
||||
/* fprintf(stderr,"Memory allocation failure\n"); */
|
||||
/* return(-3); */
|
||||
/* } */
|
||||
/* memset(current,'\0',sizeof(AVLTVect)); */
|
||||
Tree->first=Tree->current=NULL;
|
||||
Tree->nnodes=0;
|
||||
Tree->root=NULL;
|
||||
return(0);
|
||||
}
|
||||
|
||||
int AVLTreeReInit(AVLTreePtr Tree)
|
||||
{
|
||||
AVLTVectPtr current /* , next */ ;
|
||||
if (Tree==NULL) {
|
||||
fprintf(stderr,"Cannot ReInitialize a NULL Tree pointer\n");
|
||||
return(-1);
|
||||
}
|
||||
|
||||
if (Tree->first!=NULL) {
|
||||
current=Tree->first;
|
||||
while (current!=NULL) {
|
||||
current->avail=0;
|
||||
memset(current->pool,'\0',POOLSIZE*sizeof(AVLNode));
|
||||
current=current->next;
|
||||
}
|
||||
} else {
|
||||
if ((current=(AVLTVectPtr)malloc(sizeof(AVLTVect)))==NULL) {
|
||||
fprintf(stderr,"Memory allocation failure\n");
|
||||
return(-3);
|
||||
}
|
||||
current->avail=0;
|
||||
current->previous=current->next=NULL;
|
||||
Tree->first=current;
|
||||
}
|
||||
Tree->current=Tree->first;
|
||||
Tree->nnodes=0;
|
||||
Tree->root=NULL;
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
AVLNodePtr AVLTreeSearch(AVLTreePtr Tree, void *key,
|
||||
int (*comp)(void *, void *))
|
||||
{
|
||||
AVLNodePtr current;
|
||||
int icmp;
|
||||
if (Tree==NULL) return(NULL);
|
||||
current = Tree->root;
|
||||
#ifdef PROFILE
|
||||
Tree->nsteps=0;
|
||||
#endif
|
||||
while (current != NULL) {
|
||||
icmp = (*comp)(key,current->key);
|
||||
#ifdef PROFILE
|
||||
Tree->nsteps +=1;
|
||||
#endif
|
||||
if (icmp<0) {
|
||||
current = current->llink;
|
||||
} else if (icmp==0){
|
||||
return(current);
|
||||
} else if (icmp>0) {
|
||||
current = current->rlink;
|
||||
}
|
||||
}
|
||||
return(current);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void AVLTreeInorderTraverse(AVLTreePtr Tree, void (*func)(void *, void *),
|
||||
void *data)
|
||||
{
|
||||
int lev;
|
||||
AVLNodePtr root;
|
||||
|
||||
AVLNodePtr stack[MAXSTACK+2];
|
||||
int choice[MAXSTACK+2];
|
||||
root=Tree->root;
|
||||
if (root == NULL) return;
|
||||
|
||||
lev=0;
|
||||
stack[lev] = root;
|
||||
choice[lev] = -1;
|
||||
|
||||
while (lev>=0) {
|
||||
if (stack[lev]==NULL) {
|
||||
lev--;
|
||||
} else {
|
||||
if (choice[lev]==-1) {
|
||||
stack[lev+1] = stack[lev]->llink;
|
||||
choice[lev+1] = -1;
|
||||
choice[lev] += 1;
|
||||
lev++;
|
||||
} else if (choice[lev]==0) {
|
||||
(*func)(stack[lev]->key,data);
|
||||
stack[lev+1] = stack[lev]->rlink;
|
||||
choice[lev+1] = -1;
|
||||
choice[lev] += 1;
|
||||
lev++;
|
||||
} else {
|
||||
lev--;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int AVLTreeInorderTraverseWithDelims(AVLTreePtr Tree, void *first, void *last,
|
||||
int (*comp)(void*, void*),
|
||||
void (*func)(void *, void *),
|
||||
void *data)
|
||||
{
|
||||
AVLNodePtr root, current;
|
||||
int lev, nvisit, icmp;
|
||||
AVLNodePtr stack[MAXSTACK+2];
|
||||
int choice[MAXSTACK+2];
|
||||
|
||||
root=Tree->root;
|
||||
if (root == NULL) return(0);
|
||||
|
||||
nvisit=0;
|
||||
lev=0;
|
||||
current = root;
|
||||
while (current != NULL) {
|
||||
stack[lev] = current;
|
||||
icmp = (*comp)(first,current->key);
|
||||
if (icmp<=0) {
|
||||
choice[lev]=0;
|
||||
current = current->llink;
|
||||
} else if (icmp>0) {
|
||||
current = current->rlink;
|
||||
choice[lev]=1;
|
||||
}
|
||||
lev++;
|
||||
}
|
||||
lev--;
|
||||
while (lev>=0) {
|
||||
if (stack[lev]==NULL) {
|
||||
lev--;
|
||||
} else {
|
||||
if (choice[lev]==-1) {
|
||||
stack[lev+1] = stack[lev]->llink;
|
||||
choice[lev+1] = -1;
|
||||
choice[lev] += 1;
|
||||
lev++;
|
||||
} else if (choice[lev]==0) {
|
||||
if (((*comp)(last,stack[lev]->key))<0) {
|
||||
lev--;
|
||||
} else {
|
||||
(*func)(stack[lev]->key,data);
|
||||
nvisit++;
|
||||
stack[lev+1] = stack[lev]->rlink;
|
||||
choice[lev+1] = -1;
|
||||
choice[lev] += 1;
|
||||
lev++;
|
||||
}
|
||||
} else {
|
||||
lev--;
|
||||
}
|
||||
}
|
||||
}
|
||||
return(nvisit);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void AVLTreePreorderTraverse(AVLTreePtr Tree, void (*func)(void *, void *),
|
||||
void *data)
|
||||
{
|
||||
AVLNodePtr root;
|
||||
int lev;
|
||||
AVLNodePtr stack[MAXSTACK+2];
|
||||
int choice[MAXSTACK+2];
|
||||
|
||||
root=Tree->root;
|
||||
if (root == NULL) return;
|
||||
lev=0;
|
||||
stack[lev] = root;
|
||||
choice[lev] = -1;
|
||||
|
||||
while (lev>=0) {
|
||||
if (stack[lev]==NULL) {
|
||||
lev--;
|
||||
} else {
|
||||
if (choice[lev]==-1) {
|
||||
(*func)(stack[lev]->key,data);
|
||||
stack[lev+1] = stack[lev]->llink;
|
||||
choice[lev+1] = -1;
|
||||
choice[lev] += 1;
|
||||
lev++;
|
||||
} else if (choice[lev]==0) {
|
||||
stack[lev+1] = stack[lev]->rlink;
|
||||
choice[lev+1] = -1;
|
||||
choice[lev] += 1;
|
||||
lev++;
|
||||
} else {
|
||||
lev--;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void AVLTreeFree(AVLTreePtr Tree, void (*ffree)(void *))
|
||||
{
|
||||
AVLTVectPtr current, next;
|
||||
int i;
|
||||
if (Tree == NULL) return;
|
||||
|
||||
current=Tree->first;
|
||||
|
||||
while (current != NULL) {
|
||||
next=current->next;
|
||||
if (*ffree != NULL) {
|
||||
for (i=0; i<current->avail; i++)
|
||||
(*ffree)((current->pool[i]).key);
|
||||
}
|
||||
free(current);
|
||||
current=next;
|
||||
}
|
||||
Tree->nnodes=0;
|
||||
Tree->first=Tree->current=NULL;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
AVLNodePtr GetAVLNode(AVLTreePtr Tree)
|
||||
{
|
||||
AVLTVectPtr current, new;
|
||||
AVLNodePtr newnode;
|
||||
|
||||
if (Tree==NULL) {
|
||||
return(NULL);
|
||||
}
|
||||
if ((current=Tree->current)==NULL) {
|
||||
if ((current=(AVLTVectPtr)malloc(sizeof(AVLTVect)))==NULL) {
|
||||
fprintf(stderr,"Memory allocation failure\n");
|
||||
return(NULL);
|
||||
}
|
||||
memset(current,'\0',sizeof(AVLTVect));
|
||||
Tree->first=Tree->current=current;
|
||||
}
|
||||
|
||||
while ((current->avail>=POOLSIZE)&&(current->next!=NULL))
|
||||
current=current->next;
|
||||
|
||||
if (current->avail<POOLSIZE) {
|
||||
newnode=&(current->pool[current->avail]);
|
||||
current->avail += 1;
|
||||
} else {
|
||||
if ((new=(AVLTVectPtr)malloc(sizeof(AVLTVect)))==NULL) {
|
||||
fprintf(stderr,"Memory allocation failure\n");
|
||||
return(NULL);
|
||||
}
|
||||
memset(new,'\0',sizeof(AVLTVect));
|
||||
newnode=&(new->pool[0]);
|
||||
new->avail = 1;
|
||||
current->next=new;
|
||||
new->previous=current;
|
||||
new->next=NULL;
|
||||
Tree->current=new;
|
||||
}
|
||||
return(newnode);
|
||||
}
|
||||
|
||||
int AVLTreeInsert(AVLTreePtr Tree, void *key,int (*comp)(void *, void *),
|
||||
void (*update)(void *, void *, void *), void *data)
|
||||
{
|
||||
AVLNodePtr root, t, s, p, q, r;
|
||||
int search, bal, icmp;
|
||||
|
||||
if (Tree==NULL) {
|
||||
fprintf(stderr,"Fatal error: null tree pointer\n");
|
||||
return(-1);
|
||||
}
|
||||
|
||||
if ((root = Tree->root) == NULL) {
|
||||
if ((t=GetAVLNode(Tree))==NULL) {
|
||||
return(-2);
|
||||
}
|
||||
t->key = key;
|
||||
t->rlink=t->llink=NULL;
|
||||
t->bal=0;
|
||||
Tree->root = t;
|
||||
Tree->nnodes=1;
|
||||
return(0);
|
||||
}
|
||||
t = NULL;
|
||||
s = root;
|
||||
p = root;
|
||||
search=1;
|
||||
while (search) {
|
||||
icmp = (*comp)(key,p->key);
|
||||
if (icmp<0) {
|
||||
if ((q=p->llink)==NULL) {
|
||||
if ((q=GetAVLNode(Tree))==NULL) {
|
||||
return(-2);
|
||||
}
|
||||
p->llink=q;
|
||||
search=0;
|
||||
} else {
|
||||
if (q->bal != 0) {
|
||||
t=p;
|
||||
s=q;
|
||||
}
|
||||
}
|
||||
} else if (icmp == 0) {
|
||||
(*update)(key,p->key,data);
|
||||
return(1);
|
||||
} else {
|
||||
if ((q=p->rlink)==NULL) {
|
||||
if ((q=GetAVLNode(Tree))==NULL) {
|
||||
return(-2);
|
||||
}
|
||||
p->rlink=q;
|
||||
search=0;
|
||||
} else {
|
||||
if (q->bal != 0) {
|
||||
t=p;
|
||||
s=q;
|
||||
}
|
||||
}
|
||||
}
|
||||
p=q;
|
||||
}
|
||||
q->key=key;
|
||||
q->llink=q->rlink=NULL;
|
||||
q->bal=0;
|
||||
Tree->nnodes += 1;
|
||||
|
||||
if ((*comp)(key,s->key)<0) {
|
||||
r=p=s->llink;
|
||||
} else {
|
||||
r=p=s->rlink;
|
||||
}
|
||||
|
||||
while (p!=q) {
|
||||
if ((*comp)(key,p->key)<0) {
|
||||
p->bal=-1;
|
||||
p = p->llink;
|
||||
} else {
|
||||
p->bal=1;
|
||||
p=p->rlink;
|
||||
}
|
||||
}
|
||||
|
||||
if ((*comp)(key,s->key)<0) {
|
||||
bal=-1;
|
||||
} else {
|
||||
bal=1;
|
||||
}
|
||||
|
||||
if (s->bal == 0) {
|
||||
s->bal=bal;
|
||||
return (0);
|
||||
} else if (s->bal == -bal) {
|
||||
s->bal=0;
|
||||
return (0);
|
||||
} else if (s->bal == bal) {
|
||||
|
||||
if (r->bal == bal) {
|
||||
/* single rotation */
|
||||
p=r;
|
||||
if (bal>0) {
|
||||
s->rlink=r->llink;
|
||||
r->llink=s;
|
||||
} else {
|
||||
s->llink=r->rlink;
|
||||
r->rlink=s;
|
||||
}
|
||||
s->bal=r->bal=0;
|
||||
} else if (r->bal == -bal) {
|
||||
/* double rotation */
|
||||
if (bal>0) {
|
||||
p=r->llink;
|
||||
r->llink=p->rlink;
|
||||
p->rlink=r;
|
||||
s->rlink=p->llink;
|
||||
p->llink=s;
|
||||
} else {
|
||||
p=r->rlink;
|
||||
r->rlink=p->llink;
|
||||
p->llink=r;
|
||||
s->llink=p->rlink;
|
||||
p->rlink=s;
|
||||
}
|
||||
if (p->bal == bal) {
|
||||
s->bal=-bal;
|
||||
r->bal=0;
|
||||
} else if (p->bal==0) {
|
||||
s->bal=r->bal=0;
|
||||
} else {
|
||||
r->bal=bal;
|
||||
s->bal=0;
|
||||
}
|
||||
p->bal=0;
|
||||
}
|
||||
if (t==NULL) {
|
||||
root=p;
|
||||
} else {
|
||||
if (t->rlink==s) {
|
||||
t->rlink=p;
|
||||
} else {
|
||||
t->llink=p;
|
||||
}
|
||||
}
|
||||
Tree->root=root;
|
||||
return(0);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
AVLNodePtr AVLTreeUserInsert(AVLTreePtr Tree, void *key,
|
||||
int (*comp)(void *, void *))
|
||||
{
|
||||
AVLNodePtr root, t, s, p, q, r;
|
||||
int search, bal, icmp;
|
||||
|
||||
if (Tree==NULL) {
|
||||
fprintf(stderr,"Fatal error: null tree pointer\n");
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
if ((root = Tree->root) == NULL) {
|
||||
if ((t=GetAVLNode(Tree))==NULL) {
|
||||
return(NULL);
|
||||
}
|
||||
t->key = key;
|
||||
t->rlink=t->llink=NULL;
|
||||
t->bal=0;
|
||||
Tree->root = t;
|
||||
Tree->nnodes=1;
|
||||
return(t);
|
||||
}
|
||||
t = NULL;
|
||||
s = root;
|
||||
p = root;
|
||||
search=1;
|
||||
while (search) {
|
||||
icmp = (*comp)(key,p->key);
|
||||
if (icmp<0) {
|
||||
if ((q=p->llink)==(AVLNodePtr) NULL) {
|
||||
if ((q=GetAVLNode(Tree))==NULL) {
|
||||
return(NULL);
|
||||
}
|
||||
p->llink=q;
|
||||
search=0;
|
||||
} else {
|
||||
if (q->bal != 0) {
|
||||
t=p;
|
||||
s=q;
|
||||
}
|
||||
}
|
||||
} else if (icmp == 0) {
|
||||
return(p);
|
||||
} else {
|
||||
if ((q=p->rlink)==NULL) {
|
||||
if ((q=GetAVLNode(Tree))==NULL) {
|
||||
return(NULL);
|
||||
}
|
||||
p->rlink=q;
|
||||
search=0;
|
||||
} else {
|
||||
if (q->bal != 0) {
|
||||
t=p;
|
||||
s=q;
|
||||
}
|
||||
}
|
||||
}
|
||||
p=q;
|
||||
}
|
||||
q->key=key;
|
||||
q->llink=q->rlink=NULL;
|
||||
q->bal=0;
|
||||
Tree->nnodes += 1;
|
||||
|
||||
if ((*comp)(key,s->key)<0) {
|
||||
r=p=s->llink;
|
||||
} else {
|
||||
r=p=s->rlink;
|
||||
}
|
||||
|
||||
while (p!=q) {
|
||||
if ((*comp)(key,p->key)<0) {
|
||||
p->bal=-1;
|
||||
p = p->llink;
|
||||
} else {
|
||||
p->bal=1;
|
||||
p=p->rlink;
|
||||
}
|
||||
}
|
||||
|
||||
if ((*comp)(key,s->key)<0) {
|
||||
bal=-1;
|
||||
} else {
|
||||
bal=1;
|
||||
}
|
||||
|
||||
if (s->bal == 0) {
|
||||
s->bal=bal;
|
||||
return (q);
|
||||
} else if (s->bal == -bal) {
|
||||
s->bal=0;
|
||||
return (q);
|
||||
} else if (s->bal == bal) {
|
||||
|
||||
if (r->bal == bal) {
|
||||
/* single rotation */
|
||||
p=r;
|
||||
if (bal>0) {
|
||||
s->rlink=r->llink;
|
||||
r->llink=s;
|
||||
} else {
|
||||
s->llink=r->rlink;
|
||||
r->rlink=s;
|
||||
}
|
||||
s->bal=r->bal=0;
|
||||
} else if (r->bal == -bal) {
|
||||
/* double rotation */
|
||||
if (bal>0) {
|
||||
p=r->llink;
|
||||
r->llink=p->rlink;
|
||||
p->rlink=r;
|
||||
s->rlink=p->llink;
|
||||
p->llink=s;
|
||||
} else {
|
||||
p=r->rlink;
|
||||
r->rlink=p->llink;
|
||||
p->llink=r;
|
||||
s->llink=p->rlink;
|
||||
p->rlink=s;
|
||||
}
|
||||
if (p->bal == bal) {
|
||||
s->bal=-bal;
|
||||
r->bal=0;
|
||||
} else if (p->bal==0) {
|
||||
s->bal=r->bal=0;
|
||||
} else {
|
||||
r->bal=bal;
|
||||
s->bal=0;
|
||||
}
|
||||
p->bal=0;
|
||||
}
|
||||
if (t==NULL) {
|
||||
root=p;
|
||||
} else {
|
||||
if (t->rlink==s) {
|
||||
t->rlink=p;
|
||||
} else {
|
||||
t->llink=p;
|
||||
}
|
||||
}
|
||||
Tree->root=root;
|
||||
return(q);
|
||||
}
|
||||
return(q);
|
||||
}
|
||||
|
||||
@ -1,71 +0,0 @@
|
||||
/*
|
||||
* Parallel Sparse BLAS version 2.2
|
||||
* (C) Copyright 2006/2007/2008
|
||||
* Salvatore Filippone University of Rome Tor Vergata
|
||||
* Alfredo Buttari University of Rome Tor Vergata
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions, and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. The name of the PSBLAS group or the names of its contributors may
|
||||
* not be used to endorse or promote products derived from this
|
||||
* software without specific written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PSBLAS GROUP OR ITS CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
/* Type definitions for balanced AVL tree search and insertion */
|
||||
/* See avltree.c for a full definition of the subroutines */
|
||||
/* */
|
||||
|
||||
typedef struct avlnode *AVLNodePtr;
|
||||
typedef struct avlnode {
|
||||
AVLNodePtr llink,rlink;
|
||||
int bal;
|
||||
void *key;
|
||||
} AVLNode;
|
||||
|
||||
typedef struct avltvect *AVLTVectPtr;
|
||||
|
||||
typedef struct avltree *AVLTreePtr;
|
||||
typedef struct avltree {
|
||||
AVLTVectPtr first, current;
|
||||
AVLNodePtr root;
|
||||
int nnodes;
|
||||
#ifdef PROFILE
|
||||
int nsteps;
|
||||
#endif
|
||||
} AVLTree;
|
||||
|
||||
|
||||
AVLNodePtr AVLTreeSearch(AVLTreePtr, void *, int (*)(void *, void *));
|
||||
AVLNodePtr GetAVLNode(AVLTreePtr);
|
||||
int AVLTreeInit(AVLTreePtr);
|
||||
int AVLTreeReInit(AVLTreePtr);
|
||||
AVLTreePtr GetAVLTree();
|
||||
int AVLTreeInsert(AVLTreePtr, void *, int (*)(void *, void *),
|
||||
void (*)(void *, void *, void *), void *);
|
||||
AVLNodePtr AVLTreeUserInsert(AVLTreePtr, void *, int (*)(void *, void *));
|
||||
void AVLTreeInorderTraverse(AVLTreePtr, void (*)(void *, void *), void *);
|
||||
void AVLTreePreorderTraverse(AVLTreePtr, void (*)(void *, void *), void *);
|
||||
void AVLTreeFree(AVLTreePtr, void (*)(void *));
|
||||
int HowManyItems(AVLTreePtr);
|
||||
int AVLTreeInorderTraverseWithDelims(AVLTreePtr,void*, void*, int (*)(void*,void*),
|
||||
void (*)(void *, void *), void *);
|
||||
|
||||
|
||||
@ -1,446 +0,0 @@
|
||||
/*
|
||||
* Parallel Sparse BLAS version 2.2
|
||||
* (C) Copyright 2006/2007/2008
|
||||
* Salvatore Filippone University of Rome Tor Vergata
|
||||
* Alfredo Buttari University of Rome Tor Vergata
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions, and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. The name of the PSBLAS group or the names of its contributors may
|
||||
* not be used to endorse or promote products derived from this
|
||||
* software without specific written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PSBLAS GROUP OR ITS CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
/*****************************************************************/
|
||||
/* */
|
||||
/* srcht.c : specialized insert/search for (key,val) integer */
|
||||
/* pairs. Written by: Salvatore Filippone */
|
||||
/* */
|
||||
/* Last updated: Mar 09 2004 */
|
||||
/* */
|
||||
/* Uses: avltree */
|
||||
/* */
|
||||
/* Data types: */
|
||||
/* */
|
||||
/* KeyType: struct with two integer fields, key and val. */
|
||||
/* */
|
||||
/* */
|
||||
/* User callable functions: */
|
||||
/* */
|
||||
/* void InitPairSearchTree(int *iret) */
|
||||
/* Purpose: initialize a search structure; */
|
||||
/* Function value: 0: OK */
|
||||
/* -1: failure */
|
||||
/* */
|
||||
/* */
|
||||
/* void SearchInsKeyVal(int *key, int *val, int *res, */
|
||||
/* int *iret) */
|
||||
/* Purpose: Search for a key, insert it if not present. */
|
||||
/* */
|
||||
/* Input: 1. key */
|
||||
/* Key to be searched for. */
|
||||
/* 2. val */
|
||||
/* Value to form a (key,val) pair to be */
|
||||
/* inserted if key not already present. */
|
||||
/* Output: 3. res */
|
||||
/* The val part of the pair with key; if the */
|
||||
/* key was freshly inserted then res=val */
|
||||
/* Function value: 0 Normal termination */
|
||||
/* 1 Key was already present. */
|
||||
/* -1 Invalid input pointer */
|
||||
/* -3 Memory allocation failure */
|
||||
/* */
|
||||
/* */
|
||||
/* void FreePairSearchTree() */
|
||||
/* Purpose: free up tree data storage */
|
||||
/* */
|
||||
/* */
|
||||
/*****************************************************************/
|
||||
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "avltree.h"
|
||||
|
||||
#define POOLSIZE 4096
|
||||
#define CACHESIZE 16
|
||||
#ifdef LowerUnderscore
|
||||
#define InitPairSearchTree initpairsearchtree_
|
||||
#define FreePairSearchTree freepairsearchtree_
|
||||
#define ClonePairSearchTree clonepairsearchtree_
|
||||
#define SizeofPairSearchTree sizeofpairsearchtree_
|
||||
#define SearchInsKeyVal searchinskeyval_
|
||||
#define SearchKeyVal searchkeyval_
|
||||
#define NPairs npairs_
|
||||
#endif
|
||||
#ifdef LowerDoubleUnderscore
|
||||
#define InitPairSearchTree initpairsearchtree_
|
||||
#define FreePairSearchTree freepairsearchtree_
|
||||
#define ClonePairSearchTree clonepairsearchtree_
|
||||
#define SizeofPairSearchTree sizeofpairsearchtree_
|
||||
#define SearchInsKeyVal searchinskeyval_
|
||||
#define SearchKeyVal searchkeyval_
|
||||
#define NPairs npairs_
|
||||
#endif
|
||||
#ifdef LowerCase
|
||||
#define InitPairSearchTree initpairsearchtree
|
||||
#define FreePairSearchTree freepairsearchtree
|
||||
#define ClonePairSearchTree clonepairsearchtree
|
||||
#define SizeofPairSearchTree sizeofpairsearchtree
|
||||
#define SearchInsKeyVal searchinskeyval
|
||||
#define SearchKeyVal searchkeyval
|
||||
#define NPairs npairs
|
||||
#endif
|
||||
#ifdef UpperUnderscore
|
||||
#define InitPairSearchTree INITPAIRSEARCHTREE_
|
||||
#define FreePairSearchTree FREEPAIRSEARCHTREE_
|
||||
#define ClonePairSearchTree CLONEPAIRSEARCHTREE_
|
||||
#define SizeofPairSearchTree SIZEOFPAIRSEARCHTREE_
|
||||
#define SearchInsKeyVal SEARCHINSKEYVAL_
|
||||
#define SearchKeyVal SEARCHKEYVAL_
|
||||
#define NPairs NPAIRS_
|
||||
#endif
|
||||
#ifdef UpperDoubleUnderscore
|
||||
#define InitPairSearchTree INITPAIRSEARCHTREE_
|
||||
#define FreePairSearchTree FREEPAIRSEARCHTREE_
|
||||
#define ClonePairSearchTree CLONEPAIRSEARCHTREE_
|
||||
#define SizeofPairSearchTree SIZEOFPAIRSEARCHTREE_
|
||||
#define SearchInsKeyVal SEARCHINSKEYVAL_
|
||||
#define SearchKeyVal SEARCHKEYVAL_
|
||||
#define NPairs NPAIRS_
|
||||
#endif
|
||||
#ifdef UpperCase
|
||||
#define InitPairSearchTree INITPAIRSEARCHTREE
|
||||
#define FreePairSearchTree FREEPAIRSEARCHTREE
|
||||
#define ClonePairSearchTree CLONEPAIRSEARCHTREE
|
||||
#define SizeofPairSearchTree SIZEOFPAIRSEARCHTREE
|
||||
#define SearchInsKeyVal SEARCHINSKEYVAL
|
||||
#define SearchKeyVal SEARCHKEYVAL
|
||||
#define NPairs NPAIRS
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
typedef struct keypair *KeyPairPtr;
|
||||
typedef struct keypair {
|
||||
int key,val;
|
||||
} KeyPair;
|
||||
|
||||
|
||||
typedef struct pairvect *PairVectPtr;
|
||||
typedef struct pairvect {
|
||||
KeyPair pool[POOLSIZE];
|
||||
int avail;
|
||||
PairVectPtr previous, next;
|
||||
} PairVect;
|
||||
|
||||
|
||||
|
||||
typedef struct pairtree *PairTreePtr;
|
||||
typedef struct pairtree {
|
||||
int retval;
|
||||
int cache[2][CACHESIZE], cpnt;
|
||||
PairVectPtr PairPoolRoot,PairPoolCrt;
|
||||
AVLTreePtr tree;
|
||||
} PairTree;
|
||||
|
||||
#ifdef Ptr64Bits
|
||||
typedef long long fptr;
|
||||
#else
|
||||
typedef int fptr; /* 32-bit by default */
|
||||
#endif
|
||||
|
||||
/* fptr *f_factors, */
|
||||
/* *f_factors = (fptr) LUfactors; */
|
||||
|
||||
/* static int retval; */
|
||||
/* static PairVectPtr PairPoolRoot=NULL,PairPoolCrt=NULL; */
|
||||
/* static AVLTreePtr tree=NULL; */
|
||||
|
||||
int CompareKeys(void *key1, void *key2)
|
||||
{
|
||||
if (((KeyPairPtr) key1)->key < ((KeyPairPtr) key2)->key){
|
||||
return(-1);
|
||||
} else if (((KeyPairPtr)key1)->key == ((KeyPairPtr)key2)->key){
|
||||
return(0);
|
||||
} else {
|
||||
return(1);
|
||||
}
|
||||
}
|
||||
|
||||
void InitPairSearchTree(fptr *ftree, int *iret)
|
||||
{
|
||||
int i;
|
||||
PairTreePtr PTree;
|
||||
|
||||
*iret = 0;
|
||||
|
||||
if ((PTree = malloc(sizeof(PairTree)))==NULL) {
|
||||
*iret=-1; return;
|
||||
}
|
||||
PTree->retval=0;
|
||||
for (i=0; i<CACHESIZE; i++) {
|
||||
PTree->cache[0][i]=PTree->cache[1][i] = -1;
|
||||
}
|
||||
PTree->cpnt=0;
|
||||
if ((PTree->tree = GetAVLTree())==NULL) {
|
||||
*iret=-1; return;
|
||||
}
|
||||
if ((PTree->PairPoolRoot=(PairVectPtr)malloc(sizeof(PairVect)))==NULL) {
|
||||
*iret=-3; return;
|
||||
} else {
|
||||
PTree->PairPoolRoot->avail=0;
|
||||
PTree->PairPoolRoot->previous=PTree->PairPoolRoot->next=NULL;
|
||||
PTree->PairPoolCrt=PTree->PairPoolRoot;
|
||||
}
|
||||
*ftree = (fptr) PTree;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
int NPairs(fptr *ftree)
|
||||
{
|
||||
PairTreePtr PTree;
|
||||
|
||||
PTree = (PairTreePtr) *ftree;
|
||||
|
||||
return(HowManyItems(PTree->tree));
|
||||
}
|
||||
|
||||
void KeyUpdate( void *key1, void *key2, void *data)
|
||||
{
|
||||
*((int *) data)=((KeyPairPtr) key2)->val;
|
||||
}
|
||||
|
||||
int SizeofPairSearchTree(fptr *ftree)
|
||||
{
|
||||
PairTreePtr PTree;
|
||||
PairVectPtr current,next;
|
||||
int sz;
|
||||
PTree = (PairTreePtr) *ftree;
|
||||
|
||||
sz = 0;
|
||||
if (PTree==NULL) return(sz);
|
||||
current=PTree->PairPoolRoot;
|
||||
|
||||
while (current != NULL) {
|
||||
sz += sizeof(PairVect);
|
||||
next=current->next;
|
||||
current=next;
|
||||
}
|
||||
return(sz);
|
||||
}
|
||||
|
||||
void FreePairSearchTree(fptr *ftree)
|
||||
{
|
||||
PairTreePtr PTree;
|
||||
PairVectPtr current,next;
|
||||
|
||||
PTree = (PairTreePtr) *ftree;
|
||||
|
||||
AVLTreeFree(PTree->tree,NULL);
|
||||
|
||||
current=PTree->PairPoolRoot;
|
||||
|
||||
while (current != NULL) {
|
||||
next=current->next;
|
||||
free(current);
|
||||
current=next;
|
||||
}
|
||||
free(PTree->tree);
|
||||
free(PTree);
|
||||
*ftree = (fptr) NULL;
|
||||
return;
|
||||
}
|
||||
|
||||
int AdvanceKeyPair(PairVectPtr current)
|
||||
{
|
||||
if (current!=NULL) {
|
||||
current->avail +=1;
|
||||
return(current->avail);
|
||||
}
|
||||
return(-1);
|
||||
}
|
||||
|
||||
|
||||
KeyPairPtr GetKeyPair(PairVectPtr *current)
|
||||
{
|
||||
PairVectPtr new, crt;
|
||||
KeyPairPtr newnode;
|
||||
|
||||
crt=*current;
|
||||
if (crt==NULL) {
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
if (crt->avail<POOLSIZE) {
|
||||
newnode=&(crt->pool[crt->avail]);
|
||||
} else {
|
||||
if ((new=(PairVectPtr)malloc(sizeof(PairVect)))==NULL) {
|
||||
fprintf(stderr,"Memory allocation failure\n");
|
||||
return(NULL);
|
||||
}
|
||||
memset(new,'\0',sizeof(PairVect));
|
||||
newnode=&(new->pool[0]);
|
||||
crt->next=new;
|
||||
new->previous=crt;
|
||||
new->next=NULL;
|
||||
*current=new;
|
||||
}
|
||||
return(newnode);
|
||||
}
|
||||
|
||||
|
||||
/* */
|
||||
/* void SearchInsKeyVal(int *key, int *val, int *res, */
|
||||
/* int *iret) */
|
||||
/* Purpose: Search for a key, insert it if not present. */
|
||||
/* */
|
||||
/* Input: 1. key */
|
||||
/* Key to be searched for. */
|
||||
/* 2. val */
|
||||
/* Value to form a (key,val) pair to be */
|
||||
/* inserted if key not already present. */
|
||||
/* Output: 3. res */
|
||||
/* The val part of the pair with key; if the */
|
||||
/* key was freshly inserted then res=val */
|
||||
/* Function value: 0 Normal termination */
|
||||
/* -1 Invalid input pointer */
|
||||
/* -3 Memory allocation failure */
|
||||
/* */
|
||||
|
||||
void SearchInsKeyVal(fptr *ftree, int *key, int *val, int *res, int *iret)
|
||||
{
|
||||
PairTreePtr PTree;
|
||||
KeyPairPtr node;
|
||||
int info,i;
|
||||
|
||||
PTree = (PairTreePtr) *ftree;
|
||||
node = GetKeyPair(&(PTree->PairPoolCrt));
|
||||
node->key = *key;
|
||||
node->val = *val;
|
||||
if ((i=PTree->cpnt)<CACHESIZE) {
|
||||
PTree->cache[0][i] = *key;
|
||||
PTree->cache[1][i] = *val;
|
||||
PTree->cpnt=i+1;
|
||||
}
|
||||
|
||||
info = AVLTreeInsert(PTree->tree,node,CompareKeys,KeyUpdate,&(PTree->retval));
|
||||
*iret = info;
|
||||
|
||||
if (info==0) {
|
||||
*res = node->val;
|
||||
AdvanceKeyPair(PTree->PairPoolCrt);
|
||||
} else if (info == 1) {
|
||||
*res = PTree->retval;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#define USECACHE 0
|
||||
void SearchKeyVal(fptr *ftree, int *key, int *res, int *iret)
|
||||
{
|
||||
PairTreePtr PTree;
|
||||
KeyPair node;
|
||||
AVLNodePtr noderes;
|
||||
KeyPairPtr result;
|
||||
#if USECACHE
|
||||
int i,sv[2];
|
||||
int info;
|
||||
#endif
|
||||
|
||||
*iret = 0;
|
||||
|
||||
PTree = (PairTreePtr) *ftree;
|
||||
#if USECACHE
|
||||
for (i=0; i<CACHESIZE; i++) {
|
||||
if (PTree->cache[0][i] == *key) {
|
||||
*res=PTree->cache[1][i];
|
||||
sv[0]=PTree->cache[0][i];
|
||||
sv[1]=PTree->cache[1][i];
|
||||
PTree->cache[0][i]=PTree->cache[0][0];
|
||||
PTree->cache[1][i]=PTree->cache[1][0];
|
||||
PTree->cache[0][0]=sv[0];
|
||||
PTree->cache[1][0]=sv[1];
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
node.key=*key;
|
||||
if ((noderes = AVLTreeSearch(PTree->tree,&node,CompareKeys))==NULL) {
|
||||
*res = -1;
|
||||
*iret = 0;
|
||||
} else {
|
||||
result = (KeyPairPtr) noderes->key;
|
||||
*res = result->val;
|
||||
#if USECACHE
|
||||
for (i=CACHESIZE-1; i>0; i--) {
|
||||
PTree->cache[0][i]=PTree->cache[0][i-1];
|
||||
PTree->cache[0][i]=PTree->cache[1][i-1];
|
||||
}
|
||||
PTree->cache[0][0]=*key;
|
||||
PTree->cache[1][0]=result->val;
|
||||
#endif
|
||||
}
|
||||
#ifdef PROFILE
|
||||
*iret = 1;
|
||||
*iret = PTree->tree->nsteps;
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
void PairTreeVisit(AVLNodePtr current, PairTreePtr PTree)
|
||||
{
|
||||
KeyPairPtr node,inode;
|
||||
int info;
|
||||
|
||||
if (current==NULL) return;
|
||||
inode = (KeyPairPtr) current->key;
|
||||
node = GetKeyPair(&(PTree->PairPoolCrt));
|
||||
node->key = inode->key;
|
||||
node->val = inode->val;
|
||||
info = AVLTreeInsert(PTree->tree,node,CompareKeys,KeyUpdate,&(PTree->retval));
|
||||
if (info==0) {
|
||||
AdvanceKeyPair(PTree->PairPoolCrt);
|
||||
}
|
||||
PairTreeVisit(current->llink,PTree);
|
||||
PairTreeVisit(current->rlink,PTree);
|
||||
}
|
||||
|
||||
void ClonePairSearchTree(fptr *ftreein, fptr *ftreeout)
|
||||
{
|
||||
PairTreePtr PTreein, PTreeout;
|
||||
int i;
|
||||
|
||||
PTreein = (PairTreePtr) *ftreein;
|
||||
|
||||
if (PTreein == NULL) {
|
||||
*ftreeout = (fptr) NULL;
|
||||
return;
|
||||
}
|
||||
InitPairSearchTree(ftreeout,&i);
|
||||
PTreeout = (PairTreePtr) *ftreeout;
|
||||
PairTreeVisit(PTreein->tree->root,PTreeout);
|
||||
}
|
||||
@ -0,0 +1,618 @@
|
||||
!!$
|
||||
!!$ Parallel Sparse BLAS v2.0
|
||||
!!$ (C) Copyright 2006 Salvatore Filippone University of Rome Tor Vergata
|
||||
!!$ Alfredo Buttari University of Rome Tor Vergata
|
||||
!!$
|
||||
!!$ Redistribution and use in source and binary forms, with or without
|
||||
!!$ modification, are permitted provided that the following conditions
|
||||
!!$ are met:
|
||||
!!$ 1. Redistributions of source code must retain the above copyright
|
||||
!!$ notice, this list of conditions and the following disclaimer.
|
||||
!!$ 2. Redistributions in binary form must reproduce the above copyright
|
||||
!!$ notice, this list of conditions, and the following disclaimer in the
|
||||
!!$ documentation and/or other materials provided with the distribution.
|
||||
!!$ 3. The name of the PSBLAS group or the names of its contributors may
|
||||
!!$ not be used to endorse or promote products derived from this
|
||||
!!$ software without specific written permission.
|
||||
!!$
|
||||
!!$ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
!!$ ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
!!$ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
!!$ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PSBLAS GROUP OR ITS CONTRIBUTORS
|
||||
!!$ BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
!!$ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
!!$ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
!!$ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
!!$ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
!!$ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
!!$ POSSIBILITY OF SUCH DAMAGE.
|
||||
!!$
|
||||
!!$
|
||||
|
||||
module psb_item_mod
|
||||
type psb_item_int2
|
||||
integer :: key, val
|
||||
end type psb_item_int2
|
||||
interface psb_sizeof
|
||||
module procedure psb_item_int2_size
|
||||
end interface
|
||||
contains
|
||||
function psb_item_int2_size(node)
|
||||
use psb_const_mod
|
||||
type(psb_item_int2) :: node
|
||||
psb_item_int2_size = psb_sizeof_int * 2
|
||||
end function psb_item_int2_size
|
||||
|
||||
subroutine psb_print_item_key_val(iout,item)
|
||||
integer, intent(in) :: iout
|
||||
type(psb_item_int2), intent(in) :: item
|
||||
write(iout,*) 'Value: ',item%key,item%val
|
||||
call flush(iout)
|
||||
end subroutine psb_print_item_key_val
|
||||
end module psb_item_mod
|
||||
|
||||
module psb_avl_mod
|
||||
|
||||
use psb_item_mod
|
||||
|
||||
integer, parameter :: LeftHigh = -1, EqualHeight=0, RightHigh=1
|
||||
integer, parameter :: AVLTreeDuplicate = -123, AVLTreeOK=0, &
|
||||
& AVLTreeOutOfMemory=-512, AVLTreeFatalError=-1024
|
||||
integer :: level,outlev
|
||||
integer, parameter :: poolsize = 1024
|
||||
|
||||
type psb_treenode_int2
|
||||
type(psb_item_int2) :: item
|
||||
type(psb_treenode_int2), pointer :: left=>null(), right=>null()
|
||||
integer :: balance
|
||||
end type psb_treenode_int2
|
||||
|
||||
type psb_treevect_int2
|
||||
type(psb_treenode_int2) :: pool(poolsize)
|
||||
integer :: avail
|
||||
type(psb_treevect_int2), pointer :: next=>null(), prev=>null()
|
||||
end type psb_treevect_int2
|
||||
|
||||
type psb_tree_int2
|
||||
type(psb_treevect_int2), pointer :: head=>null(), current=>null()
|
||||
type(psb_treenode_int2), pointer :: root=>null()
|
||||
integer :: nnodes
|
||||
end type psb_tree_int2
|
||||
|
||||
interface psb_sizeof
|
||||
module procedure psb_Sizeof_Tree_int2, psb_sizeof_node_int2
|
||||
end interface
|
||||
|
||||
interface InitSearchTree
|
||||
module procedure InitSearchTree_int2
|
||||
end interface
|
||||
|
||||
interface FreeSearchTree
|
||||
module procedure FreeSearchTree_int2
|
||||
end interface
|
||||
|
||||
interface SearchKey
|
||||
module procedure SearchKey_int2
|
||||
end interface
|
||||
|
||||
interface SearchInsKey
|
||||
module procedure SearchInsKey_int2
|
||||
end interface
|
||||
|
||||
interface GetAVLTree
|
||||
module procedure GetAVLTree_int2
|
||||
end interface
|
||||
|
||||
interface CloneSearchTree
|
||||
module procedure CloneSearchTree_int2
|
||||
end interface
|
||||
|
||||
interface CloneAVLTree
|
||||
module procedure CloneAVLTree_int2
|
||||
end interface
|
||||
|
||||
interface GetAVLNode
|
||||
module procedure GetAVLNode_int2
|
||||
end interface
|
||||
interface UnGetAVLNode
|
||||
module procedure UnGetAVLNode_int2
|
||||
end interface
|
||||
|
||||
interface VisitAVLTree
|
||||
module procedure VisitAVLTree_int2, VisitAVLTreeNode_int2
|
||||
end interface
|
||||
|
||||
interface VisitAVLTreeLev
|
||||
module procedure VisitAVLTreeLev_int2, VisitAVLTreeNodeLev_int2
|
||||
end interface
|
||||
|
||||
interface AVLTreeLeftBalance
|
||||
module procedure AVLTreeLeftBalance_int2
|
||||
end interface
|
||||
|
||||
interface AVLTreeRightBalance
|
||||
module procedure AVLTreeRightBalance_int2
|
||||
end interface
|
||||
|
||||
interface AVLTreeRotateLeft
|
||||
module procedure AVLTreeRotateLeft_int2
|
||||
end interface
|
||||
|
||||
interface AVLTreeRotateRight
|
||||
module procedure AVLTreeRotateRight_int2
|
||||
end interface
|
||||
|
||||
interface AVLSearchKey
|
||||
module procedure AVLSearchKey_int2
|
||||
end interface
|
||||
|
||||
interface AVLSearchInsKey
|
||||
module procedure AVLSearchInsKey_int2
|
||||
end interface
|
||||
|
||||
interface AVLSearchInsNode
|
||||
module procedure AVLSearchInsNode_int2
|
||||
end interface
|
||||
|
||||
contains
|
||||
|
||||
subroutine InitSearchTree_int2(tree, info)
|
||||
type(psb_tree_int2), pointer :: tree
|
||||
integer :: info
|
||||
|
||||
if (associated(tree)) then
|
||||
call FreeSearchTree(tree,info)
|
||||
end if
|
||||
call GetAVLTree(tree,info)
|
||||
|
||||
end subroutine InitSearchTree_int2
|
||||
|
||||
subroutine CloneSearchTree_int2(treein, treeout)
|
||||
type(psb_tree_int2), pointer :: treein,treeout
|
||||
integer :: info
|
||||
if (.not.associated(treein)) then
|
||||
treeout => null()
|
||||
return
|
||||
endif
|
||||
call GetAVLTree(treeout,info)
|
||||
call CloneAVLTree(treein%root,treeout)
|
||||
|
||||
end subroutine CloneSearchTree_int2
|
||||
|
||||
subroutine CloneAVLTree_int2(root, tree)
|
||||
type(psb_treenode_int2), pointer :: root
|
||||
type(psb_tree_int2), pointer :: tree
|
||||
integer :: info, key,val,next
|
||||
if (.not.associated(root)) return
|
||||
key = root%item%key
|
||||
next = root%item%val
|
||||
call SearchInsKey(tree,key,val,next,info)
|
||||
call CloneAVLTree(root%left,tree)
|
||||
call CloneAVLTree(root%right,tree)
|
||||
end subroutine CloneAVLTree_int2
|
||||
|
||||
subroutine FreeSearchTree_int2(tree, info)
|
||||
type(psb_tree_int2), pointer :: tree
|
||||
integer :: info
|
||||
type(psb_treevect_int2), pointer :: current,next
|
||||
|
||||
if (.not.associated(tree)) return
|
||||
current => tree%head
|
||||
do
|
||||
if (.not.associated(current)) exit
|
||||
next => current%next
|
||||
deallocate(current,stat=info)
|
||||
if (info /= 0) then
|
||||
info = AVLTreeFatalError
|
||||
return
|
||||
end if
|
||||
current => next
|
||||
end do
|
||||
deallocate(tree,stat=info)
|
||||
if (info /= 0) then
|
||||
info = AVLTreeFatalError
|
||||
return
|
||||
end if
|
||||
|
||||
end subroutine FreeSearchTree_int2
|
||||
|
||||
function psb_Sizeof_Tree_int2(tree)
|
||||
use psb_const_mod
|
||||
type(psb_tree_int2), pointer :: tree
|
||||
integer :: psb_Sizeof_Tree_int2
|
||||
integer :: val
|
||||
type(psb_treevect_int2), pointer :: current,next
|
||||
|
||||
val = 0
|
||||
if (associated(tree)) then
|
||||
current => tree%head
|
||||
do
|
||||
if (.not.associated(current)) exit
|
||||
val = val + 3*psb_sizeof_int + poolsize*psb_sizeof(current%pool(1))
|
||||
current => current%next
|
||||
end do
|
||||
end if
|
||||
psb_Sizeof_Tree_int2 = val
|
||||
end function psb_Sizeof_Tree_int2
|
||||
|
||||
function psb_sizeof_node_int2(node)
|
||||
|
||||
use psb_const_mod
|
||||
type(psb_treenode_int2) :: node
|
||||
integer :: psb_sizeof_node_int2
|
||||
integer :: val
|
||||
|
||||
|
||||
psb_sizeof_node_int2 = 3*psb_sizeof_int + psb_sizeof(node%item)
|
||||
|
||||
end function psb_sizeof_node_int2
|
||||
|
||||
subroutine SearchKey_int2(tree,key,val,info)
|
||||
type(psb_tree_int2), target :: tree
|
||||
integer :: key,val,info
|
||||
type(psb_item_int2), pointer :: retval
|
||||
info = 0
|
||||
call AVLSearchKey(tree,key,retval,info)
|
||||
if (associated(retval)) then
|
||||
val = retval%val
|
||||
else
|
||||
val = -1
|
||||
end if
|
||||
end subroutine SearchKey_int2
|
||||
|
||||
subroutine SearchInsKey_int2(tree,key,val, nextval,info)
|
||||
type(psb_tree_int2), target :: tree
|
||||
integer :: key,val,nextval,info
|
||||
|
||||
call AVLSearchInsKey(tree,key,val,nextval,info)
|
||||
|
||||
end subroutine SearchInsKey_int2
|
||||
|
||||
subroutine GetAVLTree_int2(tree, info)
|
||||
type(psb_tree_int2), pointer :: tree
|
||||
integer :: info
|
||||
|
||||
allocate(tree, stat=info)
|
||||
if (info == 0) allocate(tree%head,stat=info)
|
||||
if (info == 0) then
|
||||
tree%current => tree%head
|
||||
tree%head%avail = 0
|
||||
tree%nnodes=0
|
||||
end if
|
||||
|
||||
if (info /= 0) then
|
||||
write(0,*) 'Failed allocation 1 GetAVLTree '
|
||||
info = AVLTreeOutOfMemory
|
||||
|
||||
return
|
||||
end if
|
||||
|
||||
end subroutine GetAVLTree_int2
|
||||
|
||||
subroutine VisitAVLTree_int2(tree, info,iout)
|
||||
type(psb_tree_int2), pointer :: tree
|
||||
integer :: info
|
||||
integer, optional :: iout
|
||||
|
||||
info = 0
|
||||
if (.not.associated(tree)) return
|
||||
call VisitAVLTree(tree%root,iout)
|
||||
|
||||
end subroutine VisitAVLTree_int2
|
||||
|
||||
recursive subroutine VisitAVLTreeNode_int2(root,iout)
|
||||
type(psb_treenode_int2), pointer :: root
|
||||
integer, optional :: iout
|
||||
integer :: info
|
||||
|
||||
if (.not.associated(root)) return
|
||||
call VisitAVLTree(root%left,iout)
|
||||
if (present(iout)) then
|
||||
call psb_print_item_key_val(iout,root%item)
|
||||
else
|
||||
call psb_print_item_key_val(6,root%item)
|
||||
end if
|
||||
call VisitAVLTree(root%right,iout)
|
||||
end subroutine VisitAVLTreeNode_int2
|
||||
|
||||
subroutine VisitAVLTreeLev_int2(tree, info)
|
||||
type(psb_tree_int2), pointer :: tree
|
||||
integer :: info
|
||||
|
||||
if (.not.associated(tree)) return
|
||||
do outlev = 0, 3
|
||||
write(6,*) 'Tree level : ',outlev
|
||||
call VisitAVLTreeLev(tree%root,0)
|
||||
end do
|
||||
|
||||
end subroutine VisitAVLTreeLev_int2
|
||||
|
||||
recursive subroutine VisitAVLTreeNodeLev_int2(root,level)
|
||||
type(psb_treenode_int2), pointer :: root
|
||||
integer :: info,level
|
||||
|
||||
if (.not.associated(root)) return
|
||||
call VisitAVLTreeLev(root%left,level+1)
|
||||
if (level == outlev) call psb_print_item_key_val(6,root%item)
|
||||
call VisitAVLTreeLev(root%right,level+1)
|
||||
end subroutine VisitAVLTreeNodeLev_int2
|
||||
|
||||
|
||||
function GetAVLNode_int2(tree, info)
|
||||
type(psb_tree_int2), target :: tree
|
||||
type(psb_treenode_int2), pointer :: GetAVLNode_int2
|
||||
integer :: info
|
||||
type(psb_treevect_int2), pointer :: current, temp
|
||||
|
||||
GetAVLNode_int2 => null()
|
||||
|
||||
if (.not.associated(tree%current)) then
|
||||
allocate(tree%head,stat=info)
|
||||
if (info /= 0) then
|
||||
info = AVLTreeOutOfMemory
|
||||
return
|
||||
end if
|
||||
tree%current => tree%head
|
||||
tree%current%avail = 0
|
||||
end if
|
||||
current => tree%current
|
||||
do
|
||||
if (current%avail < poolsize) exit
|
||||
if (.not.(associated(current%next))) then
|
||||
allocate(temp,stat=info)
|
||||
if (info /= 0) then
|
||||
info = AVLTreeOutOfMemory
|
||||
return
|
||||
end if
|
||||
temp%avail = 0
|
||||
temp%prev => current
|
||||
current%next => temp
|
||||
end if
|
||||
current => current%next
|
||||
end do
|
||||
tree%current => current
|
||||
current%avail = current%avail + 1
|
||||
GetAVLNode_int2 => current%pool(current%avail)
|
||||
|
||||
end function GetAVLNode_int2
|
||||
|
||||
subroutine UnGetAVLNode_int2(tree, info)
|
||||
type(psb_tree_int2), target :: tree
|
||||
integer :: info
|
||||
|
||||
|
||||
if (.not.associated(tree%current)) then
|
||||
return
|
||||
end if
|
||||
if (tree%current%avail > 0) &
|
||||
& tree%current%avail = tree%current%avail - 1
|
||||
return
|
||||
end subroutine UnGetAVLNode_int2
|
||||
|
||||
subroutine AVLSearchKey_int2(tree,key,retval,info)
|
||||
type(psb_tree_int2), target :: tree
|
||||
integer :: key,info
|
||||
type(psb_item_int2), pointer :: retval
|
||||
type(psb_treenode_int2), pointer :: root
|
||||
|
||||
retval => null()
|
||||
root => tree%root
|
||||
do
|
||||
if (.not.associated(root)) exit
|
||||
if (key < root%item%key) then
|
||||
root => root%left
|
||||
else if (key == root%item%key) then
|
||||
retval => root%item
|
||||
exit
|
||||
else if (key > root%item%key) then
|
||||
root => root%right
|
||||
end if
|
||||
end do
|
||||
|
||||
end subroutine AVLSearchKey_int2
|
||||
|
||||
subroutine AVLSearchInsKey_int2(tree,key,val,nextval,info)
|
||||
type(psb_tree_int2), target :: tree
|
||||
integer :: key,val,nextval,info
|
||||
type(psb_treenode_int2), pointer :: itemp
|
||||
logical :: taller
|
||||
|
||||
itemp => GetAVLNode(tree,info)
|
||||
if (info /=0) then
|
||||
return
|
||||
end if
|
||||
if (.not.associated(itemp)) then
|
||||
info = -5
|
||||
return
|
||||
endif
|
||||
itemp%item%key = key
|
||||
itemp%item%val = nextval
|
||||
itemp%left => null()
|
||||
itemp%right => null()
|
||||
|
||||
call AVLSearchInsNode(tree%root,itemp,taller,info)
|
||||
val = itemp%item%val
|
||||
if (info == AVLTreeDuplicate) then
|
||||
call UnGetAVLNode(tree,info)
|
||||
!!$ write(0,*) 'From searchInsNode ',key,val,nextval
|
||||
info = 0
|
||||
return
|
||||
else if (info == AVLTreeOK) then
|
||||
tree%nnodes = tree%nnodes + 1
|
||||
info = 0
|
||||
return
|
||||
else
|
||||
write(0,*) 'Error from inner SearchInsNode '
|
||||
endif
|
||||
|
||||
end subroutine AVLSearchInsKey_int2
|
||||
|
||||
|
||||
recursive subroutine AVLSearchInsNode_int2(root,node,taller,info)
|
||||
type(psb_treenode_int2), pointer :: root, node
|
||||
integer :: info
|
||||
logical :: taller
|
||||
|
||||
info = AVLTreeOK
|
||||
taller = .false.
|
||||
if (.not.associated(root)) then
|
||||
root => node
|
||||
node%balance = EqualHeight
|
||||
node%left => null()
|
||||
node%right => null()
|
||||
taller = .true.
|
||||
else if (node%item%key == root%item%key) then
|
||||
!!$ write(0,*) 'SearchInsNode : found key',node%item%key,node%item%val,&
|
||||
!!$ &root%item%key,root%item%val
|
||||
info = AVLTreeDuplicate
|
||||
node%item%val = root%item%val
|
||||
return
|
||||
|
||||
else if (node%item%key < root%item%key) then
|
||||
|
||||
call AVLSearchInsNode(root%left,node,taller,info)
|
||||
if (info == AVLTreeDuplicate) return
|
||||
if (info == AVLTreeFatalError) return
|
||||
if (taller) then
|
||||
select case(root%balance)
|
||||
case(LeftHigh)
|
||||
call AVLTreeLeftBalance(root,taller)
|
||||
case(EqualHeight)
|
||||
root%balance = LeftHigh
|
||||
case(RightHigh)
|
||||
root%balance = EqualHeight
|
||||
taller = .false.
|
||||
case default
|
||||
info = AVLTreeFatalError
|
||||
end select
|
||||
end if
|
||||
else if (node%item%key > root%item%key) then
|
||||
call AVLSearchInsNode(root%right,node,taller,info)
|
||||
if (info == AVLTreeDuplicate) return
|
||||
if (info == AVLTreeFatalError) return
|
||||
if (taller) then
|
||||
select case(root%balance)
|
||||
case(LeftHigh)
|
||||
root%balance = EqualHeight
|
||||
taller = .false.
|
||||
case(EqualHeight)
|
||||
root%balance = RightHigh
|
||||
case(RightHigh)
|
||||
call AVLTreeRightBalance(root,taller)
|
||||
case default
|
||||
info = AVLTreeFatalError
|
||||
end select
|
||||
end if
|
||||
end if
|
||||
|
||||
end subroutine AVLSearchInsNode_int2
|
||||
|
||||
|
||||
|
||||
recursive subroutine AVLTreeLeftBalance_int2(root,taller)
|
||||
type(psb_treenode_int2), pointer :: root
|
||||
logical :: taller
|
||||
|
||||
type(psb_treenode_int2), pointer :: rs, ls
|
||||
|
||||
ls => root%left
|
||||
select case (ls%balance)
|
||||
case(LeftHigh)
|
||||
root%balance = EqualHeight
|
||||
ls%balance = EqualHeight
|
||||
call AVLTreeRotateRight(root)
|
||||
taller = .false.
|
||||
case(EqualHeight)
|
||||
write(0,*) 'Warning: balancing and already balanced left tree? '
|
||||
case(RightHigh)
|
||||
rs => ls%right
|
||||
select case(rs%balance)
|
||||
case(LeftHigh)
|
||||
root%balance = RightHigh
|
||||
ls%balance = EqualHeight
|
||||
case(EqualHeight)
|
||||
root%balance = EqualHeight
|
||||
ls%balance = EqualHeight
|
||||
case(RightHigh)
|
||||
root%balance = EqualHeight
|
||||
ls%balance = LeftHigh
|
||||
end select
|
||||
rs%balance = EqualHeight
|
||||
call AVLTreeRotateLeft(root%left)
|
||||
call AVLTreeRotateRight(root)
|
||||
taller = .false.
|
||||
end select
|
||||
|
||||
end subroutine AVLTreeLeftBalance_int2
|
||||
|
||||
|
||||
recursive subroutine AVLTreeRightBalance_int2(root,taller)
|
||||
type(psb_treenode_int2), pointer :: root
|
||||
logical :: taller
|
||||
type(psb_treenode_int2), pointer :: rs, ls
|
||||
|
||||
rs => root%right
|
||||
select case (rs%balance)
|
||||
case(RightHigh)
|
||||
root%balance = EqualHeight
|
||||
rs%balance = EqualHeight
|
||||
call AVLTreeRotateLeft(root)
|
||||
taller = .false.
|
||||
case(EqualHeight)
|
||||
write(0,*) 'Warning: balancing and already balanced right tree? '
|
||||
case(LeftHigh)
|
||||
ls => rs%left
|
||||
select case(ls%balance)
|
||||
case(RightHigh)
|
||||
root%balance = LeftHigh
|
||||
rs%balance = EqualHeight
|
||||
case(EqualHeight)
|
||||
root%balance = EqualHeight
|
||||
rs%balance = EqualHeight
|
||||
case(LeftHigh)
|
||||
root%balance = EqualHeight
|
||||
rs%balance = RightHigh
|
||||
end select
|
||||
ls%balance = EqualHeight
|
||||
call AVLTreeRotateRight(root%right)
|
||||
call AVLTreeRotateLeft(root)
|
||||
taller = .false.
|
||||
end select
|
||||
end subroutine AVLTreeRightBalance_int2
|
||||
|
||||
|
||||
|
||||
subroutine AVLTreeRotateLeft_int2(root)
|
||||
type(psb_treenode_int2), pointer :: root
|
||||
type(psb_treenode_int2), pointer :: temp
|
||||
if (.not.associated(root)) then
|
||||
return
|
||||
endif
|
||||
if (.not.associated(root%right)) then
|
||||
return
|
||||
endif
|
||||
temp => root%right
|
||||
root%right => temp%left
|
||||
temp%left => root
|
||||
root => temp
|
||||
|
||||
end subroutine AVLTreeRotateLeft_int2
|
||||
|
||||
subroutine AVLTreeRotateRight_int2(root)
|
||||
type(psb_treenode_int2), pointer :: root
|
||||
type(psb_treenode_int2), pointer :: temp
|
||||
if (.not.associated(root)) then
|
||||
return
|
||||
endif
|
||||
if (.not.associated(root%left)) then
|
||||
return
|
||||
endif
|
||||
temp => root%left
|
||||
root%left => temp%right
|
||||
temp%right => root
|
||||
root => temp
|
||||
|
||||
end subroutine AVLTreeRotateRight_int2
|
||||
|
||||
|
||||
end module psb_avl_mod
|
||||
Loading…
Reference in New Issue