void reorderList(ListNode *head) {
//step 1: count
//iterator headPtr = head;
int len = lengthOfList( head );
if( len < 3 ){
return;
}
//step 2: reverse
int mid = (len+1)/2;
iterator midPtr = getMid( head, mid );
iterator mn = midPtr->next;
midPtr->next = NULL;
midPtr = reverseList( mn );
//step 3: merge
iterator hn = head->next;
mn = midPtr->next;
while( mn != NULL ){
head->next = midPtr;
midPtr->next = hn;
head = hn;
midPtr = mn;
hn = head->next;
mn = midPtr->next;
}
head->next = midPtr;
midPtr->next = hn;
return ;
}
// Removing Kth from the last element.
void removeKthFromLast(int index){
node_t *link = head;
node_t *dlink=NULL;
if(index>lengthOfList()||index<1)
{
return;
}
index = lengthOfList()-index;
while(index!=1){
link = link->next;
index--;
}
dlink = link->next;
link->next = dlink->next;
free(dlink);
}
void checkPalindrome(node_t **headPtr,int mid){
node_t *link=NULL;
node_t *slowPtr,*fastPtr;
ReverseList(headPtr,mid);
//Comparing.
//
link = *headPtr;
slowPtr = fastPtr = link;
//push a link forward.
if(lengthOfList(*headPtr)%2!=0){
link=link->next;
}
while(fastPtr!=NULL){
fastPtr = fastPtr->next;
if(fastPtr!=NULL&&fastPtr->next!=NULL){
fastPtr=fastPtr->next;
slowPtr=slowPtr->next;
}
}
slowPtr = slowPtr->next;
while(slowPtr!=NULL){
if(slowPtr->val!=link->val){
printf("Not a Palindrome");
break;
}
slowPtr=slowPtr->next;
link=link->next;
}
if(slowPtr==NULL){
printf("Palindrome");
}
//reversing it back.
ReverseList(headPtr,mid);
}
List* mergeSort(List* list)
{
List* newList1 = createList();
List* newList2 = createList();
int length = lengthOfList(list);
if (length != 1)
{
Position temp = first(list);
for (int i = 1; i <= length/2; ++i)
{
add(newList1, retrieve(temp, list));
temp = next(temp, list);
}
for (int i = length/2 + 1; i <= length; ++i)
{
add(newList2, retrieve(temp, list));
temp = next(temp, list);
}
list = merge(mergeSort(newList1), mergeSort(newList2));
}
return list;
}
double evaluateValueAsBool(Value* v) {
double i;
Value* u;
if (v->type == 'v') {
u = valueFromName(((Variable*)v)->name);
if (u == NULL) return NAN;
return evaluateValueAsBool(u);
}
if (v->type == 'n') {
return *((double*)v->data);
}
if (v->type == 'c') {
u = evaluateFuncVal((FuncVal*)v);
if (u == NULL) return NAN;
i = evaluateValueAsBool(u);
freeValue(u);
return i;
}
if (v->type == 's') {
return strlen(((String*)v->data)->val);
}
if (v->type == 'b') {
return ((BoolExpr*)v)->lasteval;
}
if (v->type == 'l') {
if (v->data)
return lengthOfList(((List*)v->data)->next) +
(double)((VarTree*)((List*)((List*)v->data)->data)->data)->count;
else
return 0.0;
}
if (v->type == 'd') {
return evaluateValueAsBool(evaluateStatements((List*)v->data));
}
if (v->type == '0') {
return 0;
}
return 1;
}
int main(){
int choice,element,index;
choice = 0;
while(choice){
printf("\nWhat would you like to do? ");
printf("\n1. Insert.");
printf("\n2. delete");
printf("\n3. print");
printf("\n4. search");
printf("\n5. delete at index");
printf("\n6. delete key");
printf("\n0. Exit.");
scanf("%d",&choice);
switch(choice){
case 1: printf("Enter Element: ");
scanf("%d",&element);
insertElement(element);
break;
case 2: printf("Delete Element: ");
deleteFirst();
break;
case 3: printList();
break;
case 4:
printf("Enter Element: ");
scanf("%d",&element);
index = searchForIndex(element);
if(index == lengthOfList()){
printf("\nElement not found");
}
else
printf("%d",index);
break;
case 5: printf("Enter Element: ");
scanf("%d",&element);
deleteElementAtIndex(element);
case 6: printf("Enter Element: ");
scanf("%d",&element);
deleteElement(element);
case 0: break;
}
}
/// Test Case 1. removing duplicates from searching.
if(0) {
insertElement(4);
insertElement(4);
insertElement(2);
insertElement(2);
insertElement(2);
printList();
removeDuplicates_Searching();
printList();
}
// test case 2. For removing kth from the last element.
if(1) {
insertElement(10);
insertElement(20);
insertElement(30);
insertElement(40);
insertElement(50);
printList();
removeKthFromLast(-1);
printList();
}
return 0;
}
int returnIndex(node_t *headPtr){
int len = lengthOfList(headPtr);
int result = (len%2==0) ? (len/2):(len/2+1);
return result;
}
int lengthOfList( listOfPaths_t* list)
{
if (list != NULL)
return 1 + lengthOfList(list->next);
return 0;
}
