mirror of
https://github.com/lua/lua
synced 2024-12-24 03:16:50 +03:00
new sort algorithm.
This commit is contained in:
Roberto Ierusalimschy
parent
b9c9ccfbb4
commit
03d38b66fd
120
lbuiltin.c
120
lbuiltin.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
** $Id: lbuiltin.c,v 1.40 1998/12/27 20:22:36 roberto Exp roberto $
|
||||
** $Id: lbuiltin.c,v 1.43 1998/12/30 13:16:50 roberto Exp $
|
||||
** Built-in functions
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
@ -28,7 +28,7 @@
|
||||
|
||||
|
||||
/*
|
||||
** =======================================================
|
||||
** {======================================================
|
||||
** Auxliliar functions
|
||||
** =======================================================
|
||||
*/
|
||||
@ -45,7 +45,6 @@ static void pushtagstring (TaggedString *s) {
|
||||
static real getsize (Hash *h) {
|
||||
real max = 0;
|
||||
int i;
|
||||
LUA_ASSERT(ttype(t) == LUA_T_ARRAY, "table expected");
|
||||
for (i = 0; i<nhash(h); i++) {
|
||||
Node *n = h->node+i;
|
||||
if (ttype(ref(n)) == LUA_T_NUMBER &&
|
||||
@ -77,15 +76,11 @@ static void luaB_getn (void) {
|
||||
lua_pushnumber(getnarg(gethash(1)));
|
||||
}
|
||||
|
||||
|
||||
static void tablemove (Hash *a, int from, int to) {
|
||||
TObject temp = *luaH_getint(a, from);
|
||||
luaH_setint(a, to, &temp);
|
||||
}
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
/*
|
||||
** =======================================================
|
||||
** {======================================================
|
||||
** Functions that use only the official API
|
||||
** =======================================================
|
||||
*/
|
||||
@ -243,10 +238,11 @@ static void luaB_collectgarbage (void) {
|
||||
lua_pushnumber(lua_collectgarbage(luaL_opt_int(1, 0)));
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
/*
|
||||
** =======================================================
|
||||
** {======================================================
|
||||
** Functions that could use only the official API but
|
||||
** do not, for efficiency.
|
||||
** =======================================================
|
||||
@ -307,13 +303,16 @@ static void luaB_call (void) {
|
||||
}
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
/*
|
||||
** =======================================================
|
||||
** {======================================================
|
||||
** "Extra" functions
|
||||
** (These functions can be written in Lua, so you can
|
||||
** delete them if you need a tiny Lua implementation.)
|
||||
** These functions can be written in Lua, so you can
|
||||
** delete them if you need a tiny Lua implementation.
|
||||
** If you delete them, remove their entries in array
|
||||
** "builtin_funcs".
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
@ -332,8 +331,7 @@ static void luaB_foreachi (void) {
|
||||
luaD_checkstack(3); /* for f, ref, and val */
|
||||
for (i=1; i<=n; i++) {
|
||||
*(L->stack.top++) = f;
|
||||
ttype(L->stack.top) = LUA_T_NUMBER;
|
||||
nvalue(L->stack.top++) = i;
|
||||
ttype(L->stack.top) = LUA_T_NUMBER; nvalue(L->stack.top++) = i;
|
||||
*(L->stack.top++) = *luaH_getint(t, i);
|
||||
luaD_calln(2, 1);
|
||||
if (ttype(L->stack.top-1) != LUA_T_NIL)
|
||||
@ -400,7 +398,7 @@ static void luaB_tinsert (void) {
|
||||
}
|
||||
luaV_setn(a, n+1); /* increment field "n" */
|
||||
for ( ;n>=pos; n--)
|
||||
tablemove(a, n, n+1);
|
||||
luaH_move(a, n, n+1);
|
||||
luaH_setint(a, pos, luaA_Address(v));
|
||||
}
|
||||
|
||||
@ -413,69 +411,79 @@ static void luaB_tremove (void) {
|
||||
if (n <= 0) return; /* table is "empty" */
|
||||
luaV_setn(a, n-1); /* decrement field "n" */
|
||||
for ( ;pos<n; pos++)
|
||||
tablemove(a, pos+1, pos);
|
||||
luaH_move(a, pos+1, pos);
|
||||
luaA_pushobject(&v);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Quicksort algorithm from "Programming Pearls", pg. 112
|
||||
/* {
|
||||
** Quicksort
|
||||
*/
|
||||
|
||||
static void swap (Hash *a, int i, int j) {
|
||||
/* notice: must use two temporary vars, because luaH_setint may cause a
|
||||
rehash and change the addresses of values in the array */
|
||||
TObject ai = *luaH_getint(a, i);
|
||||
tablemove(a, j, i);
|
||||
luaH_setint(a, j, &ai);
|
||||
TObject temp = *luaH_getint(a, i);
|
||||
luaH_move(a, j, i);
|
||||
luaH_setint(a, j, &temp);
|
||||
}
|
||||
|
||||
static int sort_comp (TObject *f, TObject *a, TObject *b) {
|
||||
/* notice: the caller (auxsort) must check stack space */
|
||||
if (f) {
|
||||
*(L->stack.top++) = *f;
|
||||
*(L->stack.top++) = *a;
|
||||
*(L->stack.top++) = *b;
|
||||
*(L->stack.top) = *f;
|
||||
*(L->stack.top+1) = *a;
|
||||
*(L->stack.top+2) = *b;
|
||||
L->stack.top += 3;
|
||||
luaD_calln(2, 1);
|
||||
}
|
||||
else { /* a < b? */
|
||||
*(L->stack.top++) = *a;
|
||||
*(L->stack.top++) = *b;
|
||||
*(L->stack.top) = *a;
|
||||
*(L->stack.top+1) = *b;
|
||||
L->stack.top += 2;
|
||||
luaV_comparison(LUA_T_NUMBER, LUA_T_NIL, LUA_T_NIL, IM_LT);
|
||||
}
|
||||
return ttype(--(L->stack.top)) != LUA_T_NIL;
|
||||
}
|
||||
|
||||
static void auxsort (Hash *a, int l, int u, TObject *f) {
|
||||
init:
|
||||
init: /* using goto's to optimize tail recursion */
|
||||
if (u <= l) return; /* 0 or 1 element */
|
||||
luaD_checkstack(4); /* for pivot, f, a, b (sort_comp) */
|
||||
if (u-l == 1) { /* only two elements? */
|
||||
if (sort_comp(f, luaH_getint(a, u), luaH_getint(a, l))) /* a[u] < a[l]? */
|
||||
swap(a, l, u);
|
||||
}
|
||||
else {
|
||||
int i;
|
||||
int m = l;
|
||||
swap(a, l, (l+u)/2); /* put middle element as pivot (a[l]) */
|
||||
*(L->stack.top++) = *luaH_getint(a, l); /* save pivot on stack (for GC) */
|
||||
for (i=l+1; i<=u; i++) {
|
||||
/* invariant: a[l+1..m] < P <= a[m+1..i-1] */
|
||||
if (sort_comp(f, luaH_getint(a, i), L->stack.top-1)) { /* a[i] < P? */
|
||||
m++;
|
||||
swap(a, m, i);
|
||||
}
|
||||
TObject *P;
|
||||
int i, j;
|
||||
/* sort elements a[l], a[(l+u)/2] and a[u] */
|
||||
if (sort_comp(f, luaH_getint(a, u), luaH_getint(a, l))) /* a[l]>a[u]? */
|
||||
swap(a, l, u);
|
||||
if (u-l == 1) return; /* only 2 elements */
|
||||
i = (l+u)/2;
|
||||
if (sort_comp(f, luaH_getint(a, i), luaH_getint(a, l))) /* a[l]>a[i]? */
|
||||
swap(a, l, i);
|
||||
else if (sort_comp(f, luaH_getint(a, u), luaH_getint(a, i))) /* a[i]>a[u]? */
|
||||
swap(a, i, u);
|
||||
if (u-l == 2) return; /* only 3 elements */
|
||||
P = L->stack.top++;
|
||||
*P = *luaH_getint(a, i); /* save pivot on stack (for GC) */
|
||||
swap(a, i, u-1); /* put median element as pivot (a[u-1]) */
|
||||
/* a[l] <= P == a[u-1] <= a[u], only needs to sort from l+1 to u-2 */
|
||||
i = l; j = u-1;
|
||||
for (;;) {
|
||||
/* invariant: a[l..i] <= P <= a[j..u] */
|
||||
while (sort_comp(f, luaH_getint(a, ++i), P)) /* stop when a[i] >= P */
|
||||
if (i>u) lua_error("invalid order function for sorting");
|
||||
while (sort_comp(f, P, luaH_getint(a, --j))) /* stop when a[j] <= P */
|
||||
if (j<l) lua_error("invalid order function for sorting");
|
||||
if (j<i) break;
|
||||
swap(a, i, j);
|
||||
}
|
||||
swap(a, u-1, i); /* swap pivot (a[u-1]) with a[i] */
|
||||
L->stack.top--; /* remove pivot from stack */
|
||||
swap(a, l, m); /* swap pivot with a[m] */
|
||||
/* a[l..m-1] < a[m] <= a[m+1..u] */
|
||||
if (m-l < u-m) { /* check which "half" is bigger */
|
||||
auxsort(a, l, m-1, f); /* call recursively the smaller one */
|
||||
l = m+1; goto init; /* auxsort(a, m+1, u, f); */
|
||||
/* a[l..i-1] <= a[i] == P <= a[i+1..u] */
|
||||
if (i-l < u-i) { /* check which "half" is bigger */
|
||||
auxsort(a, l, i-1, f); /* call recursively the smaller one */
|
||||
l = i+1; goto init; /* auxsort(a, i+1, u, f); */
|
||||
}
|
||||
else {
|
||||
auxsort(a, m+1, u, f);
|
||||
u = m-1; goto init; /* auxsort(a, l, m-1, f); */
|
||||
auxsort(a, i+1, u, f);
|
||||
u = i-1; goto init; /* auxsort(a, l, i-1, f); */
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -487,14 +495,16 @@ static void luaB_sort (void) {
|
||||
lua_Object func = lua_getparam(2);
|
||||
TObject *f = luaA_Address(func);
|
||||
luaL_arg_check(!f || lua_isfunction(func), 2, "function expected");
|
||||
luaD_checkstack(4); /* for Pivot, f, a, b (sort_comp) */
|
||||
auxsort(a, 1, n, f);
|
||||
lua_pushobject(t);
|
||||
}
|
||||
|
||||
/* }}===================================================== */
|
||||
|
||||
|
||||
/*
|
||||
** =======================================================
|
||||
** {======================================================
|
||||
** Internal Functions.
|
||||
** These functions need access to internal structures
|
||||
** to be implemented.
|
||||
@ -576,12 +586,13 @@ static void luaB_type (void) {
|
||||
lua_pushnumber(lua_tag(o));
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
|
||||
#ifdef DEBUG
|
||||
/*
|
||||
** =======================================================
|
||||
** {======================================================
|
||||
** some DEBUG functions
|
||||
** =======================================================
|
||||
*/
|
||||
@ -652,6 +663,7 @@ static void testC (void) {
|
||||
}
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user