Java每日一练01素数，删除倒数第n个索引，外观数组

打印1-100之间的素数

class Solution{
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            boolean b = new Test102().checkPrime(i);
            if (b) System.out.print(i + " ");
            // 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
        }
    }

    private boolean checkPrime(int x) {
        boolean isPrime = true;
        if (x == 1 || x % 2 == 0 && x != 2) {
            isPrime = false;
        } else {
            for (int i = 3; i < x; i++) {
                if (x % i == 0) {
                    isPrime = false;
                    break;
                }
            }
        }
        return isPrime;
    }
}

链表删除倒数第n个索引的元素

class Node {
    int data;
    Node next;
    public Node() {
    }

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

class Link implements CommonLink,linkUtils {
    Node head, tail;
    int size;

    public Link() {
        head = new Node();
        tail = head;
        size = 0;
    }

    /**
     * 在链表末尾添加1个节点
     * @param e
     */
    @Override
    public void add(int e) {
        // TODO Auto-generated method stub
        Node node = new Node(e);
        tail.next = node;
        tail = node;
        size++;
    }

    /**
     * 在指定位置插入节点
     * @param e
     * @param index
     */
    @Override
    public void insert(int e, int index) {//形参index表示结点所处位置的下标
        Node node1 = getNodePrePosition(index);
        Node node = getNodePosition(index);
        //创建一个新节点，为要插入的节点
        Node node2 = new Node(e);
        if (index == 0) {//如果插入的位置是第一个节点
            head.next = null;
            head.next = node2;
        } else {
            node1.next = null;
            node1.next = node2;
        }
        node2.next = node;
        size++;

    }

    /**
     * 获取指定位置的元素
     * @param index
     * @return
     */
    private Node getNodePosition(int index) {
        checkindex(index);
        Node node = head.next;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    /**
     * 获取指定位置之前的元素
     * @param index
     * @return
     */
    private Node getNodePrePosition(int index) {
        checkindex(index);
        //找到下标index-1
        Node node1 = head.next;
        for (int i = 0; i < index - 1; i++) {
            node1 = node1.next;
        }
        return node1;
    }

    /**
     * 删除指定位置的节点
     * @param index
     */
    @Override
    public void delete(int index) {
        Node node1 = getNodePrePosition(index);
        Node node = getNodePosition(index);
        if (index != 0) {
            if (index == size - 1) {
                node1.next = null;
            } else {
                node1.next = null;
                node1.next = node.next;
            }
            //设置node的指针为空，node的值为空
            node.next = null;
            node.data = 0;
        } else {//假设index等于0
            head.next = null;
            head.next = node.next;
            node.next = null;
            node.data = 0;
        }
        size--;
    }

    /**
     * 获取指定位置节点的值
     * @param index
     * @return
     */
    @Override
    public int get(int index) {
        // TODO Auto-generated method stub
        //找到下表index
        Node node = head.next;
        //从头节点开始，依次向后查找
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node.data;
    }

    /**
     * 修改指定位置节点的值
     * @param e 新值
     * @param index 指定位置
     */
    @Override
    public void modify(int e, int index) {
        // TODO Auto-generated method stub
        //找到下表index
        Node node = head.next;
        //从头节点开始，依次向后查找
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        Node node1 = new Node(e);
        node.data = e;
    }

    /**
     * 获取链表长度
     * @return
     */
    @Override
    public int getSize() {
        return size;
    }

    /**
     * 检查传入的index是否合格
     * @param index
     */
    public void checkindex(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("invalid param");
        }
    }

    /**
     * 遍历链表
     * @param link 链表的引用
     */
    @Override
    public void printLink(Link link) {
        for (int i = 0; i < link.getSize(); i++) {
            //取出元素
            int e = link.get(i);
            //输出元素
            System.out.println("No " + i + " data： " + e);
        }
    }

    /**
     * 删除链表倒数第n个节点
     * @param link 链表的索引
     * @param index 指定位置
     */
    @Override
    public void deleteCountDownIndex(Link link,int index) {
        int newIndex = link.getSize() - index;
        link.delete(newIndex);
    }

    /**
     * 反转链表的方法
     * @return
     */
    @Override
    public Node reverseLink() {
        Node prev = null; 
        Node curr = head; 
        while (curr != null) {
            Node nextTemp = curr.next; 
            curr.next = prev; 
            prev = curr; 
            curr = nextTemp; 
        }
        return prev;
    }
}

interface CommonLink {
    //存储
    public void add(int e);

    //插入
    public void insert(int e, int index);

    //删除
    public void delete(int index);

    //获取元素
    public int get(int index);

    //修改
    public void modify(int e, int index);

    //获取元素个数
    public int getSize();

    //遍历链表
    public void printLink(Link link);
}

interface linkUtils {
    // 删除倒数第n个索引的节点
    public void deleteCountDownIndex(Link link,int index);
    // 反转链表
    public Node reverseLink();
}

class Test {
    public static void main(String[] args) {
        Link link = new Link();
        //添加数据
        link.add(12);
        link.add(34);
        link.add(56);
        link.add(78);
        link.add(90);
        //遍历列表
        // link.printLink(link);
        link.deleteCountDownIndex(link,4);
        link.printLink(link);
    }
}

外观数组

class Solution1 {
    /*
     * 描述前一项，这个数是 1 即 “ 一 个 1 ”，记作 "11"
     * 描述前一项，这个数是 11 即 “ 二 个 1 ” ，记作 "21"
     * 描述前一项，这个数是 21 即 “ 一 个 2 + 一 个 1 ” ，记作 "1211"
     * 描述前一项，这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ，记作 "111221"
     * 外观数组是先读在描述的数据
     * 每进行1次读取都会描述上一条数据
     * 描述的数据会呈指数型增长
     * 避免读取的次数超过30
     */

    /**
     * 整数转描述性字符串
     *
     * @param n 需要描述的整数
     * @return 描述字符串
     */
    public String countAndSay(int n) {
        if(n == 1) return "1";
        /*
         * 程序运行到此处
         * 开始进行递归
         * 直到符合递归结束的条件
         * 也就是n==1的时候
         * 开始弹栈
         *
         * 弹栈第1次返回默认值1
         * 弹栈第2次是对数字1的描述 11
         * 弹栈第3次是对数字11的描述 21
         * 弹栈第4次是对数字21的描述 1211
         * ...
         * 直到弹栈次数等于当前读取的次数
         */
        String num = countAndSay(n - 1);
        StringBuilder s = new StringBuilder();
        for(int i=0; i<num.length(); i++) {
            int count = 1;
            while(i < num.length()-1 && num.charAt(i) == num.charAt(i+1)) {
                count++;
                i++;
            }
            s.append(count);
            s.append(num.charAt(i));
        }
        return s.toString();
    }
}

class Test2 {
    public static void main(String[] args) {
        String s = new Solution1().countAndSay(4);
        /*
         * 假如读4
         * 那么就是对3描述的数字进行描述
         * 仔细看读取的次数对应的描述信息
         * 可以很快地看出来
         * 这是一个递归的过程
         */
        System.out.println(s);
    }
}