第十八章 算法

  dataType[] arrayRefVar;	//首选的方法
  // 或
  dataType arrayRefVar[];	//效果相同，但不是首选方法

  dataType[ ] arrayRefVar = new dataType[ arraySize];

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    //可序列化版本号
    private static final long serialVersionUID = 8683452581122892189L;
 
    //默认的初始化数组大小 为10 .
    private static final int DEFAULT_CAPACITY = 10;
 
    //实例化一个空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
 
    //存放List元素的数组
    private transient Object[] elementData;
 
    //List中元素的数量，和存放List元素的数组长度可能相等，也可能不相等
    private int size;
 
    //构造方法，指定初始化的数组长度
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }
 
    //无参构造方法
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }
 
    //构造方法，参数为集合元素
    public ArrayList(Collection<? extends E> c) {
        //将集合转换成数组，并赋值给elementData数组
        elementData = c.toArray();
        size = elementData.length;
        //如果c.toArray返回的不是Object[]类型的数组，转换成Object[]类型
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }
 
    //改变数组的长度，使长度和List的size相等。
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = Arrays.copyOf(elementData, size);
        }
    }
 
    //确定ArrayList的容量
    //判断当前elementData是否是EMPTY_ELEMENTDATA,若是设置长度为10
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != EMPTY_ELEMENTDATA)
            // any size if real element table
            ? 0
            // larger than default for empty table. It's already supposed to be
            // at default size.
            : DEFAULT_CAPACITY;
        //是否需要扩容
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    //当前位置和默认大小之间取最大值
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
 
        ensureExplicitCapacity(minCapacity);
    }
 
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
 
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
 
    //数组的最大容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 
    //扩容操作
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //容量扩充1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //生成一个长度为newCapacity数组，并将elementData数组中元素拷贝到新数组中，并将新数组的引用赋值给elementData
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
 
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
 
    //返回数组中已经放入的元素个数，非数组长度
    public int size() {
        return size;
    }
 
    //List是否为空
    public boolean isEmpty() {
        return size == 0;
    }
 
    //判断是否包包含指定元素
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
 
    //查找指定的元素，存在返回下标，不存在放回 -1 
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
 
    //倒序查找元素，存在放回下标，不存在返回-1 
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
 
    //因为实现了clone接口，所以需要重写clone()方法，实现对象的拷贝
    public Object clone() {
        try {
            @SuppressWarnings("unchecked")
                ArrayList<E> v = (ArrayList<E>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }
 
    //将集合转化为数组
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }
 
    //转化为指定类型的数组元素，推荐使用此方法
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }
 
    // Positional Access Operations
    //放回指定位置的数组元素
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }
 
    //返回列表中指定位置的元素
    public E get(int index) {
        rangeCheck(index);
 
        return elementData(index);
    }
 
    //设置指定位置的元素，并返回被替换的元素
    public E set(int index, E element) {
        rangeCheck(index);
 
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
 
    //添加元素
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    //将元素添加到指定位置上，从指定位置的元素开始所有元素向后移动，为新添加的元素提供位置
    public void add(int index, E element) {
        rangeCheckForAdd(index);
 
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
 
    //删除指定位置的元素，其他元素做相依的移动，并将最后一个元素置空，方便垃圾处理机制回收，防止内存泄露，并返回删除的元素值
    public E remove(int index) {
        rangeCheck(index);
 
        modCount++;
        E oldValue = elementData(index);
 
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
 
        return oldValue;
    }
 
    //删除元素方法
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
 
    //快速删除执行操作
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }
 
    //清除列表
    public void clear() {
        modCount++;
 
        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;
 
        size = 0;
    }
 
    //添加方法，添加的元素为集合
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }
 
    //从指定位置开始添加集合元素
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);
 
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
 
        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
 
        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }
 
    //范围删除方法
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);
 
        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }
 
    //下标检测方法，如果不合法，抛出IndexOutOfBoundsException异常
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
 
    /**
     * A version of rangeCheck used by add and addAll.
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
 
    //溢出信息
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }
 
    //删除所有元素
    public boolean removeAll(Collection<?> c) {
        return batchRemove(c, false);
    }
 
    
    public boolean retainAll(Collection<?> c) {
        return batchRemove(c, true);
    }
 
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }
  //流操作方法，将对象写入输出流中
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
 
        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);
 
        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
 
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
 
    //流操作，读方法，将对象从流中取出
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;
 
        // Read in size, and any hidden stuff
        s.defaultReadObject();
 
        // Read in capacity
        s.readInt(); // ignored
 
        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);
 
            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }
 
    //迭代方法，返回内部类实例
    public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }
 
    //迭代方法，返回内部类实例
    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }
 
    //迭代方法，返回内部类实例
    public Iterator<E> iterator() {
        return new Itr();
    }
 
    //内部类，实现Iterator接口
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;
        //是否还有下一个元素，返回true or false 
        public boolean hasNext() {
            return cursor != size;
        }
        //返回元素
        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;   //获取外部类的elementData数组
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
        //删除元素
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
 
            try {
                ArrayList.this.remove(lastRet);  //调用外部类删除方法，删除指定位置的元素
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
 
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
 
    //省略了ListItr、SubList两个内部类
}

ArrayList(int initialCapacity);
ArrayList(); 
ArrayList(Collection<? extends E> c);

public boolean add(E e) {
	// 关键 -> 添加之前，校验容量
	ensureCapacityInternal(size + 1); 
	
	// 修改 size，并在数组末尾添加指定元素
	elementData[size++] = e;
	return true;
}
 
// 关键 -> minCapacity = size+1，即表示执行完添加操作后，数组中的元素个数 
private void ensureCapacityInternal(int minCapacity) {
	// 判断内部数组是否为空
	if (elementData == EMPTY_ELEMENTDATA) {
		// 设置数组最小容量（>=10）
		minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
	}
	ensureExplicitCapacity(minCapacity);
}
//接着会判断添加操作会不会导致内部数组的容量饱和
private void ensureExplicitCapacity(int minCapacity) {
	modCount++;
	
	// 判断结果为 true，则表示接下来的添加操作会导致元素数量超出数组容量
	if (minCapacity - elementData.length > 0){
		// 真正的扩容操作
		grow(minCapacity);
	}
}
 
 
//实现真正的扩容公式与数组的拷贝
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 
private void grow(int minCapacity) {
	
	int oldCapacity = elementData.length;
	
	// 关键-> 容量扩充公式
	int newCapacity = oldCapacity + (oldCapacity >> 1);
	
	// 针对新容量的一系列判断
	if (newCapacity - minCapacity < 0){
		newCapacity = minCapacity;
	}
	if (newCapacity - MAX_ARRAY_SIZE > 0){
		newCapacity = hugeCapacity(minCapacity);
	}
		
	// 关键 -> 复制旧数组元素到新数组中去
	elementData = Arrays.copyOf(elementData, newCapacity);
}
 
private static int hugeCapacity(int minCapacity) {
	if (minCapacity < 0){
		throw new OutOfMemoryError();
	}
			
	return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

3.3 链表

3.3.1 什么是链表

public static int binarySearch(Integer[] srcArray, int des) {
    //定义初始最小、最大索引
    int start = 0;
    int end = srcArray.length - 1;
    //确保不会出现重复查找，越界
    while (start <= end) {
        //计算出中间索引值
        int middle = (end + start)>>>1 ;//防止溢出
        if (des == srcArray[middle]) {
            return middle;
        //判断下限
        } else if (des < srcArray[middle]) {
            end = middle - 1;
        //判断上限
        } else {
            start = middle + 1;
        }
    }
    //若没有，则返回-1
    return -1;
}

5.2 选择排序

public int[] selectSort(int[] array) {
    if (array == null || array.length < 2) {
        return array;
    }
 
    for (int i = 0; i < array.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] < array[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex > i) {
            array[i] = array[i] ^ array[minIndex];
            array[minIndex] = array[i] ^ array[minIndex];
            array[i] = array[i] ^ array[minIndex];
        }
    }
    return array;
}

public int[] insertSort(int[] array) {
    if (array == null || array.length < 2) {
        return array;
    }
 
    for (int i = 1; i < array.length; i++) {
        int temp = array[i];
        int j = i - 1;
        while (j >= 0 && array[j] > temp) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = temp;
    }
    return array;
}

public int[] shellSort(int[] array) {
    if (array == null || array.length < 2) {
        return array;
    }
 
    int gap = array.length >>> 1;
    while (gap > 0) {
        for (int i = gap; i < array.length; i++) {
            int temp = array[i];
            int j = i - gap;
            while (j >= 0 && array[j] > temp) {
                array[j + gap] = array[j];
                j = j - gap;
            }
            array[j + gap] = temp;
        }
        gap >>>= 1;
    }
    return array;
}

public class MaxHeap {
 
    /**
     * 排序数组
     */
    private int[] nodeArray;
    /**
     * 数组的真实大小
     */
    private int size;
 
    private int parent(int index) {
        return (index - 1) >>> 1;
    }
 
    private int leftChild(int index) {
        return (index << 1) + 1;
    }
 
    private int rightChild(int index) {
        return (index << 1) + 2;
    }
 
    private void swap(int i, int j) {
        nodeArray[i] = nodeArray[i] ^ nodeArray[j];
        nodeArray[j] = nodeArray[i] ^ nodeArray[j];
        nodeArray[i] = nodeArray[i] ^ nodeArray[j];
    }
 
    private void siftUp(int index) {
        //如果index处节点的值大于其父节点的值，则交换两个节点值，同时将index指向其父节点，继续向上循环判断
        while (index > 0 && nodeArray[index] > nodeArray[parent(index)]) {
            swap(index, parent(index));
            index = parent(index);
        }
    }
 
    private void siftDown(int index) {
        //左孩子的索引比size小，意味着索引index处的节点有左孩子，证明此时index节点不是叶子节点
        while (leftChild(index) < size) {
            //maxIndex记录的是index节点左右孩子中最大值的索引
            int maxIndex = leftChild(index);
            //右孩子的索引小于size意味着index节点含有右孩子
            if (rightChild(index) < size && nodeArray[rightChild(index)] > nodeArray[maxIndex]) {
                maxIndex = rightChild(index);
            }
            //如果index节点值比左右孩子值都大，则终止循环
            if (nodeArray[index] >= nodeArray[maxIndex]) {
                break;
            }
            //否则进行交换，将index指向其交换的左孩子或右孩子，继续向下循环，直到叶子节点
            swap(index, maxIndex);
            index = maxIndex;
        }
    }
 
    private void add(int value) {
        nodeArray[size++] = value;
        //构建大顶堆
        siftUp(size - 1);
    }
 
    private void extractMax() {
        /*
        将堆顶元素和最后一个元素进行交换
        此时并没有删除元素，而只是将size-1，剩下的元素重新构建成大顶堆
         */
        swap(0, --size);
        //重新构建大顶堆
        siftDown(0);
    }
 
    public int[] heapSort(int[] array) {
        if (array == null || array.length < 2) {
            return array;
        }
 
        nodeArray = new int[array.length];
        for (int value : array) {
            add(value);
        }
        for (int ignored : array) {
            extractMax();
        }
        return nodeArray;
    }
}

