コード例 #1
0
// Function to convert a DLL to a Binary Tree
CNode *convDLLtoBT(CNode *pHeadC)
{
	CNode *mid;			// Middle point of DLL (and will be root)
	CNode *subEnd;		// Acts as end of left DLL
	CNode *rHead;		// Acts as pHead of right side DLL
	
	// Base Case
	if(pHeadC == NULL)
		return NULL;

	// Find middle of DLL/subDLL (root)
	mid = findMiddle(pHeadC);
	
	// Break out left DLL
	if(pHeadC == mid)
		pHeadC = NULL;
	else
	{
		subEnd = mid->pPrevious;
		if(subEnd != NULL)
			subEnd->pNext = NULL;
	}

	rHead = mid->pNext;		// Break out right DLL

	mid->pPrevious = convDLLtoBT(pHeadC);	// Recursive call for left DLL
	mid->pNext = convDLLtoBT(rHead);		// Recursive call for right DLL

	return mid;		// Return original mid as root of binary tree
}
コード例 #2
0
ファイル: Middle_find2.c プロジェクト: zj793039327/algorithms
int main()
{
    int a[] = {2,3,2,2,2,2,1,5,4};
    int result = findMiddle(a,9);
    printf("result is %d\n",result);
    getchar();
    getchar();
    return 0;
}
コード例 #3
0
ファイル: SortList.cpp プロジェクト: liming-vie/LeetCode
    ListNode* sortList(ListNode* head) {
    	if(!head || !head->next)	return head;

    	auto middle=findMiddle(head);
    	auto next=middle->next;
    	middle->next=NULL;

    	return merge(sortList(head), sortList(next));
    }
コード例 #4
0
int main(int argc, char **argv){
	char array[] = "asdfasdfasdfasdf";
	int *p = preProcess(array, 16);
	double *pd = preProcess2(array, 16);
	printf("find average 2 to 9: %d\n", findAverage(array, 16, 2, 9, p));
	printf("find average 2 to 9: %d\n", findAverage2(array, 16, 2, 9, pd));
	printf("find middle 2 to 9: %d\n", findMiddle(array, 16, 2, 9));
	return 1;
}
コード例 #5
0
ファイル: ReorderList.c プロジェクト: mewiteor/LeetCode
void reorderList(struct ListNode* head) {
    struct ListNode *p,*q;
    if(!head||!head->next||!head->next->next)
        return;
    p=findMiddle(head);
    q=reverse(p->next);
    p->next=NULL;
    merge(head,q);
}
コード例 #6
0
 bool isPalindrome(ListNode* head) {
     ListNode* pMid = findMiddle(head);
     ListNode* pRev = reverseLink(pMid); 
     for(;head!=pMid; head=head->next, pRev=pRev->next) {
         if (head->val != pRev->val) {
             return false;
         }
     }
     return true;
 }
コード例 #7
0
ファイル: Middle_find.c プロジェクト: zj793039327/algorithms
int main()
{
	int i;
	int a[] = {1,2,3,2,2,2,5,4,2};
	int result = findMiddle(a, 0, 8, 9);	
	printf("middle is %d\n", result);
	getchar();
	getchar();
	return 0;
}
コード例 #8
0
    ListNode *sortList(ListNode *head) {
        if (head == NULL || head->next == NULL)return head;

        ListNode *middle = findMiddle(head);
        ListNode *head2 = middle->next;
        middle->next = nullptr; // 断开

        ListNode *l1 = sortList(head);  // 前半段排序
        ListNode *l2 = sortList(head2);  // 后半段排序
        return mergeTwoLists(l1, l2);
    }
コード例 #9
0
ファイル: solution.cpp プロジェクト: pmdiano/shuati
    ListNode* sortList(ListNode* head) {
        if (!head || !head->next) {
            return head;
        }

        ListNode* mid = findMiddle(head);
        ListNode* right = sortList(mid->next);
        mid->next = nullptr;
        ListNode* left = sortList(head);

        return merge(left, right);
    }
