コード例 #1
0
/**
 * [intersectionPoint Returns the point of intersection of two lists]
 * @param  head1 [ head of list 1 ]
 * @param  head2 [ head of list 2 ]
 * @return       [ Intersecting node, if lists intersect, else nullptr]
 */
Node * intersectionPoint( Node * head1, Node * head2 )
{
  int len1 = listLen(head1);
  int len2 = listLen(head2);
  //figure out the bigger list ( and smaller )
  //ptr points to bigger list, let us move the difference
  //between the two.
  Node * ptr1 = ( len1 > len2 ) ? head1 : head2;
  Node * ptr2 = ( len1 > len2 ) ? head2 : head1;
  int i = 0;
  while ( i < std::abs(len1 - len2) && ptr1 ) {
    ptr1 = ptr1->next;
    ++i;
  }
  //Now we have equal nodes to travel on both the nodes
  // traversing and comparing the pointers.

  while( ptr1 && ptr2 ) {
    if ( ptr1 == ptr2 ) {
      return ptr1;
    }
    ptr1 = ptr1->next;
    ptr2 = ptr2->next;
  }
  return nullptr;
}
コード例 #2
0
ファイル: events.c プロジェクト: RuedKamp/OMCompiler
/*! \fn checkForStateEvent
 *
 *  \param [ref] [data]
 *  \param [ref] [eventList]
 *
 *  This function checks for events in interval=[oldTime, timeValue]
 *  If a zero crossing function cause a sign change, root finding
 *  process will start
 */