public int[] mergeSort(int[] array) {
    if (array == null || array.length < 2) {
        return array;
    }
 
    return mergeSort(array, 0, array.length - 1);
}
 
private int[] mergeSort(int[] array, int left, int right) {
    if (left < right) {
        //这里没有选择“(left + right) / 2”的方式，是为了防止数据溢出
        int mid = left + ((right - left) >>> 1);
        // 拆分子数组
        mergeSort(array, left, mid);
        mergeSort(array, mid + 1, right);
        // 对子数组进行合并
        merge(array, left, mid, right);
    }
    return array;
}
 
private void merge(int[] array, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    // p1和p2为需要对比的两个数组的指针，k为存放temp数组的指针
    int p1 = left, p2 = mid + 1, k = 0;
    while (p1 <= mid && p2 <= right) {
        if (array[p1] <= array[p2]) {
            temp[k++] = array[p1++];
        } else {
            temp[k++] = array[p2++];
        }
    }
    // 把剩余的数组直接放到temp数组中
    while (p1 <= mid) {
        temp[k++] = array[p1++];
    }
    while (p2 <= right) {
        temp[k++] = array[p2++];
    }
    // 复制回原数组
    for (int i = 0; i < temp.length; i++) {
        array[i + left] = temp[i];
    }
}

