ListNode *insertionSortList(ListNode *head) {
ListNode dummy(INT_MIN);
for (ListNode *cur = head; cur != nullptr;) {
auto pos = findInsertPos(&dummy, cur->val);
ListNode *tmp = cur->next;
cur->next = pos->next;
pos->next = cur;
cur = tmp;
}
return dummy.next;
}
int planEmptyTS(
unsigned int TSNumPerLine,
unsigned int protectTSNum,
unsigned int leastEmptyTSNum,
unsigned int inNum,
P_PLAN_INPUT_UNIT pIn,
P_PLAN_OUTPUT_UNIT pOut) {
//unsigned char extraTSNum[inNum];
unsigned char *cycleNum = NULL;
unsigned char **perCycleEmptyTSNum = NULL;
//unsigned int curInsertNum = 0;
unsigned char *insertPos = NULL;
unsigned int i = 0, j = 0, k = 0, startPos = 0, endPos = 0, epmtyTSNum = 255, tempEptTSNum = 255;
int tempVal = 0;
if((2*protectTSNum) >= TSNumPerLine)
return -1;
cycleNum = (unsigned char *)malloc(inNum);
perCycleEmptyTSNum = (unsigned char **)malloc(inNum*sizeof(char *));
for(i=0; i<inNum; i++) {
perCycleEmptyTSNum[i] = (unsigned char *)malloc(TSNumPerLine);
}
insertPos = (unsigned char *)malloc(leastEmptyTSNum);
for(i=0; i<inNum; i++) {
pOut[i].emptyTSNum = TSNumPerLine % pIn[i].totalTTSNum;
cycleNum[i] = TSNumPerLine / pIn[i].totalTTSNum;
if(0 == pOut[i].emptyTSNum) {
pOut[i].emptyTSNum += pIn[i].totalTTSNum;
cycleNum[i] --;
}
disperseEmptyTS(pOut[i].emptyTSNum, cycleNum[i], perCycleEmptyTSNum[i]);
expressionEmptyTS(pIn[i].totalTTSNum, cycleNum[i], perCycleEmptyTSNum[i], pOut[i].emptyTSPos);
memset(pOut[i].emptyTSAttr, EMPTY_TS_ATTR_ASYNC, pOut[i].emptyTSNum);
}
PLAN_EMPTY_TS :
memset(insertPos, TSNumPerLine-2, leastEmptyTSNum);
for(i=0; i<leastEmptyTSNum; i++) {
sort(i, insertPos);
epmtyTSNum = 255;
tempEptTSNum = 255;
tempVal = 0;
for(j=0; j<i+1; j++) {
if(0 == j)
startPos = 0;
else
startPos = insertPos[j-1];
endPos = insertPos[j];
tempVal = findInsertPos(startPos, endPos, inNum, pIn, pOut, &tempEptTSNum);
if(tempVal > 0) {
if(tempEptTSNum < epmtyTSNum) {
epmtyTSNum = tempEptTSNum;
insertPos[i] = tempVal;
}
} else {
if(abs(tempVal) >= inNum) {
//return -1;
continue;
}
else {
pOut[abs(tempVal)].emptyTSNum += pIn[abs(tempVal)].totalTTSNum;
cycleNum[abs(tempVal)] --;
for(k=0; k<inNum; k++) {
disperseEmptyTS(pOut[k].emptyTSNum, cycleNum[k], perCycleEmptyTSNum[k]);
expressionEmptyTS(pIn[k].totalTTSNum, cycleNum[k], perCycleEmptyTSNum[k], pOut[k].emptyTSPos);
memset(pOut[k].emptyTSAttr, EMPTY_TS_ATTR_ASYNC, pOut[k].emptyTSNum);
goto PLAN_EMPTY_TS;
}
}
}
}
for(k=0; k<i; k++) {
if(insertPos[k] > insertPos[i]) {
endPos = insertPos[k];
break;
} else {
endPos = (TSNumPerLine-protectTSNum);
}
}
for(k=0; k<inNum; k++) {
setSyncEmptyTSPos(insertPos[i], endPos, &pIn[k], pOut[k].emptyTSNum, pOut[k].emptyTSPos);
}
}
for(i=0; i<inNum; i++) {
for(j=0; j<TSNumPerLine; j++) {
for(k=0; k<pOut[i].emptyTSNum; k++) {
if(j == pOut[i].emptyTSPos[k])
break;
}
if(k == pOut[i].emptyTSNum)
printf("0 ");
else
printf("1 ");
}
printf("\r\n");
}
free(cycleNum);
for(i=0; i<inNum; i++) {
free(perCycleEmptyTSNum[i]);
}
free(perCycleEmptyTSNum);
free(insertPos);
return 0;
}
