1、有人会直接用表与{}比较

local a = {}

if a == {} then
    print("a 是空表")
else 
    print("a 不是空表")
end

答案可能出乎你的意外，最后打印的是：a不是空表。因为table是引用变量，所以这里比较的是a的地址和匿名table的地址，所以是不相等的。

2、还有人可能用table.maxn()

local a = {key = 1}

if table.maxn(a) == 0 then
    print("a 是空表")
else 
    print("a 不是空表")
end


--[[
a 是空表
]]--

这个时候明明a不是空的但是用table.maxn却返回0，这是因为table.maxn返回的是数组形式的表的长度。

3、其实这里可以用到lua再带的函数next

local a = {}

if next(a) == nil then
    print("a 是空表")
else 
    print("a 不是空表")
end

--[[

a 是空表
]]--

 

L为指向表头结点的指针，分别写出带有头结点的单链表、单项循环链表和双向循环链表判空的条件
单链表 NULL==L->next
单向循环 L==L->next
双向循环 L==L->next&&L==L->prior

题目：判断一个链表是否为回文结构
给定一个链表的头节点head，请判断该链表是否为回文结构。
例如：1 ->2 -> 1，返回true。1 -> 2 -> 2 -> 1，返回true。15 -> 6 -> 15，返回true。1 -> 2 -> 3，返回 false 。
链表结构：
class Node{
    int value;
    Node next;

    public Node(int val){
        this.value = val;
    }
}
进阶：如果链表长度为 N ，时间复杂度达到O(N) ，额外空间复杂度达到 O(1)。
法一：借助辅助空间，使用栈
思路：
将链表 List 节点依次压入栈中，再依次弹出节点 node ；将 List 从头节点 head 开始比较，一旦发现不同则返回true；当head 为空时【比较结束】返回true。
图1 使用栈的思路
Code：
public boolean isPalindrome(Node head){
    Stack<Node> stack = new Stack<Node>();
    Node cur = head;
    while(cur != null){ //压栈
        stack.push(cur);
        cur = cur.next;
    }
    while(head != null){
        if(head.value != stack.pop().value)
            return false;
        head = head.next;
    }
    return true;
}
时间复杂度：需要遍历整个 List ，所以 T(n) = O(n) 。
空间复杂度：由于需要保存 List 的所有节点，所以 S(n) = O(n) 。
法二、快慢指针法
看到这个标题，思考一下能否不用保存整个 List 去解决这道题？
根据回文的特性，回文 List 必然是关于中间的对称轴对称的，如果从中间开始比较，是否可以用原先一半的空间来解决它？   ——Yes.
思路：
快指针 A 一次走 2 步，慢指针 B 一次走 1 步；当 A 走到 List 末尾时， B 刚好到中点；
B 将后半部分遍历并压入栈中；
A 再从头开始遍历，每遍历一个，栈 pop 一个进行比较。
某一步不相等 => false；遍历结束后且之前未返回 => true 。
Code:
public boolean isPalindrome2(Node head){    
    if(head == null || head.next == null) //空 or 仅有一个node的List是回文串
        return true;
    Node fast = head;
    Node slow = head; 
    while(fast.next != null && fast.next.next != null ){
        slow = slow.next; //最终到mid处
        fast = fast.next.next; //最终到end处
    }
    Stack<Node> stack = new Stack<Node>();
    while(slow != null){
        stack.push(slow);
        slow = slow.next; //继续从mid遍历到end
    }
    while(!stack.isEmpty()){
        if(head.value != stack.pop().value)
            return false;
        head = head.next;
    }
    return true;
}
时间复杂度：需要遍历整个 List ，所以 T(n) = O(n) 。
空间复杂度：仅需要保存 List 的后半部分节点，相比法一少了一半，但是去除系数，S(n) = O(n) 。
法三、快慢指针升级版
法二我们已经用到了快慢指针，能否借助它们，实现彻底不用 O(N) 级别的辅助空间？？
—— Yes.
首先我们能找到 List 的中点，让 List 一分为二，并让后半部分逆序；
接着前半部分从前往后，后半部分从后往前遍历，边遍历便比较。
如此，两个 node 的空间即解决了问题。
思路
快指针 A 一次走 2 步，慢指针 B 一次走 1 步；当 A 走到 List 末尾时， B 刚好到中点；
将中点的 next 指向 null ，右部分逆序；
两个 list 都从首开始遍历比较，直到结束。
得到 true / false 的结果后，记得将原结构恢复 。
细节
用 length-1 来计算：奇数个节点，中点指向null ；偶数个节点，慢指针会来到中点的前一个位置。如下图：
图2 让中点指向null
code
public boolean isPalindrome3(Node head){
    if(head == null || head.next == null)
        return true;
    Node n1 = head;
    Node n2 = head;
    while(n2.next != null && n2.next.next!=null){
        n1 = n1.next;
        n2 = n2.next.next;
    }
    n2 = n1.next; //n2 -> 右半部分第一个node
    n1.next = null; //mid.next -> null

    // convert right part  局部结构：n1 -> n2 -> n3 -> ni -> ...
    Node n3 = null;
    while(n2 != null){
        n3 = n2.next; // save n2的 next node
        n2.next = n1; // 改变n2指向
        n1 = n2; //移动n1
        n2 = n3; //移动n2
    }

    n3 = n1; //此时n2为空，n1为last node ,用n3记录下来便与恢复结构 
    n2 = head; //n2 为left part first node
    boolean res = true; //保存结果，最后才返回

    //check 回文
    while(n1 != null && n2 != null){
        if(n1.value != n2.value){
            res = false;
            break;
        }
        n1 = n1.next;
        n2 = n2.next;
    }

    //recover List
    n1 = n3.next;
    n3.next = null;
    while(n1 != null){
        n2 = n1.next;
        n1.next = n3;
        n3 = n1;
        n1 = n2;
    }

    return res;

}
时间复杂度：需要遍历整个 List ，所以 T(n) = O(n) 。
空间复杂度：仅仅用到了两个额外空间，S(n) = O(1) 。
法三的注意点：不能直接得到结果后立刻返回，要记得把原结构恢复；反转链表的操作要细心。

