Upload files

Author: avhn

.DS_Store

@@ -0,0 +1,13 @@
+void RemoveDublicates(struct node *head) {
+  if (head == NULL) return;
+
+  struct node *current = head;
+  while (current->next != NULL) {
+    if (current->data == current->next->data) {
+      struct node* temp = current->next;
+      current->next = current->next->next;
+      free(temp);
+    }
+    else current = current->next;
+  }
+}

stanfordcslib105/LinkedListProblems.pdf

@@ -0,0 +1,9 @@
+void MoveNode(struct node** destRef, struct node** sourceRef) {
+  assert(*sourceRef != NULL);
+
+  struct node *temp = *sourceRef;
+  *sourceRef = (*sourceRef)->next; //Rearrange source
+
+  temp->next = *destRef; //Move node
+  *destRef = temp;
+}

stanfordcslib105/f10_RemoveDublicates.c

@@ -0,0 +1,21 @@
+/*void AlternatingSplit(struct node *source, struct node **aRef, struct node **bRef) {
+  struct node *current = source;
+  for (int i = 0; current != NULL; current = current->next, i++) {
+    if (i%2 == 0) Push(aRef, current->data);
+    else Push(bRef, current->data);
+  }
+}
+
+*/
+void AlternatingSplit(struct node *source, struct node **aRef, struct node **bRef) {
+  assert(source != NULL);
+  struct node *current = source;
+
+  for(int i = 0; current != NULL; i++) {
+    struct node *temp = current;
+    current = current->next;
+
+    if (i % 2 == 0) MoveNode(aRef, &temp );
+    else MoveNode(bRef, &temp );
+  }
+}

stanfordcslib105/f11_MoveNode.c

@@ -0,0 +1,35 @@
+// data is copied
+struct node* ShuffleMerge(struct node *a, struct node *b) {
+  struct node *newHead = NULL, *currA = a, *currB = b;
+  struct node **tail = &newHead;
+
+  while (currA != NULL || currB != NULL){
+    if (currA != NULL) {
+      Push(tail, currA->data);
+      currA = currA->next, tail = &((**tail).next);
+    }
+    if(currB != NULL) {
+      Push(tail, currB->data);
+      currB = currB->next, tail = &((**tail).next);
+    }
+  }
+  return newHead;
+}
+
+//parameters' data wasted, not referenced so not dereferenced as NULL to check, not my choice
+/*
+struct node* ShuffleMerge(struct node *a, struct node *b) {
+  struct node *newNode = NULL;
+
+  if(a == NULL) return b;
+  else if(b == NULL) return a;
+  else {
+    struct node *recur = ShuffleMerge(a->next, b->next);
+
+    newNode = a;
+    a->next = b;
+    b->next = recur;
+  }
+  return newNode;
+}
+*/

stanfordcslib105/f12_AlternatingSplit.c

@@ -0,0 +1,57 @@
+/*
+struct node* SortedMerge(struct node *a, struct node *b) {
+  struct node *newHead = NULL, *temp;
+
+  while (a != NULL || b != NULL) {
+    if (a != NULL) {
+      temp = a, a = a->next;
+      SortedInsert(&newHead, temp);
+    }
+    if (b != NULL) {
+      temp = b, b = b->next;
+      SortedInsert(&newHead, temp);
+    }
+  }
+  return newHead;
+}
+*/
+
+/*
+//Local Reference
+struct node* SortedMerge(struct node *a, struct node *b) {
+  struct node *newHead = NULL;
+  struct node **lastRef = &newHead;
+
+  while (1) {
+    if ( a == NULL ) {
+      *lastRef = b;
+      break;
+    }
+    else if ( b == NULL ){
+      *lastRef = a;
+      break;
+    }
+
+    if ( a->data >= b->data ) *lastRef = b, b = b->next, (*lastRef)->next = NULL;
+    else *lastRef = a, a = a->next, (*lastRef)->next = NULL;
+    lastRef = &((*lastRef)->next);
+  }
+  return newHead;
+}
+*/
+
+ //Recursion
+struct node* SortedMerge(struct node *a, struct node *b) {
+  if ( a == NULL ) return b;
+  else if ( b == NULL ) return a;
+
+  struct node *newHead = NULL;
+  if ( a->data <= b->data) {
+    newHead = a;
+    newHead->next = SortedMerge(a->next, b);
+  } else {
+    newHead = b;
+    newHead->next = SortedMerge(a, b->next);
+  }
+  return newHead;
+}

