void test_InsertFirst(void) { Status status = ERROR; GENERALIZED_LIST_TYPE element, list = getGeneralizedList("(1,2)"); if (list == NULL) return; list = NULL; element = getGeneralizedList("(1)"); status = InsertFirst(&list, &element); CU_ASSERT_EQUAL(status, OK); assertEqual(list, "(1)"); list = getGeneralizedList("(2)"); element = getGeneralizedList("(1)"); status = InsertFirst(&list, &element); CU_ASSERT_EQUAL(status, OK); assertEqual(list, "(1,2)"); list = getGeneralizedList("((21,22,23,24,25),3,(4,(51,52,53,(501,502))))"); element = getGeneralizedList("(11,12,13)"); status = InsertFirst(&list, &element); CU_ASSERT_EQUAL(status, OK); assertEqual(list, "((11,12,13),(21,22,23,24,25),3,(4,(51,52,53,(501,502))))"); }
int main(void) { // ---------------------------------------------Declarations------------------------------------------------- clock_t time; time = clock(); char *my_string; size_t size=100000; ll str_size,i,j; // -------------------------------------------Inputing String------------------------------------------------ my_string = (char *) malloc (size + 1); // gives back the size of the string str_size = getline (&my_string, &size, stdin); if(str_size==-1){ printf("Error\n"); } else{ printf("Your string is : %s\n",my_string); } // ----------------------------------------------Finding all 1-palindromes---------------------------------------------- pairs *pal[str_size/2][str_size]; ll count[str_size/2]; for(i=0;i<str_size/2;i++) count[i]=0; for(i=0;i<str_size/2;i++){ for(j=0;j<str_size;j++) pal[i][j]=NULL; } for(i=0;i<str_size;i++){ for(j=i+1;j<str_size;j++){ if(my_string[i]==my_string[j]){ pair no; no.first=i;no.second=j; InsertFirst(&pal[0][count[0]],no); InsertFirst(&pal[1][count[1]],no); count[0]++; count[1]++; } } } printf("%lld\n",count[1]); printPal(pal[1],count[1]); // ------------------------------------------------------------------------------------------------------------------- ll k; for(k=2;k<str_size/2;k++){ for(i=0;i<count[k-1];i++){ for(j=0;j<count[0];j++){ Check(&pal[1][j],&pal[k-1][i],&pal[k][count[k]],&count[k],k); } } printPal(pal[k],count[k]); } // --------------------------------------------------Calculating Running Time--------------------------------------------- time = clock() - time; double time_taken = ((double)time)/CLOCKS_PER_SEC; printf("Time: %f seconds to execute \n", time_taken); return 0; }
void DisplayElement::SortByZIndex (void) { DisplayElement *unsorted = mpFirstChild, *child, *leastOfThese, *sorted = 0; // Bubble sort for now, just to test that it works while (unsorted) { leastOfThese = unsorted; child = unsorted; while (child) { if (child->GetZIndex() < leastOfThese->GetZIndex()) { leastOfThese = child; } child = child->mpNext; } if (!sorted) { InsertFirst(leastOfThese); } else { if (sorted->mpNext != leastOfThese) { InsertAfter(sorted, leastOfThese); } } sorted = unsorted; unsorted = unsorted->mpNext; } }
List FInversList (List L) /* Mengirimkan list baru, hasil invers dari L */ /* dengan menyalin semua elemn list. Alokasi mungkin gagal. */ /* Jika alokasi gagal, hasilnya list kosong */ /* dan semua elemen yang terlanjur di-alokasi, harus didealokasi */ { List InversedList; addressList InversP, P = First(L); int success = 1; CreateEmptyList(&InversedList); while (P != NULL && success) { InversP = Alokasi(Info(P)); if (InversP != NULL) { InsertFirst(&InversedList, InversP); P = Next(P); } else { success = 0; } } if (!success) DelAll(&InversedList); return InversedList; }
void CVirtBaseList::InsertAfter(CVirtBaseListItem* pBeforeItem, CVirtBaseListItem* pNewItem) { ASSERT(pNewItem != NULL); if (pBeforeItem == NULL) InsertFirst(pNewItem); // Insert at start of list if pBeforeItem is NULL if (pBeforeItem->m_pNext != NULL) pBeforeItem->m_pNext->m_pPrev = pNewItem; else m_pLast = pNewItem; pNewItem->m_pPrev = pBeforeItem; pNewItem->m_pNext = pBeforeItem->m_pNext; pBeforeItem->m_pNext = pNewItem; };
void CBareList::InsertAfter(CBareListItem* pBeforeItem, CBareListItem* pNewItem) { if (pBeforeItem == 0) InsertFirst(pNewItem); // Insert at start of list if pBeforeItem is 0 if (pBeforeItem->m_pNext != 0) pBeforeItem->m_pNext->m_pPrev = pNewItem; else m_pLast = pNewItem; pNewItem->m_pPrev = pBeforeItem; pNewItem->m_pNext = pBeforeItem->m_pNext; pBeforeItem->m_pNext = pNewItem; m_nCount++; };
/*** PENAMBAHAN ELEMEN ***/ void InsVFirst(List *L, infotypeList X) /* I.S. L mungkin kosong */ /* F.S. Melakukan alokasi sebuah elemen dan */ /* menambahkan elemen pertama dengan nilai X jika alokasi berhasil */ { addressList P = Alokasi(X); if (P != NULL) InsertFirst(L, P); }
/* Penambahan Elemen */ void InsVFirst (List *L, infotype X) { /* Kamus Lokal */ address P; /* Algoritma */ P = Alokasi(X); if (P != Nil) { InsertFirst(L,P); } }
void InsVFirst (List *L,infotype X) { /* I.S. L mungkin kosong */ /* F.S. Melakukan alokasi sebuah elemen dan menambahkan elemen pertama dengan nilai X jika alokasi berhasil */ address P = Alokasi(X); if(P!=Nil) InsertFirst(L,P); else printf("Allocation failed. \n"); }
int test_InsertFirst() { solved=TRUE; InsertFirst(&TEMPLIST,ElemValue); if (!solved) { printf("Operace InsertFirst nebyla implementována!\n"); return(FALSE); } else { print_elements_of_list(TEMPLIST); return(TRUE); } }
void InversList (List *L) { /* Kamus Lokal */ address P, Pt; /* Algoritma */ CreateList(&Lt); if (P != Nil) { while (Next(P) != Nil) { Pt = Next(P); DelAfter(L,P,Pt); InsertFirst(L,Pt); } } }
void InsertLast (List *L, address P) { /* Kamus Lokal */ address Last; /* Algoritma */ Last = First(*L); if (First(*L) == Nil) { InsertFirst(L,P); } else { while (Next(Last) != Nil) { Last = Next(Last); } InsertAfter(L,P,Last) } }
void InsertLast(List *L, addressList P) /* I.S. Sembarang, P sudah dialokasi */ /* F.S. P ditambahkan sebagai elemen terakhir yang baru */ { if (IsEmptyList(*L)) { InsertFirst(L, P); } else { addressList Last = First(*L); while (Next(Last) != NULL) Last = Next(Last); InsertAfter(L, P, Last); } }
// Insert "value" at the end of the list bool LList::InsertLast (const int & value) { if(size==0)return InsertFirst(value); LNode * ptr = new LNode; if(ptr==NULL)return false; ptr->data = value; ptr->next = NULL;// the new node points to null because it is the last pointer LNode *tmp = new LNode;// create a new node to travers down the node list tmp = first; while(tmp->next!=NULL){ tmp=tmp->next;// last node in the list } tmp->next=ptr;// takes the last pointer and has it point to the new node size++;// since a node was added, it increases the size return true; }
void InsertLast (ListPlayer *L, AddressOfPlayer P) /* I.S. Sembarang, P sudah dialokasi F.S. P ditambahkan sebagai elemen terakhir yang baru */ { if (IsLPlayerEmpty(*L)) { InsertFirst(L,P); } else { AddressOfPlayer Last=First(*L); while (Next(Last)!=First(*L)) { Last=Next(Last); } Next(Last) = P; Next(P) = First(*L); } }
void InsertLast (List *L,address P) { /* I.S. Sembarang, P sudah dialokasi */ /* F.S. P ditambahkan sebagai elemen terakhir yang baru, */ /*yaitu menjadi elemen sebelum dummy */ //Kamus Lokal address Pt; //Algoritma if (IsListEmpty(*L)) InsertFirst(L,P); else { Pt = First(*L); Prev(Pt) = P; Next(P) = Pt; Pt = Last(*L); Next(Pt) = P; Prev(P) = Pt; Last(*L) = P; } }
void DisplayElement::InsertOrdered (DisplayElement *pChild) { DisplayElement *place = mpLastChild; long zIndex = pChild->GetZIndex(); while (place) { if (place->GetZIndex() <= zIndex) { // check to make sure we aren't trying to insert child after itself if (place != pChild) { InsertAfter(place, pChild); } return; } place = place->mpPrev; } InsertFirst(pChild); }
List FInversList (List L) { /* Kamus Lokal */ List Li; address P, Pt; boolean gagal; /* Algoritma */ gagal = false; CreateList(&Li); P = First(L); while ((P != Nil) && (!gagal)) { Pt = Alokasi(Info(P)); if (Pt != Nil) { InsertFirst(&Li, Pt); P = Next(P); } else { DelAll(&Li); gagal = true; } } return Li; }