int checkForStateEvent(DATA* data, LIST *eventList)
{
  TRACE_PUSH
  long i=0;

  debugStreamPrint(LOG_EVENTS, 1, "check state-event zerocrossing at time %g",  data->localData[0]->timeValue);

  for(i=0; i<data->modelData.nZeroCrossings; i++)
  {
    int *eq_indexes;
    const char *exp_str = data->callback->zeroCrossingDescription(i,&eq_indexes);
    debugStreamPrintWithEquationIndexes(LOG_EVENTS, 1, eq_indexes, "%s", exp_str);

    if(sign(data->simulationInfo.zeroCrossings[i]) != sign(data->simulationInfo.zeroCrossingsPre[i]))
    {
      debugStreamPrint(LOG_EVENTS, 0, "changed:   %s", (data->simulationInfo.zeroCrossingsPre[i] > 0) ? "TRUE -> FALSE" : "FALSE -> TRUE");
      listPushFront(eventList, &(data->simulationInfo.zeroCrossingIndex[i]));
    }
    else
    {
      debugStreamPrint(LOG_EVENTS, 0, "unchanged: %s", (data->simulationInfo.zeroCrossingsPre[i] > 0) ? "TRUE -- TRUE" : "FALSE -- FALSE");
    }

    if (DEBUG_STREAM(LOG_EVENTS))
      messageClose(LOG_EVENTS);
  }
  if (DEBUG_STREAM(LOG_EVENTS))
    messageClose(LOG_EVENTS);

  if(listLen(eventList) > 0)
  {
    TRACE_POP
    return 1;
  }
コード例 #3
0
ファイル: oldlist.c プロジェクト: theme/dsaa
node* bubbleSort( node *head){
    if ( NULL == head || NULL == head->next)
        return head;

    node *m, *n;
    int flag, len = listLen(head);
    int j,i = len -1;
    while( i > 0  ){
        printf("bs- ");
        listPrint( head );
        m = head;
        n = head->next;
        flag = 0;
        for( j= 0 ; j < i; ++j  ) {
            if ( n->data < m->data)
            {
                int tmp = n->data;
                n->data = m->data;
                m->data = tmp;
                flag = 1;
            }
            m = m->next;
            n = n->next;
        }
        if( 0 == flag )
            break;
        --i;
    }
    return head;
}
コード例 #4
0
ファイル: Rotate-List.cpp プロジェクト: Finalcheat/leetcode
 ListNode* rotateRight(ListNode* head, int k) {
     if (head == NULL) {
         return head;
     }
     int len = listLen(head);
     k = k % len;
     if (k == 0) {
         return head;
     }
     ListNode* node2 = head;
     while (k-- && node2) {
         node2 = node2->next;
     }
     ListNode* node1 = head;
     while (node2 && node2->next) {
         node1 = node1->next;
         node2 = node2->next;
     }
     ListNode* newHead = NULL;
     if (node2 == NULL || node2 == head) {
         newHead = head;
     } else {
         newHead = node1->next;
         node2->next = head;
         node1->next = NULL;
     }
     return newHead;
 }
コード例 #5
0
ファイル: nonlinearSystem.c プロジェクト: arun3688/OMCompiler
/*! \fn updateInitialGuessDB
 *
 *  This function writes new values to solution list.
 *
 *  \param [in]  [nonlinsys]
 *  \param [in]  [time] time for extrapolation
 *  \param [in]  [context] current context of evaluation
 *
 */
int updateInitialGuessDB(NONLINEAR_SYSTEM_DATA *nonlinsys, double time, int context)
{
  /* write solution to oldValue list for extrapolation */
  if (nonlinsys->solved == 1)
  {
    /* do not use solution of jacobian for next extrapolation */
    if (context < 4)
    {
      addListElement((VALUES_LIST*)nonlinsys->oldValueList,
              createValueElement(nonlinsys->size, time, nonlinsys->nlsx));
    }
  }
  else if (nonlinsys->solved == 2)
  {
    if (listLen(((VALUES_LIST*)nonlinsys->oldValueList)->valueList)>0)
    {
      cleanValueList((VALUES_LIST*)nonlinsys->oldValueList, NULL);
    }
    /* do not use solution of jacobian for next extrapolation */
    if (context < 4)
    {
      addListElement((VALUES_LIST*)nonlinsys->oldValueList,
              createValueElement(nonlinsys->size, time, nonlinsys->nlsx));
    }
  }
  messageClose(LOG_NLS_EXTRAPOLATE);
  return 0;
}
コード例 #6
0
ファイル: 019.cpp プロジェクト: HoboChen/sc
 ListNode* removeNthFromEnd(ListNode* head, int n) {
     int p = listLen(head) + 1 - n;
     if (p == 1) return head -> next;
     ListNode* remove = head;
     for (int i = 0; i < p - 2; i++) remove = remove -> next;
     remove -> next = remove -> next -> next;
     return head;
 }
コード例 #7
0
ファイル: server.c プロジェクト: Foja/dp2p
void alarm_handler()
{

  if (listLen(&list) == 0)
  {
     alarm(100);
     return;
  }

  decrementaTtl(&list);
  alarm(100);
  return;
}
コード例 #8
0
ファイル: main.cpp プロジェクト: XiaoningLiu/LeetCode_CPP
  ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    int len1 = listLen(l1);
    int len2 = listLen(l2);
    int maxLen = len1 > len2 ? len1 : len2;
    int minLen = len1 > len2 ? len2 : len1;
    ListNode* longList = len1 > len2 ? l1 : l2;
    ListNode* shortList = len1 > len2 ? l2 : l1;

    ListNode* resList = new ListNode(0);
    ListNode* p = resList;
    
    int val1(0), val2(0), add(0), n(0);
    for (int i = 0; i < maxLen; i++)
    {
      val1 = longList->val;
      val2 = i < minLen ? shortList->val : 0;

      n = val1 + val2 + add;
      if (n > 9)
      {
        add = 1;
        n -= 10;
      }
      else
        add = 0;

      p->next = new ListNode(n);
      p = p->next;
      longList = longList->next;

      if (i < minLen)
        shortList = shortList->next;
    }
    if (add == 1)
      p->next = new ListNode(1);
    
    return resList->next;
  }
コード例 #9
0
ファイル: Sort List.cpp プロジェクト: darrenhp/AlgoSolution
 ListNode* sortList(ListNode* head) {
     int len = listLen(head);
     for (int subRange = 1; subRange < len; subRange *= 2) {
         ListNode* remain = head;
         ListNode* newHead = NULL;
         ListNode** newTail = &newHead;
         while (remain != NULL) {
             ListNode* L1 = takeN(remain, subRange);
             ListNode* L2 = takeN(remain, subRange);
             mergeToTail(L1, L2, newTail);
         }
         head = newHead;
     }
     return head;
 }
コード例 #10
0
ファイル: oldlist.c プロジェクト: theme/dsaa
int main()
{
    //new a new list
    node *p,*head;
    int d,deld,insertd;

    p = head = NULL;
    while( scanf("%d",&d) )
    {
        if( 0 == d ) break;
        node *n = (node*) malloc(sizeof(node));
        n->data = d;
        n->next = NULL;
        if (NULL == head)
            p = head = n;
        p->next = n;
        p = n;
    }

    listLen( head );
    listPrint( head );

    printf("del?");
    scanf("%d",&deld);
    head = delByData(head, deld);
    listPrint( head );

    printf("insert?");
    scanf("%d",&insertd);
    head = insert(head, insertd);
    listPrint( head );

    printf("reverse\n");
    head = reverse (head );
    listPrint( head );

    printf("sort\n");
    //head = selSort( head );
    head = bubbleSort( head );
    listPrint( head );

    listFree( head );
    return 0;
}
コード例 #11
0
ファイル: nonlinearSystem.c プロジェクト: arun3688/OMCompiler
/*! \fn getInitialGuess
 *
 *  This function writes initial guess to nonlinsys->nlsx and nonlinsys->nlsOld.
 *
 *  \param [in]  [nonlinsys]
 *  \param [in]  [time] time for extrapolation
 *
 */