stanfordcslib105/f13_ShuffleMerge.c

@@ -0,0 +1,11 @@
+void MergeSort(struct node **headRef) {
+  if(*headRef == NULL || (*headRef)->next == NULL) return;
+
+  struct node *a = NULL, *b = NULL;
+  FrontBackSplit(*headRef, &a, &b);
+
+  MergeSort(&a);
+  MergeSort(&b);
+
+  *headRef = SortedMerge(a,b);
+}

stanfordcslib105/f14_SortedMerge.c

@@ -0,0 +1,32 @@
+/*
+struct node* SortedIntersect(struct node *a, struct node (b) {
+  struct node* newHead = NULL;
+  while (a != NULL && b != NULL) {
+    if ( a->data == b->data ) {
+      PushTail(&newHead, a->data);
+      a = a->next;
+      b = b->next;
+    }
+    else if ( a->data > b->data) b = b->next;
+    else a = a->next;
+  }
+  return newHead;
+}
+*/
+
+//Local referance
+struct node* SortedIntersect(struct node *a, struct node *b) {
+  struct node *newHead = NULL;
+  struct node **tailRef = &newHead;
+
+  while (a != NULL && b != NULL) {
+    if ( a->data == b->data ) {
+      Push(tailRef, a->data);
+      tailRef = &((*tailRef)->next);
+      a = a->next, b = b->next;
+    }
+    else if ( a->data < b->data) a = a->next;
+    else b = b->next;
+  }
+  return newHead;
+}

stanfordcslib105/f15_MergeSort.c

@@ -0,0 +1,30 @@
+/*
+// a.k.a back-middle-front strategy
+void Reverse(struct node **headRef) {
+  assert(Length(*headRef) > 1);
+
+  struct node *backPtr = NULL, *mainPtr = *headRef, *frontPtr = mainPtr->next;
+  while (1){
+    mainPtr->next = backPtr;
+    if (frontPtr == NULL) break;
+    backPtr = mainPtr;
+    mainPtr = frontPtr;
+    frontPtr = frontPtr->next;
+  }
+  *headRef = mainPtr;
+}
+*/
+
+// Moving nodes
+void Reverse(struct node **headRef) {
+  assert(*headRef);
+
+  struct node *result = 0, *current = *headRef;
+  do {
+    struct node *temp = current->next;
+    current->next = result;
+    result = current;
+    current = temp;
+  } while (current);
+  *headRef = result;
+}

stanfordcslib105/f16_SortedIntersect.c

@@ -0,0 +1,26 @@
+/*
+void RecursiveReverse(struct node **headRef) {
+  assert(*headRef); //Empty list case
+
+  struct node *initial = *headRef, *rest = initial->next;
+  if (rest == NULL) return; //End of list, last initial in stack is at (n-1)th node
+
+  RecursiveReverse(&rest);
+  *headRef = rest; //Final rest's value(last node's adress) is initialized via reference
+
+  initial->next->next = initial; //Point back
+  initial->next = NULL;
+}
+*/
+
+void RecursiveReverse(struct node **headRef) {
+  struct node *first = *headRef, *rest = first->next;
+  if (rest == NULL) return;
+
+  RecursiveReverse(&rest);
+
+  first->next->next = first;
+  first->next = NULL;
+
+  *headRef = rest;
+}

stanfordcslib105/f17_Reverse.c

@@ -0,0 +1,5 @@
+int Count(struct node* head, int searchFor) {
+  int count = 0;
+  for(struct node* current = head; current != NULL; current = current->next) if(current->data == searchFor) count++;
+  return count;
+}

stanfordcslib105/f18_RecursiveReverse.c

