int main(int argc, const char * argv[]) {
FILE *file = fopen(argv[1], "r");
char line[1024];
while(fgets(line, 1024, file)) {
//printf("%s", line);
}
struct node *aList;
initializeLinkedList(&aList);
insertBack(9, &aList);
insertBack(61, &aList);
insertFront(0, &aList);
deleteFront(&aList);
insertFront(109, &aList);
insertFront(81, &aList);
insertBack(1890, &aList);
printf("%s\n", "printing list:");
printLinkedList(&aList);
destroyLinkedList(&aList);
printf("got %d\n", ant);
fclose(file);
#ifndef _MY_MYTEST_H_
printf("defining");
#endif
return 0;
}
bool LinkedList::insert(Node_entry el){
Node *newNode, *aux;//, *currentNode;//, *nextNode;
if (front==NULL){
insertFront(el);
return true;
}
if(el<front->entry){
insertFront(el);
return true;
}
if(el>rear->entry){
insertRear(el);
return true;
}
newNode = new Node(el);
if(newNode == NULL) return false;
aux = front;
while(el>=aux->entry){
aux = aux->next;
}
newNode->next = aux;
newNode->prev = aux->prev;
aux->prev=newNode;
return true;
}
int main()
{
Node *l = insertFront(0, NULL);
for (int i = 1; i < 10; ++i) {
l = insertFront(i, l);
}
printList(l);
l = reverseList(l);
printList(l);
deleteList(l);
}
/* BFS */
void BFS(GraphRef G, int s){
ListRef Q = newList();
int v, w, i;
G->source = s;
insertFront(Q, s);
G->color[s] = 2;
G->distance[s] = 0;
while(getLength(Q) > 0){
moveTo(Q, 0);
v = getCurrent(Q);
G->color[v] = 3;
deleteCurrent(Q);
if(!isEmpty(G->adj[v])){
moveTo(G->adj[v], 0);
for(i=0;i<getLength(G->adj[v]);i++){
w = getCurrent(G->adj[v]);
if(G->color[w] < 2){
G->color[w] = 2;
G->parent[w] = v;
G->distance[w] = G->distance[v]+1;
insertBack(Q, w);
}
if(i<getLength(G->adj[v])-1){
moveNext(G->adj[v]);
}
}
}
}
freeList(&Q);
}
void BFS(GraphRef G, int s){
int i, u, tmp;
G->source = s;
for ( i = 1;i <= getOrder(G); i++){
G->color[i] = 'w';
G->discover[i] = INF;
G->parent[i] = NIL;
}
G->color[s] = 'g';
G->discover[s] = 0;
G->parent[s] = NIL;
ListRef Q = newList();
insertFront( Q, s );
while( !isEmpty(Q) ){
u = getFront(Q);
deleteFront(Q);
moveTo(G->adjacency[u], 0);
while ( !offEnd(G->adjacency[u]) ){
tmp = getCurrent(G->adjacency[u]);
if ( G->color[tmp] == 'w'){
G->color[tmp] = 'g';
G->discover[tmp] = G->discover[u] + 1;
G->parent[tmp] = u;
insertBack( Q, tmp );
}
moveNext(G->adjacency[u]);
}
G->color[u] = 'b';
}
freeList(&Q);
}
int main(void){
Card card;
Node *root = NULL, *ptr;
printf("Enter name and age > ");
while(scanf("%s %d", card.name, &card.age) !=EOF)
{
insertFront( &root, card );
ptr = root;
while ( ptr != NULL ) {
printNode(ptr->card );
ptr = ptr->next;
}
while ( root != NULL )
removeFront( &root );
}
return (0);
}
int main()
{
int numberOfNodes = 0;
scanf("%d", &numberOfNodes);
int numberOfEdges = 0;
scanf("%d", &numberOfEdges);
List nodes[numberOfNodes + 1];
nodesPtr = nodes;
int i = 0;
for (i = 0; i <= numberOfNodes; i++) {
nodes[i].first = NULL;
nodes[i].count = 0;
}
int tempParent, tempChild;
for (i = 0; i < numberOfEdges; i++) {
scanf("%d", &tempParent);
scanf("%d", &tempChild);
insertFront(&nodes[tempParent], tempChild);
insertFront(&nodes[tempChild], tempParent);
}
int queries;
scanf("%d", &queries);
int query[MAX_QUERIES][2];
int startNode, endNode;
for (i = 0; i < queries; i++) {
scanf("%d", &query[i][0]);
scanf("%d", &query[i][1]);
}
for (i = 0; i < queries; i++) {
printf("%d\n", bfs(nodes, query[i][0], query[i][1], numberOfNodes));
}
for (i = 0; i < numberOfNodes; i++) {
while (getSize(&nodes[i])) {
deleteAt(&nodes[i], 0);
}
}
return 0;
}
/*! insert a layer at the end of list */
void DoubleLinkedList::insertBack (Layer * l){
if(this->botlayer==NULL){
//std::cout<<"insert at back";
insertFront(l);
} else {
//std::cout<<"insert at back";
insertAfter(l,this->botlayer);
}
};
static LinkedNode *insertBack(LinkedList *list, void *value) {
if (list->front == NULL) {
return insertFront(list, value);
} else {
return insertAfter(list, list->back, value);
}
}
bool Table::insert(const string &key, int value) {
if(hasEntry(hashTable[hashCode(key)],key)) {
return false;
}
insertFront(hashTable[hashCode(key)],key,value);
return true;
}
/* getPath */
void getPath(ListRef L, GraphRef G, int u){
int w;
makeEmpty(L);
if(getSource(G) == 0){
printf("Graph Error: calling getPath() on graph without running BFS \n");
exit(1);
}
if(G->color[u] == 1){
return;
}
else{
insertFront(L, u);
w = u;
while(G->distance[w] > 0){
insertFront(L, G->parent[w]);
w = G->parent[w];
}
}
}
void insertRear( Node **root, Card x ){
Node *ptr = (*root);
if( (*root) == NULL )
insertFront( &(*root), x);
else{
while( ptr->next != NULL)
ptr = ptr->next;
ptr->next = mallocNode();
setNode(ptr->next, x, NULL);
}
}
int main(){
struct linked * head = NULL ;
int i = 90;
head = insertFront(head,i*3);
insertBack(head,90);
insertBack(head,91);
insertBack(head,92);
insertBack(head,93);
head = addSorted(head,23);
printAll(head);
printIter(head);
return 0 ;
}
int main()
{
List ls;
ls.count = 0;
ls.first = NULL;
int number = 0;
scanf("%d", &number);
int i = 0, temp;
while (i < number) {
scanf("%d", &temp);
insertAt(&ls, i, temp);
i++;
}
print(&ls, stdout);
printf("\n");
i = 1;
while (i < 6) {
insertFront(&ls, i);
i++;
}
print(&ls, stdout);
printf("\n");
i = 1;
int nums = getSize(&ls);
while (i < nums) {
deleteAt(&ls, i);
i++;
nums--;
}
print(&ls, stdout);
printf("\n");
i = 0;
nums = getSize(&ls);
while (i < getSize(&ls)) {
if (getAt(&ls, i) < 3) {
deleteAt(&ls, i);
i--;
} else {
setAt(&ls, i, getAt(&ls, i) * 10);
}
i++;
}
print(&ls, stdout);
return 0;
}
int main() {
Node *copyNode;
int counter = 0;
int i, *arr;
while (scanf("%d", &i) == 1) {
insertFront(i);
counter++;
}
intCounter(counter);
sort(counter);
printListAscending('o');
printListDescending('o');
printListDescending('c');; //calls copy
// printArray(counter, arr);
}
/*
* insertBeforeCurrent
* Inserts new element before current element on the List
* Pre: !isEmpty(L) !offEnd(L)
*/
void insertBeforeCurrent(ListRef L, int data){
if ( !isEmpty(L) && !offEnd(L) ){
if (getIndex(L) == 1){
insertFront(L, data);
return;
}
else{
NodeRef N = newNode(data);
L->current->prev->next = N;
N->prev = L->current->prev;
N->next = L->current;
L->current->prev = N;
}
L->length++;
}
}
void insertBeforeCurrent(ListRef L, long data){
if(L==NULL){
printf("List error: calling insertBeforeCurrent on NULL ListRef\n");
exit(1);
} if (offEnd(L)){
printf("List error: calling insertBeforeCurrent on Null curren\n");
exit(1);
}
if(L->front == L->current){
insertFront(L, data);
} else {
NodeRef N = newNode(data);
N->next = L->current;
N->prev = L->current->prev;
N->prev->next = N;
L->current->prev = N;
}
L->length++;
}
void insertNode(int pos, int val) {
int i;
if (i <= 0) {
insertFront(val);
} else if (i >= m_size) {
insertBack(val);
} else {
ListNode *ptr1, *ptr2;
ptr1 = m_head;
for (i = 0; i < pos - 1; ++i) {
ptr1 = ptr1->next;
}
ptr2 = new ListNode(val);
ptr2->next = ptr1->next;
ptr1->next = ptr2;
++m_size;
}
}
int main()
{
int number;
scanf("%d", &number);
List list;
list.count = 0;
list.first = NULL;
int i = 0;
int num;
for (i = 0; i < number; i++) {
scanf("%d", &num);
insertFront(&list, num);
}
print(&list, stdout);
printf("\n");
sort(&list, compint);
print(&list, stdout);
return 0;
}
void addArc(GraphRef G, int u, int v){
ListRef row = G->adjacency[u];
/* Inserts vetex v into row u in the adjacency array */
if (isEmpty(row)){
insertFront(row, v);
return;
}
else{
moveTo(row, 0);
while (!offEnd(row)){
if (v == getCurrent(row)) return;
if (v > getCurrent(row)){
moveNext(row);
}else{
insertBeforeCurrent(row, v);
return;
}
}
insertBack(row, v);
}
}
void insertAt(List *l, int pos, int x)
{
if (pos > l->count) {
printf("Error: No such element to add\n");
return;
}
if (pos == 0) {
insertFront(l, x);
return;
}
pos--;
struct Node *previous = l->first;
int i = 0;
while (i != pos) {
previous = previous->next;
i++;
}
struct Node *temp = malloc(sizeof(struct Node));
temp->value = x;
l->count = l->count + 1;
temp->next = previous->next;
previous->next = temp;
}
int main()
{
List l;
//createListNoNodes(&l); // working
Info data1;
data1.firstName = "felipe";
data1.lastName = "Cantagalli";
data1.puid = 27296830;
data1.age = 22;
Info data2;
data2.firstName = "bibi";
data2.lastName = "letti";
data2.puid = 12345678;
data2.age = 20;
Info data3;
data3.firstName = "ricardo";
data3.lastName = "cantagalli";
data3.puid = 87654321;
data3.age = 50;
Info data4;
data4.firstName = "suzete";
data4.lastName = "tozato";
data4.puid = 43256789;
data4.age = 48;
createListNode(&l,data1); // working
printList(&l);
insertFront(&l, data2); // working
//insertFront(&l,data3);
//insertFront(&l,data4);
printList(&l);
//insertEnd(&l, data2); //working
insertEnd(&l,data3);
insertFront(&l,data4);
printList(&l);
//insertMiddle(&l,data4,1); //working
//deleteFront(&l); // working
//deleteFront(&l);
//deleteEnd(&l);
//deleteEnd(&l);
deleteMiddle(&l,1); // wroking
//deleteMiddle(&l,1);
printList(&l);
//Node* n = lookUpByIndex(&l,1);
//printf(" %s\n",n->data.firstName);
//n = lookUpByIndex(&l,0);
//printf(" %s\n",n->data.firstName);
int aux = traverse(&l,27296831);
//printf("funcionou ?! : %d",aux);
return 0;
}
void askUser()
{
int num;
int x=10;
int i;
char choices;
system("cls");
printf("\n[1]-DISPLAY ARRAY\n[2]-INSERT REAR\n[3]-INSERT FRONT\n[4]-INSERT INTO\n[5]-DELETE FRONT\n[6]-DELETE REAR\n[7]-DELETE ITEM\n[8]-DELETE ALL ITEM\n[9]-MAKE UNIQUE\n");
choices=getch();
switch(choices)
{
case '1':
displayArray();
getch();
askUser();
break;
case '2':
num=askNum();
for(i=0;i<num;i++)
{
while(x<0||x>9)
{
printf("Enter number: ");
scanf("%d",&x);
}
insertRear(x);
x=10;
displayArray();
}
getch();
askUser();
break;
case '3':
num=askNum();
for(i=0;i<num;i++)
{
while(x<0||x>9)
{
printf("Enter number: ");
scanf("%d",&x);
}
insertFront(x);
x=10;
displayArray();
}
getch();
askUser();
break;
case '4':
displayArray();
insertInto();
displayArray();
getch();
askUser();
break;
case '5':
deleteFront();
displayArray();
getch();
askUser();
break;
case '6':
deleteRear();
displayArray();
getch();
askUser();
break;
case '7':
displayArray();
deleteItem();
displayArray();
getch();
askUser();
break;
case '8':
displayArray();
deleteAllItem();
displayArray();
getch();
askUser();
break;
case '9':
displayArray();
makeUnique();
displayArray();
getch();
askUser();
break;
default:
getch();
break;
}
}
int main(int argc, char* argv[])
{
int i;
ListRef A = newList();
ListRef B = newList();
ListRef ACopy = NULL;
ListRef AB_Cat = NULL;
insertBack(A, 10);
insertBack(A, 20);
insertBack(A, 30);
insertBack(A, 40);
insertBack(A, 50);
insertBack(A, 60);
printf("equals(A,B) : %d\n", equals(A, B));
insertBack(B, 10);
insertBack(B, 20);
insertBack(B, 30);
insertBack(B, 40);
insertBack(B, 50);
insertBack(B, 60);
AB_Cat = catList(A, B);
printf("printLIST(AB_Cat) : ");
printLIST(AB_Cat);
ACopy = copyList(A);
printf("printLIST(A) : ");
printLIST(A);
printf("printLIST(ACopy) : ");
printLIST(ACopy);
printf("equals(A,ACopy) : %d\n", equals(A, ACopy));
printf("equals(A,B) : %d\n", equals(A, B));
printf("printLIST(A) : ");
printLIST(A);
moveTo(A, getLength(A));
printf("offEnd(A) : %d\n", offEnd(A));
moveTo(A, 3);
insertBeforeCurrent(A, 35);
insertAfterCurrent(A, 45);
printf("printLIST(A) : ");
printLIST(A);
printf("getCurrent(A) : %d\n", getCurrent(A));
movePrev(A);
printf("getCurrent(A) : %d\n", getCurrent(A));
deleteCurrent(A);
printf("printLIST(A) : ");
printLIST(A);
makeEmpty(B);
deleteFront(A);
printf("printLIST(A) : ");
printLIST(A);
printf("getLength(A) : %d\n", getLength(A));
printf("isEmpty(A) : %d\n", isEmpty(A));
makeEmpty(A);
printf("isEmpty(A) : %d\n", isEmpty(A));
printf("getLength(A) : %d\n", getLength(A));
/* printf("printLIST(A) : ");
printLIST(A); */
insertFront(B, 50);
insertBack(B, 60);
insertFront(B, 40);
insertBack(B, 70);
insertFront(B, 30);
insertBack(B, 80);
insertFront(B, 20);
insertBack(B, 90);
insertFront(B, 10);
printf("printLIST(B) : ");
printLIST(B);
printf("offEnd(B) : %d\n", offEnd(B));
moveTo(B, 5);
printf("offEnd(B) : %d\n", offEnd(B));
printf("getCurrent(B) : %d\n", getCurrent(B));
deleteCurrent(B);
printf("printLIST(B) : ");
printLIST(B);
/* printf("getCurrent(B) : %d\n", getCurrent(B));*/
moveTo(B, 0);
printf("getFront(B) : %d\n", getFront(B));
printf("getCurrent(B) : %d\n", getCurrent(B));
deleteFront(B);
printf("printLIST(B) : ");
printLIST(B);
printf("getFront(B) : %d\n", getFront(B));
/* printf("getCurrent(B) : %d\n", getCurrent(B)); */
moveTo(B, (getLength(B)-1));
printf("getCurrent(B) : %d\n", getCurrent(B));
printf("getBack(B) : %d\n", getBack(B));
deleteBack(B);
printf("getBack(B) : %d\n", getBack(B));
/* printf("getCurrent(B) : %d\n", getCurrent(B)); */
moveTo(B, (getLength(B)-1));
printf("getCurrent(B) : %d\n", getCurrent(B));
printf("getBack(B) : %d\n", getBack(B));
deleteBack(B);
printf("getBack(B) : %d\n", getBack(B));
printf("getCurrent(B) : %d\n", getCurrent(B));
return(0);
}