5.7 快速排序

<table style="text-align: center;">
    <tr>
        <td rowspan="2">排序算法</td>
        <td colspan="3">时间复杂度</td>
        <td rowspan="2">空间复杂度</td>
        <td rowspan="2">稳定性</td>
    </tr>
	<tr>
        <td>平均情况</td>
        <td>最好情况</td>
        <td>最坏情况</td>
    </tr>
    <tr>
    	<td>冒泡排序</td>
    	<td>O(n<sup>2</sup>)</td>
    	<td>O(n)</td>
    	<td>O(n<sup>2</sup>)</td>
    	<td>O(1)</td>
    	<td>稳定</td>
    </tr>
    <tr>
    	<td>选择排序</td>
    	<td>O(n<sup>2</sup>)</td>
    	<td>O(n<sup>2</sup>)</td>
    	<td>O(n<sup>2</sup>)</td>
    	<td>O(1)</td>
    	<td>不稳定</td>
    </tr>
    <tr>
    	<td>插入排序</td>
    	<td>O(n<sup>2</sup>)</td>
    	<td>O(n)</td>
    	<td>O(n<sup>2</sup>)</td>
    	<td>O(1)</td>
    	<td>稳定</td>
    </tr>
    <tr>
    	<td>希尔排序</td>
    	<td colspan="3">取决于增量的选择</td>
    	<td>O(1)</td>
    	<td>不稳定</td>
    </tr>
    <tr>
    	<td>堆排序</td>
    	<td>O(nlog<sub>2</sub>n)</td>
    	<td>O(nlog<sub>2</sub>n)</td>
    	<td>O(nlog<sub>2</sub>n)</td>
    	<td>O(1)</td>
    	<td>不稳定</td>
    </tr>
    <tr>
    	<td>归并排序</td>
    	<td>O(nlog<sub>2</sub>n)</td>
    	<td>O(nlog<sub>2</sub>n)</td>
    	<td>O(nlog<sub>2</sub>n)</td>
    	<td>O(n)</td>
    	<td>稳定</td>
    </tr>
    <tr>
    	<td>快速排序</td>
    	<td>O(nlog<sub>2</sub>n)</td>
    	<td>O(nlog<sub>2</sub>n)</td>
    	<td>O(n<sup>2</sup>)</td>
    	<td>O(nlog<sub>2</sub>n)</td>
    	<td>不稳定</td>
    </tr>
    <tr>
    	<td>计数排序</td>
    	<td>O(n+k)</td>
    	<td>O(n+k)</td>
    	<td>O(n+k)</td>
    	<td>O(k)</td>
    	<td>稳定</td>
    </tr>
    <tr>
    	<td>桶排序</td>
    	<td colspan="3">取决于桶散列的结果和内部排序算法的时间复杂度</td>
    	<td>O(n+l)</td>
    	<td>稳定</td>
    </tr>
    <tr>
    	<td>基数排序</td>
    	<td>O(d*(n+r))</td>
    	<td>O(d*(n+r))</td>
    	<td>O(d*(n+r))</td>
    	<td>O(n+r)</td>
    	<td>稳定</td>
    </tr>
</table>