@@ -0,0 +1,5 @@
+int GetNth(struct node* head, int index) {
+  struct node* current = head;
+  for (int i = 0; i < index; i++, current = current->next) assert(current != NULL);
+  return current->data;
+}

stanfordcslib105/f1_Count.c

@@ -0,0 +1,7 @@
+int DeleteList(struct node** headRef) {
+  /* Drags head to end of the list while deallocating */
+  while (*headRef != NULL) {
+    struct node* temp = *headRef;
+    *headRef = (**headRef).next, free(temp);
+  }
+}

stanfordcslib105/f2_GetNth.c

@@ -0,0 +1,8 @@
+int Pop(struct node** headRef) {
+  assert(*headRef != NULL);
+  struct node* head = *headRef;
+  int data = head->data;
+
+  *headRef = (*headRef)->next, free(head);
+  return data;
+}

stanfordcslib105/f3_DeleteList.c

@@ -0,0 +1,32 @@
+/*
+void InsertNth(struct node** headRef, int index, int data) {
+  // index is array representation
+
+  struct node* newNode = malloc(sizeof(struct node));
+  newNode->data = data, newNode->next = NULL;
+
+  struct node* current = *headRef;
+  for (int i = 1; i < index; i++) { // current = index-1
+    current = current->next;
+    assert(current != NULL);
+  }
+
+  if (index == 0) newNode->next = current, current = newNode;
+  else {
+    newNode->next = current->next;
+    current->next = newNode;
+  }
+}
+*/
+
+void InsertNth(struct node** headRef, int index, int data) {
+  if (index == 0) Push(headRef, data);
+  else {
+    struct node* newNode = malloc(sizeof(struct node));
+    newNode->data = data, newNode->next = NULL;
+
+    struct node *current = *headRef;
+    for(int i = 1; i < index; current = current->next, i++) assert(current != NULL);
+    assert(current != NULL), Push(&(current->next), data);
+  }
+}

stanfordcslib105/f4_Pop.c

@@ -0,0 +1,24 @@
+/*
+void SortedInsert(struct node** headRef, struct node* newNode) {
+  if (*headRef == NULL || newNode->data < (*headRef)->data) {
+    newNode->next = *headRef;
+    *headRef = newNode;
+  } else {
+    struct node* current = *headRef;
+    while (current->next != NULL && current->next->data < newNode->data) {
+      current = current->next;
+    }
+    newNode->next = current->next;
+    current->next = newNode;
+  }
+}
+*/
+
+void SortedInsert(struct node** headRef, struct node* newNode) {
+  struct node** currRef = headRef;
+  while (*currRef != NULL && (*currRef)->data < newNode->data) {
+    currRef = &((*currRef)->next);
+  }
+  newNode->next = *currRef;
+  *currRef = newNode;
+}

stanfordcslib105/f5_InsertNth.c

@@ -0,0 +1,10 @@
+#include "f6_SortedInsert.c"
+void InsertSort(struct node** headRef) {
+  struct node *current = *headRef, *temp, *result = NULL;
+  while (current != NULL) {
+    temp = current->next;
+    SortedInsert(&result, current);
+    current = temp;
+  }
+  *headRef = result;
+}

stanfordcslib105/f6_SortedInsert.c

@@ -0,0 +1,9 @@
+void Append(struct node **aRef, struct node **bRef) {
+  if (*aRef == NULL) *aRef = *bRef;
+  else {
+    struct node *current = *aRef;
+    while (current->next != NULL) current = current->next;
+    current->next = *bRef;
+  }
+  *bRef = NULL;
+}

stanfordcslib105/f7_InsertSort.c

@@ -0,0 +1,13 @@
+void FrontBackSplit(struct node* source, struct node** frontRef, struct node** backRef) {
+  int len = Length(source);
+  *frontRef = source;
+
+  if (len < 2) return;
+  else {
+  int frontend = (len % 2 == 0)? len/2: len/2 + 1;
+
+  struct node* current = source;
+  for(int i = 1; i < frontend; current = current->next, i++);
+  *backRef = current->next, current->next = NULL; //Cut the lists
+  }
+}