void RadixSort(SLList &L)//基数排序
{
int i;
ArrType f,e;//队头指针，队尾
for(i=0;i<L.keynum;i++)//进行keynum趟分配，收集
{
Distribute(L,i,f,e);//第i趟分配
Collect(L,i,f,e);//第i趟分收集
}
}
void RadixSort(SList *L)
/*对L进行基数排序，使得L成为按关键字非递减的静态链表，L.r[0]为头结点*/
{
int i;
addr f,r;
for(i=0;i<(*L).keynum;i++) /*由低位到高位依次对各关键字进行分配和收集*/
{
Distribute((*L).data,i,f,r); /*第i趟分配*/
Collect((*L).data,f,r); /*第i趟收集*/
printf("第%d趟收集后:",i+1);
PrintList2(*L);
}
}
void RadixSort(SLList *L)
{ int i;
ArrType f,e;
for(i=0;i<L->recnum;i++)
L->r[i].next=i+1;
L->r[L->recnum].next=0;
for(i=0;i<L->keynum;i++)
{ Distribute(L,i,f,e);
Collect(L,i,f,e);
}/*end of for */
}/*end of RadixSort() function*/
void RadixSort(SLList &L) { // 算法10.17
// L是采用静态链表表示的顺序表。
// 对L作基数排序，使得L成为按关键字自小到大的有序静态链表，
// L.r[0]为头结点。
int i;
ArrType f, e;
for (i=1; i<L.recnum; ++i) L.r[i-1].next = i;
L.r[L.recnum].next = 0; // 将L改造为静态链表
for (i=0; i<L.keynum; ++i) {
// 按最低位优先依次对各关键字进行分配和收集
Distribute(L, i, f, e); // 第i趟分配
Collect(L, i, f, e); // 第i趟收集
print_SLList2(L, i);
}
} // RadixSort
void HeaderCtrl::RefreshDistribution()
{
int szcx = GetSize().cx;
if(oszcx != szcx) {
if(mode == SCROLL)
for(int i = 0; i < col.GetCount(); i++) {
Column& c = col[i];
c.ratio = minmax((int)c.ratio, c.min, c.max);
}
else {
Distribute(GetVisibleCi(0), 0);
}
oszcx = szcx;
ReCompute();
}
}
static void RadixSort(SLList &L)
{ // L是采用静态链表表示的顺序表。对L作基数排序，使得L成为按关键字
// 自小到大的有序静态链表，L.r[0]为头结点。算法10.17
int i;
ArrType f,e;
for(i=0;i<L.recnum;++i)
L.r[i].next=i+1;
L.r[L.recnum].next=0; // 将L改造为静态链表
for(i=0;i<L.keynum;++i)
{ // 按最低位优先依次对各关键字进行分配和收集
Distribute(L.r,i,f,e); // 第i趟分配
Collect(L.r,f,e); // 第i趟收集
printf("第%d趟收集后:\n",i+1);
printl(L);
printf("\n");
}
}
void HeaderCtrl::SetTabWidth0(int i, int cx)
{
Column& c = col[i];
int szcx = GetSize().cx;
Rect ir = GetTabRect(i);
bool checkmin = SumMin(0) < szcx;
cx = checkmin ? minmax(cx, c.min, c.max) : min(cx, c.max);
if(mode != SCROLL) {
if(checkmin)
cx = min(cx, szcx - SumMin(i + 1) - ir.left);
cx = max(cx, szcx - SumMax(i + 1) - ir.left);
}
if(cx < 0)
cx = 0;
double rs = Denominator();
int ocx = ir.Width();
if(szcx == 0) return;
double delta = rs * (cx - ocx) / szcx;
if(ocx == cx) return;
col[i].ratio += delta;
switch(mode) {
case PROPORTIONAL:
Distribute(GetVisibleCi(i + 1), -delta);
break;
case REDUCELAST:
for(int q = col.GetCount() - 1; q >= i; q--)
Reduce(q, delta, rs, szcx, checkmin);
break;
case REDUCENEXT:
for(int q = i + 1; q < col.GetCount(); q++)
Reduce(q, delta, rs, szcx, checkmin);
if(delta > 0)
Reduce(i, delta, rs, szcx, checkmin);
break;
case SCROLL:
col[i].ratio = cx;
SbTotal();
break;
}
ReCompute();
Refresh();
}
void RadixSort(SLList *L)
{ /* L是采用静态链表表示的顺序表。对L作基数排序，使得L成为按关键字 */
/* 自小到大的有序静态链表，L.r[0]为头结点。算法10.17 */
int i;
ArrType f,e;
for(i=0;i<(*L).recnum;++i)
(*L).r[i].next=i+1;
(*L).r[(*L).recnum].next=0; /* 将L改造为静态链表 */
for(i=0;i<(*L).keynum;++i)
{ /* 按最低位优先依次对各关键字进行分配和收集 */
Distribute((*L).r,i,f,e); /* 第i趟分配 */
Collect((*L).r,f,e); /* 第i趟收集 */
printf("第%d趟收集后:\n",i+1);
printl(*L);
printf("\n");
}
}
void plDistribComponent_old::Preview()
{
if( !NumTargets() )
return;
GetCOREInterface()->DisableSceneRedraw();
plDistribInstTab replicants;
plExportProgressBar bar;
bar.Start("Preview", NumTargets() << 4);
plDistTree distTree;
Distribute(replicants, bar, &distTree);
IMakeOne(replicants);
Done();
GetCOREInterface()->EnableSceneRedraw();
GetCOREInterface()->ForceCompleteRedraw(FALSE);
}
void Radixsort() {
/*对R[0...n-1]进行基数排序，R[i].key为非负整数，且位数不超过KeySize*/
int i,k;
for (i=0; i<Radix; i++)
InitQueue(i);
for (i=KeySize-1; i>=0; i--) {
Distribute(i);
Collect(B);
if ((KeySize-i)==m) {
printf("第%d趟的结果是：",m);
for(k=0; k<n; k++)
printf("%5d",R[k].key);
printf("\n");
printf("请输入还要输出第几趟结果，不想输出时请输入0：");
scanf("\n%d",&m);
}
}
printf("最终排序结果是：");
for (k=0; k<n; k++)
printf("%5d",R[k].key);
printf("\n");
}/*Radixsort*/
// ragged right でフォーマットされた行を両端揃えにする。
void JustifyLine(VisualLine *line, const PageInfo *page)
{
Token *trailing_space_start; // 仮想の行末。残りの空白は右マージンに被せる。
trailing_space_start = EffectiveLineEnd(line);
// この行に空白しか無い場合は何もしない。
if (trailing_space_start == line->tokens)
return;
int nspaces = 0;
for (Token *tok = line->tokens; tok < trailing_space_start; tok++)
if (tok->chars[0].utf8[0] == ' ')
nspaces++;
// 空白トークンが無いので、その幅も調整できない。
if (nspaces == 0)
goto Tracking;
// 最後の空白でないトークン。
Token *last_token = trailing_space_start - 1;
short right_edge = last_token->x + last_token->width;
// printf("%hd vs %hd\n", PageInfoGetVisibleWidth(page), right_edge);
// assert(PageInfoGetVisibleWidth(page) >= right_edge);
if (PageInfoGetVisibleWidth(page) <= right_edge)
goto Tracking;
// それぞれの空白トークンについて、増やすべき幅を計算する。
int *addends = alloca(nspaces * sizeof(int));
short shortage = PageInfoGetVisibleWidth(page) - right_edge;
Distribute(shortage, nspaces, addends);
// ぶらさがっていない空白トークンに幅を分配する。
int i = 0;
int SPACE_STRETCH_LIMIT = YFontTextWidth(font, " ", 1) * 3;
for (Token *tok = line->tokens; tok != trailing_space_start; tok++) {
if (TokenIsSpace(tok)) {
int addend = (addends[i] > SPACE_STRETCH_LIMIT) ? SPACE_STRETCH_LIMIT : addends[i];
tok->width += addend;
i++;
}
}
UpdateTokenPositions(line);
Tracking:
last_token = trailing_space_start - 1;
right_edge = last_token->x + last_token->width;
shortage = PageInfoGetVisibleWidth(page) - right_edge;
size_t ntokens = trailing_space_start - line->tokens - 1;
if (ntokens == 0) {
// 最初のトークンが最後の可視トークンである場合。
return;
}
short MAX_TRACK_DELTA = (short) (YFontEm(font) / 8.0);
if (shortage == 0) {
return;
} if (shortage > 0) {
int addends[ntokens];
Distribute(shortage, ntokens, addends);
for (int i = 0; i < ntokens; i++) {
line->tokens[i].width += addends[i] > MAX_TRACK_DELTA ? MAX_TRACK_DELTA : addends[i];
}
} else {
short excess = -shortage;
int subtrahends[ntokens];
Distribute(excess, ntokens, subtrahends);
for (int i = 0; i < ntokens; i++) {
line->tokens[i].width -= subtrahends[i] > MAX_TRACK_DELTA ? MAX_TRACK_DELTA : subtrahends[i];
}
}
UpdateTokenPositions(line);
}
ParGridFunction::ParGridFunction(ParFiniteElementSpace *pf, HypreParVector *tv)
: GridFunction(pf), pfes(pf)
{
Distribute(tv);
}
