数组前移，for循环从小到大赋值

for(int k=i+1;k<m_length;k++)

{

    m_plist[k-1]=m_plist[k];

}

数组后移操作 倒序循环赋值

for(int k=m_length-1;k>=i;k--)

{    

}

链表的清空函数 ClearList() 的解释：

将头结点m_pList后的所有节点删除，并将头结点m_pList的对象指针next指针置为NULL。

void list::ClearList()
{
    Node *currentNode = m_pList->next;
    while(currentNode != NULL)
    {
     Node *temp = currentNode->next;
     delete currentNode;
     currentNode = temp;
    }
    m_pList->next = NULL;
}

m_pList并没有被删除，其数据仍然为零（ m_pList->data = 0 ），只是将其的next指针置为NULL（ m_pList->next = NULL ）。

另外，此处 while(currentNode != NULL) 只是判断节点是否为空，并不是判断节点的对象指针。

原因是：

m_pList 是一个Node类型的对象指针，则其包含两个数据成员，一个是（i nt data ），另外一个是（ Node *next ）。

其数据成员*next同时也是一个Node类型的对象，可以指向下一个节点（通过 Node *currentNode = m_pList->next  来将其下一个节点赋值给 currentNode ）。

m_pList 只作为头结点，其数据成员（ m_pList->data ）不放元素，没有任何意义；其对象指针成员( m_pList->next ) 只放链表第一个结点的地址。

m_pList 虽然是一个头结点，但不算在链表中，此时 m_iLength = 0。【由3-3 链表编码实战（一）3:55处可知】

前驱：指定元素的前一个元素

后继：指定元素的后一个元素

线性表：

1 顺序表（数组）：访问速度快、搜索能力强

2 链表：静态链表、单链表、循环链表、双向链表

线性表：n个数据元素的 有限 序列

/**
 * 单链表
 */
public class LinkedList {
    private Node first;//头结点
    private int length;//链表长度

    public LinkedList() {
        first = new Node(-1, null);
        length = 0;
    }

    private static class Node {
        int data; //数据域
        Node next; //指针域

        Node(int data, Node next) {
            this.data = data;
            this.next = next;
        }

        void showNode() {
            System.out.println(this.data + "");
        }
    }

    public boolean isEmpty() {
        return length == 0;
    }

    public int getLength() {
        return length;
    }


    //清空链表
    public void clearList() {
        Node next = first.next;
        while (next != null) {
            Node temp = next.next;
            next.next = null;
            next = temp;
        }
        first.next = null;
        length = 0;
    }

    //在头结点后边插入
    public void insertHead(int elem) {
        Node next = first.next;
        first.next = new Node(elem, next);
        length++;
    }

    //在尾结点后插入
    public void insertTail(int elem) {
        //寻找尾节点
        Node curNode = first;
        while (curNode.next != null) {
            curNode = curNode.next;
        }
        curNode.next = new Node(elem, null);
        length++;
    }

    /**
     * 在index位置插入
     *
     * @param index
     * @param elem
     */
    public void insert(int index, int elem) {
        if (index < 0 || index > length) {
            throw new IndexOutOfBoundsException("index 不是链表的正确位置");
        }

        Node curNode = first;
        //找到插入位置index的前一个位置
        for (int i = 0; i < index; i++) {
            curNode = curNode.next;
        }
        Node temp = curNode.next;
        curNode.next = new Node(elem, temp);
        length++;
    }


    /**
     * 删除index位置的元素
     *
     * @param index
     * @return
     */
    public int delete(int index) {
        if (index < 0 || index >= length) {
            throw new IndexOutOfBoundsException("index 不是链表的正确位置");
        }

        Node curNode = first;
        //找到删除位置index的前一个位置的结点
        for (int i = 0; i < index; i++) {
            curNode = curNode.next;
        }
        Node rmNode = curNode.next;
        curNode.next = rmNode.next;
        rmNode.next = null;
        length--;
        return rmNode.data;
    }


    public int getElem(int index) {
        if (index < 0 || index >= length) {
            throw new IndexOutOfBoundsException("index 不是链表的正确位置");
        }

        Node curNode = first;
        //find
        for (int i = 0; i <= index; i++) {
            curNode = curNode.next;
        }
        return curNode.data;
    }

    public int locateElem(int elem) {
        Node curNode = first;
        for (int i = 0; i < length; i++) {
            if (curNode.next.data == elem){
                return i;
            }
            curNode = curNode.next;
        }
        return -1;
    }

    //寻找一个元素的前驱
    public int getPriorElem(int elem){
        Node curNode = first;
        Node tempNode;
        while (curNode.next != null){
            tempNode = curNode;
            curNode = curNode.next;
            if (tempNode != first && curNode.data == elem){
                return tempNode.data;
            }
        }
        return -1;
    }

    //寻找一个元素的后继
    public int getNextElem(int elem){
        Node curNode = first;
        while (curNode.next != null){
            curNode = curNode.next;
            if (curNode.data == elem && curNode.next != null){
                return curNode.next.data;
            }
        }
        return -1;
    }


    public void listTraverse() {
        Node node = first;
        for (int i = 0; i < length; i++) {
            node.next.showNode();
            node = node.next;
        }
    }

}

单链表的构成