大家好，我们今日继续讲解VBA代码解决方案的第57讲内容：判断工作表是否为空表。在实际的工作中，我们要常常判断某个工作表是否为空的，那么在VBA中是如何能做到这一点呢？
VBA中没有专门的属性或函数可以判断工作表是否为空白工作表，可以使用自定义函数返回指定工作表是否为空工作表
知识点一：利用工作表函数CountA统计工作表已使用区域的非空单元格个数：COUNTA函数功能是返回参数列表中非空的单元格个数。利用函数 COUNTA 可以计算单元格区域或数组中包含数据的单元格个数。
知识点二：我们可以自定义一个函数，利用CountA统计工作表已使用区域的非空单元格个数，如果这个数值为0，那么这个工作表就是空的。
首先看看我们的自定义函数，如下面的代码所示。
Function MyIsBlankSht(Sh As Variant) As Boolean
If TypeName(Sh) = "String" Then Set Sh = Worksheets(Sh)
If Application.CountA(Sh.UsedRange.Cells) = 0 Then
MyIsBlankSht = True
End If
End Function
代码解析：
自定义MyIsBlankSht函数包含一个Variant变量类型的参数，代表工作表名称或者对象名称。如果指定的工作表为空工作表，则该函数返回True。
第2行代码使用TypeName函数判断参数Sh是否为字符串类型("String")，如果是字符串，则将以该字符串作为名称的工作表赋值给变量Sh。
第3行代码通过工作表函数CountA统计工作表已使用区域的非空单元格个数，如果统计结果为0，则表示该工作表为空工作表。
我们看看上述自定义函数在实际中的利用：有了上述的自定义函数，现在就可以像使用VBA函数一样使用自定义的MyIsBlankSht函数，如下面的代码我们要首先判断一下某个工作表是否为空，如果为空，那么删除它。
Sub MyDelBlankSht()
Dim Sh As Worksheet
Application.DisplayAlerts = False
i = 1
For Each Sh In ThisWorkbook.Sheets
If MyIsBlankSht(Sh) Then Sh.Delete: MsgBox "删除" & i & "个工作了": i = i + 1
Next
Application.DisplayAlerts = True
MsgBox "共删除" & i - 1 & "个工作！"
End Sub代码解析：
使用自定义的MyIsBlankSht函数删除工作簿中所有空工作表。
第3行代码将Application对象的DisplayAlerts属性设置为False，使删除时不显示系统警告对话框。
第5行到第7行代码，使用For Each...Next语句遍历所有工作表，使用自定义的MyIsBlankSht函数判断是否为空表，如果为空表则使用Delete方法删除。
注意 自定义MyIsBlankSht函数仅仅判断工作表单元格区域内容是否为空，如果工作表中存在其它对象(如图形对象、数据有效性、单元格批注等)，不作为判断的基准。
代码实测：
代码截图：
运行截图：每删除一个工作表会告诉我们删除的个数。
最后会告诉我们共删除了几个工作表：
今日内容回向：
1 如何判断工作表为空呢？
2 如何删除空白的工作表呢？