/*
Merge two sorted lists A and B as one linked list
Node is defined as
struct Node
{
int data;
struct Node *next;
}
*/
Node* MergeLists(Node *headA, Node* headB)
{
// This is a "method-only" submission.
// You only need to complete this method
Node* result = NULL;
/* Base cases */
if (headA == NULL)
return(headB);
else if (headB==NULL)
return(headA);
/* Pick either a or b, and recur */
if (headA->data <= headB->data)
{
result = headA;
result->next = MergeLists(headA->next, headB);
}
else
{
result = headB;
result->next = MergeLists(headA, headB->next);
}
return(result);
}
/*
Merge two sorted lists A and B as one linked list
Node is defined as
struct Node
{
int data;
struct Node *next;
}
*/
Node* MergeLists(Node *headA, Node* headB)
{
Node *list1 = headA;
Node *list2 = headB;
if (list1 == NULL) return list2;
if (list2 == NULL) return list1;
if (list1->data < list2->data) {
list1->next = MergeLists(list1->next, list2);
return list1;
} else {
list2->next = MergeLists(list2->next, list1);
return list2;
}
}
/*
Merge two sorted lists A and B as one linked list
Node is defined as
struct Node
{
int data;
struct Node *next;
}
*/
Node* MergeLists(Node *headA, Node* headB)
{
if (headA == NULL) return headB;
if (headB == NULL) return headA;
if (headA->data < headB->data){
headA->next = MergeLists(headA->next, headB);
return headA;
} else {
headB->next = MergeLists(headA, headB->next);
return headB;
}
}
int
main ()
{
Node *A = NULL;
Node *B = NULL;
A = Insert (A, 0);
A = Insert (A, 3);
A = Insert (A, 5);
A = Insert (A, 6);
A = Insert (A, 7);
A = Insert (A, 8);
B = Insert (B, 1);
B = Insert (B, 2);
B = Insert (B, 3);
B = Insert (B, 4);
B = Insert (B, 5);
B = Insert (B, 6);
B = Insert (B, 7);
B = Insert (B, 8);
B = Insert (B, 9);
Print (A);
Print (B);
A = MergeLists (A, B);
Print (A);
}
void MergeLists( ListNode *a, ListNode *b, ListNode **result )
{
if( a || b )
{
if( a && b )
{
if( a->data <= b->data )
{
(*result) = a;
a = a->next;
(*result)->next = NULL;
}
else
{
(*result) = b;
b = b->next;
(*result)->next = NULL;
}
MergeLists( a, b, &( (*result)->next ) );
}
else
{
if( a && !b )
{
(*result) = a;
}
else
{
(*result) = b;
}
}
}
}
ProcItemsEnumerator(ULONG theOptions) : myOptions(theOptions), myCurIndex(), myEffective(0)
{
if ( (myOptions & (ENUMOPTIONS_FOLDERS_ON_TOP|ENUMOPTIONS_FOLDERS_ON_BTM)) != 0)
FillLists<true>();
else
FillLists<false>();
if ( (myOptions & ENUMOPTIONS_SORT_ITEMS) != 0)
SortLists();
MergeLists( (myOptions & ENUMOPTIONS_FOLDERS_ON_BTM) == 0);
}
/*
Merge two sorted lists A and B as one linked list
Node is defined as
struct Node
{
int data;
struct Node *next;
}
*/
Node* MergeLists(Node *headA, Node* headB)
{
struct Node* head = NULL;
if (headA == NULL)
return(headB);
else if (headB==NULL)
return(headA);
if (headA->data <= headB->data)
{
head = headA;
head->next = MergeLists(headA->next, headB);
}
else
{
head = headB;
head->next = MergeLists(headA, headB->next);
}
return(head);
}
/*
Merge two sorted lists A and B as one linked list
Node is defined as
struct Node
{
int data;
struct Node *next;
}
*/
Node* MergeLists(Node *headA, Node* headB)
{
// This is a "method-only" submission.
// You only need to complete this method
Node* temp;
if(headA==NULL)
return headB;
else if(headB==NULL)
return headA;
else if(headA!=NULL && headB!=NULL){
if(headA->data<headB->data){
temp = headA->next;
headA->next = MergeLists(temp,headB);
return headA;
}
else{
temp = headB->next;
headB->next = MergeLists(headA,temp);
return headB;
}
}
else
return NULL;
}
void MergeSortOnLL( ListNode **headRef )
{
// If 0 or 1 elements in the input list, return from here.
if( !(*headRef) || !(*headRef)->next )
return;
ListNode* a = NULL;
SplitList( (*headRef), &a );
ListNode *temp = a->next;
a->next = NULL;
MergeSortOnLL( headRef );
MergeSortOnLL( &temp );
ListNode *result = NULL;
MergeLists( *headRef, temp, &result );
*headRef = result;
}
/*
Merge two sorted lists A and B as one linked list
Node is defined as
struct Node
{
int data;
struct Node *next;
}
*/
Node* MergeLists(Node *headA, Node* headB) {
if (headA == NULL) {
return headB;
} else if (headB == NULL) {
return headA;
}
Node *resultHead, *currentA = headA, *currentB = headB;
if (headA && headB) {
if (headA->data < headB->data) {
resultHead = headA;
currentA = currentA->next;
} else {
resultHead = headB;
currentB = currentB->next;
}
}
resultHead->next = MergeLists(currentA, currentB);
return resultHead;
}
/*
* Arma el grafo para graficar.
*/
graphADT
BuildPreliminarGraph(listADT list)
{
graphADT g = NewGraph();
actInfo * info, * auxInfo;
stageADT stg = NULL;
/*Lista de precedentes insertados que llegan al sumidero. Drain Connected Precendences.*/
listInfADT dcp;
/*Lista de precedentes insertados que no llegan al sumidero. Non Drain Connected Precedences.*/
listInfADT ndcp;
/*Lista de precedentes no creados. Non Created Precedences.*/
listInfADT ncp;
listInfADT mergeList;
listInfADT auxList = list; /*Se recorrera sobre esta lista.*/
activityADT act, auxAct;
while(!listInfIsEmpty(auxList))
{
dcp = newInfList(); /*Inicializo las listas.*/
ndcp = newInfList();
ncp = newInfList();
mergeList = newInfList();
info = listInfHead(list);
act = InsertActivity(g, info, NULL, GetDrain(g)); /*Creo la actividad y la
conecto al sumidero.*/
if(strcmp(info->precedencies[0], "Fuente"))
{ /*Si las precedencias NO son la fuente*/
stg = InsertStage(g); /*genero una nueva etapa y la conecto a ella.*/
SetActivityOrig(g, info->ID, stg);
}
SetPrecedencesLists(g, list, &ncp, &dcp, &ndcp, info->precedencies); /*Armo las listas.*/
if(!listInfIsEmpty(ncp))
{
stg = InsertStage(g);
while(!listInfIsEmpty(ncp))
{
auxInfo = listInfHead(ncp);
auxAct = InsertActivity(g, auxInfo, NULL, stg);
ncp = listInfTail(ncp);
}
}
if(!listInfIsEmpty(ndcp))
{
if(stg == NULL)
{
stg = InsertStage(g); /*Setea al nodo nuevo*/
SetActivityOrig(g, info->ID, stg); /*como origen de la actividad.*/
}
mergeList = MergeLists(ndcp, info->precedencies);
CreateFictitious(g, mergeList);
}
if(!listInfIsEmpty(dcp))
{
if(stg == NULL)
stg = InsertStage(g); /*Sus precedencias que terminaban en el sumidero*/
ConnectPrecDestStage(g, dcp, stg); /*ahora apuntan a la nueva act.*/
}
if(stg == NULL && IsSourcePrec(info->precedencies)) /*Si la fuente esta como*/
SetActivityOrig(g, info->ID, GetSource(g)); /*precedencia, la conecto con ella.*/
stg = NULL;
auxList = listInfTail(list);
freeInfList(&dcp);
freeInfList(&ndcp);
freeInfList(&ncp);
freeInfList(&mergeList);
}
}
LOCAL void C6CnvtStructType (TENTRY *OldEntry)
{
uchar *TypeString;
int index;
uchar *OldString;
ushort Count; // number of fields
ulong Length; // length of structure
int fList; // new field spec list
int i;
CV_prop_t property = {0}; // property byte
plfStructure plf;
uchar chName[MAXSTRLEN + 1];
ushort usNTotal; // New length of symbol including length field
ushort usNewLength; // New paded length excluding length field.
uchar chVarData[MAXNUMERICLEN];
uchar *pchVarData = chVarData;
ushort cbVarNew; // Count of bytes of new variable length field
uchar *pchSrc;
uchar *pchDest;
ushort usOldLen;
ulong ulCount;
OldEntry->flags.IsNewFormat = TRUE;
TypeString = OldEntry->TypeString;
usOldLen = *((ushort UNALIGNED *)(TypeString + 1));
AddNewSymbols = TRUE; //???????
OldString = TypeString;
TypeString += 4;
// get length in bits
Length = C6GetLWordFromNumeric (&TypeString, NULL);
// convert to bytes
if (Length != 0) {
Length = (Length - 1) / 8 + 1;
}
// Convert to new style Numeric
cbVarNew = C7StoreLWordAsNumeric (chVarData, Length);
ulCount = C6GetLWordFromNumeric(&TypeString, NULL);
// If the count is above 64K (it should never be) then make it 64K
Count = ulCount <= 0xFFFFL ? (ushort)ulCount : (ushort)0xFFFF;
index = getindex (TypeString); // tList index
fList = MergeLists ((ushort)index, (ushort)(getindex (TypeString)), Count);
chName[0] = 0;
if (TypeString < OldString + LENGTH (OldString) + 3) {
if (*TypeString == OLF_NAME) {
// name present
TypeString++;
memcpy (chName, TypeString, *TypeString + 1);
TypeString += *TypeString + 1;
if (TypeString < OldString + LENGTH (OldString) + 3) {
property.packed = (char)(*TypeString == OLF_PACKED);
}
else {
property.packed = FALSE;
}
}
else {
property.packed = (char)(*TypeString == OLF_PACKED);
}
}
else {
property.packed = FALSE;
}
// calculate new length
usNTotal = LNGTHSZ + offsetof (lfStructure, data) + cbVarNew + chName[0] + 1;
usNewLength = usNTotal - LNGTHSZ;
// Determine where the new symbol goes in memory
if (usNewLength <= usOldLen + 3 - LNGTHSZ) {
pchDest = OldString; // Copy new symbol over the old
}
else {
pchDest = AllocNewStr (OldEntry, (ushort)(usNewLength + LNGTHSZ));
}
*((ushort *)pchDest)++ = usNewLength;
plf = (plfStructure)pchDest;
plf->leaf = LF_STRUCTURE;
plf->count = Count;
plf->field = fList;
plf->property = property;
plf->derived = 0;
plf->vshape = 0;
pchDest += offsetof (lfStructure, data);
// Copy variable length "length" field
for (pchSrc = chVarData, i = cbVarNew; i > 0; i--) {
*pchDest++ = *pchSrc++;
}
// Copy the name field
for (pchSrc = chName, i = chName[0] + 1; i; i--) {
*pchDest++ = *pchSrc++;
}
DASSERT(pchDest == OldEntry->TypeString + usNewLength + LNGTHSZ);
}
