1.3.19~1.3.30

链表综合

package luyunzhou.one;

import java.util.Scanner;
/**
 * 1.3.19~1.3.30无29
 *
 */
public class Answer1319 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
//      Node<String> node = new Node<String>();
//      for (int i = 0; i < 5; i++) {
//          node.add(scanner.nextLine());
//      }
        Node<Integer> node = new Node<Integer>();
        for (int i = 0; i < 3; i++) {
            node.add(scanner.nextInt());
        }

//==========================================================
//      node.deletelast();
//      node.print();

//==========================================================
//      node.delete(scanner.nextInt());
//      node.print();

//==========================================================
//      System.out.println(node.find(scanner.nextLine(), node));

//==========================================================
//      node.removeafter(node.first);
//      node.print();

//==========================================================
//      Node<String> node1 = new Node<String>();
//      for (int i = 0; i < 5; i++) {
//          node1.add(scanner.nextLine());
//      }
//      Node<String> node2 = new Node<String>();
//      for (int i = 0; i < 5; i++) {
//          node2.add(scanner.nextLine());
//      }
//      node.insertAfter(node1, node2);
//      node1.print();

//==========================================================
//      node.remove(node, "q");
//      node.print();

//==========================================================
//      System.out.println(node.max(node.first));
//      System.out.println(node.remax(node.first));

//==========================================================
//      System.out.println(node.reverse(node.first));
//      node.print();
    }


}
class Node<Item>{
    public Node first;
    public Item item;
    public Node next;
    public void add(Item item) {
        if(first == null){
            first = new Node();
            first.item = item;
        }else {
            Node node = first;
            while(node.next != null){
                node = node.next;
            }
            Node a = new Node();
            a.item = item;
            node.next = a;
        }

    }
    public void deletelast() {
        Node node = first;
        while(node.next.next != null){
            node = node.next;
        }
        node.next = null;
    }
    /**
     * Node<String> p = node.first;
        p = p.next;
        p = null;
        p = node.first;
        System.out.println(p.next.item);
        只是断开了自身的链接，前一个节点还是可以访问的。
     * 只是把head后面的节点断开连接，所有的节点都是存在的
     * 你没有free释放这些节点的内存，那么这些节点还是有的，数据还是存在，只是和head这个节点断开了连接，找不到后面的节点而已
     * 你没有释放head这个节点，data当然存在了，即使你head=NULL，data也会存在，只是断开了和head的关系而已
     */
    public void delete(int k) {
        System.out.println("用到了");
        if(k == 1)
            first = first.next;
        else 
        if(k > 1){
            Node node = first;
            for (int i = 0; i < k-2; i++) {
                node = node.next;
            }//k-1节点
            node.next = node.next.next;
        }
    }
    /**
     * 删除第一个节点需分开讨论。
     */

    public boolean find(String key,Node node) {
        node = first;
        while(node != null){
            if(node.item.equals(key) ){
                return true;
            }
            node = node.next;
        }
        return false;
    }
    /**
     * 字符串相等用equal()
     */

    public void removeafter(Node node) {
        if(node != null||node.next != null)
        node.next = null;
    }

    public void insertAfter(Node node1,Node node2) {
        Node node = node1.first;
        while(node.next != null){
            node = node.next;
        }
        node.next = node2.first;
    }

    public void remove(Node node,String key) {
        Node p = node.first;
        while(p.next != null){
            while(p == node.first){//头结点的值为key
                if(p.item.equals(key)){
                    p = p.next;
                    node.first = node.first.next;
                    if(p == null || p.next == null&&(!p.item.equals(key))){
                        return;
                    }
                    /**
                     * if的作用
                     * 1.最后一个p.item也为key，删完直接返回，不然自身if就要null和key比较。
                     * 2.只有最后一个节点值不为key，直接返回，防止在下面while括号内null与key比较
                     */
                }else{
                    break;
                }
            }
            while(p.next.item.equals(key)){//非头结点的值为key
                p.next = p.next.next;
                if(p.next == null){
                    return;
                }
                /**
                 * if的作用
                 * 防止若最后一个p.item也是key，则while中会p.next.item=null与key比较。
                 */
            }
            p = p.next;
        }
    }

    public int max(Node<Integer> first) {
        Node<Integer> node = first;
        if(node == null){
            return 0;
        }else{
            int m = node.item.intValue();
            while(node != null){
                if(node.item.intValue() > m){
                    m = node.item.intValue();
                }
                node = node.next;
            }
            return m;
        }
    }

    public int remax(Node<Integer> first) {//递归max
        if(first == null){
            return 0;
        }else {
            int m = first.item.intValue();
            if(first.next == null){
                return m;
            }else{
                if(remax(first.next) > m){
                    return remax(first.next);
                }else {
                    return m;
                }
            }
        }
    }

    public  Item reverse(Node first) {
        Node p = first;
        Node q = first.next;
        if(q != null){
            Node r = q.next;
            p.next = null;
            do{
                q.next = p;
                p = q;
                q = r;
                if(r != null)
                r = r.next;
            }while(q != null);
        }
        this.first = p;
        return (Item) p.item;
    }

    public void print() {
        Node node = first;
        if(node == null){
            System.out.println("该链表为空链表");
        }
        while(node != null){
            System.out.print(node.item+" ");
            node = node.next;
        }
        System.out.println();
    }
}