lua的表table排序报错原因及源码分析

lua表table排序的使用方式

lua table

-- test.lua
local tb = {5,4,3,2,1}
-- 可以这样使用默认比较函数
table.sort(tb)
-- 或者这样传一个自定义比较函数
table.sort(tb, function(a,b) return a < b end)
for k,v in pairs(tb) do
    print(k, v)
end

最终结果都是输出递增顺序的1 2 3 4 5

moses@DESKTOP-LIB8NT7:/mnt/e/lua-5.4.3/src$ ./lua test.lua
1       1
2       2
3       3
4       4
5       5

产生报错的情况

在使用自定义比较函数时要注意若a==b时必须返回false否则会报错

-- 注意这里的比较符是 <=
table.sort(tb, function(a,b) return a <= b end) 

报错如下

moses@DESKTOP-LIB8NT7:/mnt/e/lua-5.4.3/src$ ./lua test.lua
./lua: test.lua:6: invalid order function for sorting
stack traceback:
        [C]: in function 'table.sort'
        test.lua:6: in main chunk
        [C]: in ?

结论

在a,b两个元素相等时，比较函数必须返回false，否则将会产生报错

---

原因分析

lua中表的排序用的是快速排序，我们来看一下代码(为了看起来简单些删去了一部分代码)
表实际的排序是由auxsort完成的，基本都有英语注释，也比较好理解

static void auxsort (lua_State *L, IdxT lo, IdxT up,
                                   unsigned int rnd) {
  while (lo < up) {  /* loop for tail recursion */
    IdxT p;  /* 选择的中值点 */ 
    .. 
    if (sort_comp(L, -1, -2))  /* a[up] < a[lo]? */
      set2(L, lo, up);  /* swap a[lo] - a[up] */
    .. 
    /* 代码运行到这时必 a[lo] <= a[up] */
    
    if (up - lo == 1)  /* only 2 elements? */
      return;  /* already sorted */
    ..
      p = (lo + up)/2;  /* middle element is a good pivot */
	..
      
    /* 上面选择了一个中心点，用来进行快速排序中的 挖洞 */
    
    if (sort_comp(L, -2, -1))  /* a[p] < a[lo]? */
      set2(L, p, lo);  /* swap a[p] - a[lo] */
    else {
      ..
      if (sort_comp(L, -1, -2))  /* a[up] < a[p]? */
        set2(L, p, up);  /* swap a[up] - a[p] */
      ..
    }
    
    /* 代码运行到这时必 a[lo] <= a[p] <= a[up] */
    
    if (up - lo == 2)  /* only 3 elements? */
      return;  /* already sorted */
    ..
    set2(L, p, up - 1);  /* swap Pivot (a[p]) with a[up - 1] */
    
    /* 将a[p] 放在 a[up -1] 的位置，然后将在 a[lo] a[up-2] 区间内进行快速的交换操作 */
    
    p = partition(L, lo, up); /* 见下面的解释 */
    /* a[lo .. p - 1] <= a[p] == P <= a[p + 1 .. up] */
    
    /* 左边部分都 <= a[p]了 右边都 >= a[p]，下面分别对左右两边的子集进行递归操作 */
    
    if (p - lo < up - p) {  /* lower interval is smaller? */
      auxsort(L, lo, p - 1, rnd);  /* call recursively for lower interval */
      ..
    }
    else {
      auxsort(L, p + 1, up, rnd);  /* call recursively for upper interval */
      ..
    }
  }  /* tail call auxsort(L, lo, up, rnd) */
}

partition 函数目的是把 <= 中值数P的 元素都放在左边， >= 中值数P的元素都放在右边 重点来啦见代码注释

static IdxT partition (lua_State *L, IdxT lo, IdxT up) {
  IdxT i = lo;  /* will be incremented before first use */
  IdxT j = up - 1;  /* will be decremented before first use */
  /* a[up -1] 里存放的是我们之前选择的中值数 */
  for (;;) {
  
    /* 从左向右找到第1个不小于P的 */
    
    while ((void)lua_geti(L, 1, ++i), sort_comp(L, -1, -2)) { 
      /* ------------------------------------
       这里sort_comp会调用我们提供的比较函数，若对相等的对象返回true，当i==up-1时，就肯定进行循环内部，触发报错
       举一个例子     
        local tb = {5,2,4,3,1}
		这个数组在进入partition函数前应该是下面这样
		tb = {1, 2, 3, 4, 5} 4为选择的中值
		在这里的while循环，若a==b返回为true则一定会进入到循环里触发此处的报错，
		若不报错再运行下去就破坏了整个快速排序的过程了。
      ------------------------------------ */
      if (l_unlikely(i == up - 1))  /* a[i] < P  but a[up - 1] == P  ?? */
        luaL_error(L, "invalid order function for sorting");
      lua_pop(L, 1);  /* remove a[i] */
    }
    
    /* 从右a[up-2]向左找到第1个不大于P的 */
    
    while ((void)lua_geti(L, 1, --j), sort_comp(L, -3, -1)) {
      if (l_unlikely(j < i))  /* j < i  but  a[j] > P ?? */
        luaL_error(L, "invalid order function for sorting");
      lua_pop(L, 1);  /* remove a[j] */
    }
    /* 整个区间都进行了交换操作 <= P的元素都在左边， >= P的都在右边了， */
    if (j < i) {  /* no elements out of place? */
      ..
      /* 将a[up-1]也就是中值数P再放到i的位置，这样就a[lo --> i-1] <= P <= a[i+1 --> up-1] <= a[up]了 */
      set2(L, up - 1, i);
      return i;
    }
    
    /* 交换上面找到的两个数然后继续找，继续交换 */
    set2(L, i, j);
  }
}