P51、面试题5：从尾到头打印链表

题目：输入一个链表的头结点，从尾到头反过来打印出每个结点的值。

链表结点定义如下：

Struct ListNode{

int   m_nKey;

ListNode*   m_pNext;

};

　　

我们可以用栈来实现“后进先出”的顺序。每经过一个结点的时候，把该结点防到一个栈中。当遍历完整个链表后，再从栈顶开始逐个输出结点的值，此时输出的结点的顺序已经反转过来了。

void PrintListReversingly_Iteratively(ListNode* pHead){
　　std::stack<ListNode*> node;
　　ListNode* pNode = pHead;
　　while(pNode != null){
　　　　nodes.push(pNode);
　　　　pNode = pNode->m_pNext;
}
　　while(!nodes.empty()){
　　　　pNode = nodes.top();
　　　　printf("%d\t",pNode->m_nValue);
　　　　nodes.pop();
　　}
}

　　我们也可以用递归来实现反过来输出链表，我们每访问到一个结点的时候，先递归输出它后面的结点，再输出该结点自身，这样链表的输出结果就反过来了。

void PrintListReversingly_Recursively(ListNode* pHead){
　　if(pHead != null){
　　　　if(pHead->m_pNext != null){
　　　　　　　PrintListReversingly_Recursively(pHead->m_pNext);
　　　　}
　　　　printf("%d\t",pHead->m_nValue);
　　}　
}

java精简版：

Node类：

package com.yyq;

/**
 * Created by Administrator on 2015/9/8.
 */
public class Node {
    String value;
    Node next;
    public Node(String  value){
        this.value = value;
    }

    public String  getValue() {
        return value;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public void setValue(String value) {
        this.value = value;
    }
};

处理类：

package com.yyq;
import java.util.Stack;

/**
 * Created by Administrator on 2015/9/8.
 */
public class PrintLinkReversingly {
    public static void main(String[] args) {
        Node a = new Node("A");
        Node b = new Node("B");
        Node c = new Node("C");
        Node d = new Node("D");
        Node e = new Node("E");
        Node f = new Node("F");
        Node g = new Node("G");
        a.next = b;
        b.next = c;
        c.next = d;
        d.next = e;
        e.next = f;
        f.next = g;
        printTailToStartRec(a);
        printTailToStartStack(a);
    }

    public static void printTailToStartRec(Node start) {
        if (start == null ) return;
        if (start.next!= null) {
            printTailToStartRec(start.next);
        }
        System.out.println(start.value);
    }

    private static void printTailToStartStack(Node node) {
        if (node == null) {
            System.out.println("list is null");
            return;
        }

        Stack<Node> stack = new Stack<Node>();
        while (node != null) {
            stack.push(node);
            node = node.next;
        }
        while (!stack.isEmpty()) {
            System.out.println(stack.pop().value);
        }
    }
}

输出结果：

F

E

D

C

B

A

G

F

E

D

C

B

A

Process finished with exit code 0

java版本：

链表接口定义：

package com.yyq;

/**
 * Created by Administrator on 2015/9/4.
 */
public interface Link {
    //向链表增加数据
    void add(Object data);

    //可以增加一组对象
    void add(Object data[]);

    //在链表中删除数据
    void delete(Object data);

    //判断数据是否存在
    boolean exists(Object data);

    //取得全部的保存对象
    Object[] getAll();

    //根据保存的位置取出指定对象
    Object get(int index);

    //求出链表的长度
    int length();
}

链表类定义：

package com.yyq;

/**
 * Created by Administrator on 2015/9/4.
 */
public class LinkImpl implements Link {
    class Node {
        private Object data;
        private Node next;

        public Node(Object data) {
            this.data = data;
        }

        public void addNode(Node newNode) {
            if (this.next == null) {
                this.next = newNode;
            } else {
                this.next.addNode(newNode);
            }
        }

        public void deleteNode(Node previous, Object data) {
            if (this.data.equals(data)) {
                previous.next = this.next;
            } else {
                if (this.next != null) {
                    this.next.deleteNode(this, data);
                }
            }
        }

        public void getAll() {
            retdata[foot++] = this.data; //取出当前节点中的数据
            if (this.next != null) {
                this.next.getAll();
            }
        }
    };
    private int foot = 0;
    private Node root; //根节点
    private int len;
    private Object retdata[];//接收全部的返回值数据

    //向链表增加数据
    @Override
    public void add(Object data) {
        if (data != null) {
            len++; //保存个数
            Node newNode = new Node(data);
            if (this.root == null) {
                this.root = newNode;
            } else {
                this.root.addNode(newNode);
            }
        }
    }

    //可以增加一组对象
    @Override
    public void add(Object data[]) {
        for(int x = 0; x < data.length; x++){
            this.add(data[x]);
        }
    }

    //在链表中删除数据
    @Override
    public void delete(Object data) {
        if(this.exists(data)){//如果存在，则执行删除
            if(this.root.equals(data)){
                this.root = this.root.next;
            }else {
                this.root.next.deleteNode(this.root,data);
            }
        }
    }

    //判断数据是否存在
    @Override
    public boolean exists(Object data) {
        if(data == null){
            return false;
        }
        if(this.root == null){
            return false;
        }
        Object d[] = this.getAll();//取得全部的数据
        boolean flag = false;
        for(int x = 0; x < d.length; x++){
            if(data.equals(d[x])){
                flag = true;
                break;
            }
        }
        return flag;
    }

    //取得全部的保存对象
    @Override
    public Object[] getAll() {
        this.foot = 0;
        if(this.len != 0){
            this.retdata = new Object[this.len];//根据大小开辟数组
            this.root.getAll();
            return this.retdata;
        }else{
            return null;
        }
    }

    //根据保存的位置取出指定对象
    @Override
    public Object get(int index) {
       Object d[] = this.getAll();
        if(index < d.length){
            return d[index];
        }else{
            return null;
        }
    }

    //求出链表的长度
    @Override
    public int length() {
        return this.len;
    }
}

链表使用举例：

package com.yyq;

/**
 * Created by Administrator on 2015/9/4.
 */
public class PrintListReversingly {
    public static void main(String[] args) {

        Link link = new LinkImpl();
        link.add("A");
        link.add("B");
        link.add("C");
        link.add(new String[]{"X","Y"});
        Object obj[] = link.getAll();
        for(Object o : obj){
            System.out.println(o);
        }
        System.out.println(obj.length);
        System.out.println(link.exists(null));
        System.out.println(link.get(3));
        link.delete("X");
        obj = link.getAll();
        for(Object o : obj){
            System.out.println(o);
        }
        System.out.println(obj.length);  //注意这里还是原来obj开辟时的长度
    }
}

从尾到头打印链表：

package com.yyq;

import java.util.Stack;

/**
 * Created by Administrator on 2015/9/4.
 */
public class PrintListReversingly {
    public static void main(String[] args) {
        Link link = new LinkImpl();
        link.add("A");
        link.add("B");
        link.add("C");
        link.add(new String[]{"D","E","F","G"});
        Object obj[] = link.getAll();
        for(Object o : obj){
            System.out.println(o);
        }

        int len = obj.length;
        System.out.println("============");
        for(int i = len-1; i >= 0; i--){
            System.out.println(obj[i]);
        }

    }
}