コード例 #10
0
ファイル: main.cpp プロジェクト: uniquews/LC
 void reorderList(ListNode *head) {
     if (head == nullptr) {
         return;
     }
     
     ListNode *mid = findMiddle(head);
     ListNode *tail = reverse(mid->next);
     mid->next = nullptr;
     merge(head, tail);
     return;
     
 }
コード例 #11
0
ファイル: Middle_find.c プロジェクト: zj793039327/algorithms
int findMiddle(int* a, int start, int end, int n)
{
	int index;
	int middle = -1;
	
	index = partition(a, start, end);
	printf("index is %d\n",index);

	if(index==n/2){		
		middle = a[index];
	}
	else if(index>n/2){		
		end = index-1;
		return findMiddle(a, start, end, n);
	}
	else{		
		start = index+1;
		return findMiddle(a, start, end, n);
	}
	return middle;
}
コード例 #12
0
ファイル: sort-list.cpp プロジェクト: JasonLin6086/Lintcode
    /**
     * @param head: The first node of linked list.
     * @return: You should return the head of the sorted linked list,
                    using constant space complexity.
     */
    ListNode *sortList(ListNode *head) {
        // write your code here
        if (NULL == head || NULL == head->next) {
            return head;
        }

        ListNode *midNode = findMiddle(head);
        ListNode *rList = sortList(midNode->next);
        midNode->next = NULL;
        ListNode *lList = sortList(head);

        return mergeList(lList, rList);
    }
コード例 #13
0
ファイル: SortList.cpp プロジェクト: mertonmeng/leetcode
    static ListNode *sortList(ListNode *head) {

		if (head == nullptr || head->next == nullptr) {
            return head;
        }

		ListNode* midPtr = findMiddle(head);

		ListNode* right = sortList(midPtr->next);
		midPtr->next = nullptr;
		ListNode* left = sortList(head);

		return Merge(left, right);
    }
コード例 #14
0
 bool isPalindrome(ListNode* head) {
     //TC:O(n); SC:O(1)
     if(!head){
         return true;
     }
     ListNode* mid = findMiddle(head);
     ListNode* tmp = mid->next;
     mid->next = nullptr; //disconnect
     ListNode* newHead = reverseList(tmp);
     while(newHead){
         if(newHead->val != head->val){
             return false;
         }
         newHead = newHead->next;
         head = head->next;
     }
     return true;
 }
コード例 #15
0
ファイル: ReorderList.cpp プロジェクト: ArthasJin/leetcode
 void reorderList(ListNode *head) {
     if (!head) {
         return;
     }
     ListNode *l1 = head, *cur = head;
     ListNode *l2 = reverse(findMiddle(head));
     bool reversed = false;
     while(l1 || l2) {
         if (!reversed) {
             l1 = l1 ? l1->next : l1;
             cur->next = l2;
         } else {
             l2 = l2 ? l2->next : l2;
             cur->next = l1;
         }
         cur = cur->next;
         reversed = !reversed;
     }
 }
コード例 #16
0
ファイル: middleLL.c プロジェクト: wolfdale/Spaghetti-code
int main(void) {
	struct node * root = NULL;
	insert(&root,1);
	insert(&root,2);
	insert(&root,3);
	insert(&root,4);
	insert(&root,5);
	insert(&root,6);
	insert(&root,7);
	struct node * temp = root;
	while(temp!=NULL){
		printf("%d\n",temp->item);
		temp=temp->next;
	}
	findMiddle(root);
	
	
	return 0;
}
コード例 #17
0
 void reorderList(ListNode* head) {
     if(!head||!head->next||!head->next->next) return;
     ListNode* mid = findMiddle(head);
     mid = rotateList(mid);
     head = mergeList(head,mid);
 }
コード例 #18
0
ファイル: touch.cpp プロジェクト: mcharmas/TouchTracer
void Touch::setContours(const vector<Point>& contours)
{
    contourPoints = vector<Point>(contours);
    middle = findMiddle();
    area = countArea();
}