int getInitialGuess(NONLINEAR_SYSTEM_DATA *nonlinsys, double time)
{
  /* value extrapolation */
  printValuesListTimes((VALUES_LIST*)nonlinsys->oldValueList);
  /* if list is empty use current start values */
  if (listLen(((VALUES_LIST*)nonlinsys->oldValueList)->valueList)==0)
  {
    /* use old value if no values are stored in the list */
    memcpy(nonlinsys->nlsx, nonlinsys->nlsxOld, nonlinsys->size*(sizeof(double)));
  }
  else
  {
    /* get extrapolated values */
    getValues((VALUES_LIST*)nonlinsys->oldValueList, time, nonlinsys->nlsxExtrapolation, nonlinsys->nlsxOld);
    memcpy(nonlinsys->nlsx, nonlinsys->nlsxOld, nonlinsys->size*(sizeof(double)));
  }

  return 0;
}
コード例 #12
0
ファイル: nonlinearSystem.c プロジェクト: adrpo/OMCompiler
/*! \fn solve non-linear systems
 *
 *  \param [in]  [data]
 *  \param [in]  [sysNumber] index of corresponding non-linear system
 *
 *  \author wbraun
 */
int solve_nonlinear_system(DATA *data, threadData_t *threadData, int sysNumber)
{
  void *dataAndThreadData[2] = {data, threadData};
  int success = 0, saveJumpState;
  NONLINEAR_SYSTEM_DATA* nonlinsys = &(data->simulationInfo->nonlinearSystemData[sysNumber]);
  struct dataNewtonAndHybrid *mixedSolverData;

  data->simulationInfo->currentNonlinearSystemIndex = sysNumber;

  /* enable to avoid division by zero */
  data->simulationInfo->noThrowDivZero = 1;
  ((DATA*)data)->simulationInfo->solveContinuous = 1;


  rt_ext_tp_tick(&nonlinsys->totalTimeClock);

  /* value extrapolation */
  infoStreamPrint(LOG_NLS_EXTRAPOLATE, 1, "############ Start new iteration for system %d at time at %g ############", sysNumber, data->localData[0]->timeValue);
  printValuesListTimes((VALUES_LIST*)nonlinsys->oldValueList);
  /* if list is empty use current start values */
  if (listLen(((VALUES_LIST*)nonlinsys->oldValueList)->valueList)==0)
  {
    //memcpy(nonlinsys->nlsxOld, nonlinsys->nlsx, nonlinsys->size*(sizeof(double)));
    //memcpy(nonlinsys->nlsxExtrapolation, nonlinsys->nlsx, nonlinsys->size*(sizeof(double)));
    memcpy(nonlinsys->nlsx, nonlinsys->nlsxOld, nonlinsys->size*(sizeof(double)));
  }
  else
  {
    /* get extrapolated values */
    getValues((VALUES_LIST*)nonlinsys->oldValueList, data->localData[0]->timeValue, nonlinsys->nlsxExtrapolation, nonlinsys->nlsxOld);
    memcpy(nonlinsys->nlsx, nonlinsys->nlsxOld, nonlinsys->size*(sizeof(double)));
  }

  if(data->simulationInfo->discreteCall)
  {
    double *fvec = malloc(sizeof(double)*nonlinsys->size);
    int success = 0;

#ifndef OMC_EMCC
    /* try */
    MMC_TRY_INTERNAL(simulationJumpBuffer)
#endif

    ((DATA*)data)->simulationInfo->solveContinuous = 0;
    nonlinsys->residualFunc((void*) dataAndThreadData, nonlinsys->nlsx, fvec, (int*)&nonlinsys->size);
    ((DATA*)data)->simulationInfo->solveContinuous = 1;

    success = 1;
    memcpy(nonlinsys->nlsxExtrapolation, nonlinsys->nlsx, nonlinsys->size*(sizeof(double)));
#ifndef OMC_EMCC
    /*catch */
    MMC_CATCH_INTERNAL(simulationJumpBuffer)
#endif
    if (!success)
    {
      warningStreamPrint(LOG_STDOUT, 0, "Non-Linear Solver try to handle a problem with a called assert.");
    }


    free(fvec);
  }