有趣的两位数和单链表处理——Java解法

有趣的两位数

有数学家发现⼀些两位数很有意思，⽐如， 34 * 86 = 43 * 68 也就是说，如果把他们的十位数和个位数交换，二者乘积不变。 编程求出满足该性质的两位数组合。 提示，暴力解法非最优解。

解题思路

先给出暴力求解的答案。考虑到11X99=99X11，这种情况不属于解题集。另外，12X24=21X42和21X42=12X24这种情况看作一个解。

代码逻辑实现

import java.util.HashSet;
import java.util.Set;

public class swap {
    public static void main(String[] args) {
        fun();
    }
    public static void fun() {
        Set<String> set=new HashSet<>();
        int sum = 0;
        for (int i = 10; i <= 99; i++) {
            for (int j = i + 1; j <= 99; j++) {
                //排除两个数相等的情况，排除交换后还是自身的情况如12X21=21X12
                //排除十位和个位相等的情况，如11X22=11X22
                //排除重复的结果，如12X42=21X24和21X24=12X42
                if (i != j && Math.abs(j - i) % 9!=0 && i % 11 != 0 && j % 11 != 0 && i * j == trans(i) * trans(j)&&!set.contains(i+""+j)) {
                    sum++;
                    set.add(i+""+j);
                    set.add(trans(i)+""+trans(j));
                    System.out.println(i + "X" + j + "=" + trans(i) + "X" + trans(j));
                }
            }
        }
        System.out.println("总数为:" + sum);
    }

    public static int trans(int cur) {
        int units = cur % 10;
        int tens = cur / 10;
        return units * 10 + tens;
    }
}

/**
12X42=21X24
12X63=21X36
13X62=31X26
13X93=31X39
14X82=41X28
23X64=32X46
23X96=32X69
24X63=42X36
24X84=42X48
26X31=62X13
26X93=62X39
28X41=82X14
34X86=43X68
36X42=63X24
36X84=63X48
39X62=93X26
46X96=64X69
48X63=84X36
总数为:18
* /

单链表处理

假设线性表 L = {A1, A2, A3, A4, …, An-2, An-1, An}，采⽤带头节点的单链表保存。链接节点定义如 下：

 typedef struct node {
   int data;
   struct node * next; 
 } NODE; 

请设计⼀个算法，编程实现，重新排列 L 中的各节点，得到线性表 L’ = {A1, An, A2, An-1, A3, An2, … }。

解题思路

如果把这个问题的单链表换成数组，那问题就很简单了。考虑到单链表是单向的，因此我采用一个集合保存所有的单链表节点。然后让集合的前半部分元素和后半部分元素依次连接。

代码逻辑实现

import java.util.ArrayList;
import java.util.List;

public class SingleLinkedList {
    static class Node {
        Node next;
        int data;
        public Node(int data) {
            this.data = data;
        }
    }

    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);
        Node node7 = new Node(7);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        node6.next = node7;
        print(node1);
        arrange(node1);
        print(node1);
    }
	/**
     * 从head遍历打印出整个单链表
     * @param head 头结点
     */
    public static void print(Node head) {
        Node cur = head;
        while (cur != null) {
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }
    
	/**
     * 重新排列单链表
     * @param head 头结点
     */
    public static Node arrange(Node head) {
        List<Node> nodeList = new ArrayList<>();
        //存储所有节点
        while (head != null) {
            nodeList.add(head);
            head = head.next;
        }
        Node cur = null;
        //因为本质上类似交换数组首尾元素，因此只需要遍历1/2的数据就可以
        for (int i = 0; i < nodeList.size() / 2; i++) {
            //如果是第一个元素则当前节点为i所在节点
            //如果不是第一个元素，当前节点此时为上一次操作的最后一个元素
            //此时需要把当前节点指向i所在节点
            if (cur == null) {
                cur = nodeList.get(i);
            } else {
                cur.next = nodeList.get(i);
                cur = nodeList.get(i);
            }
            //获取列表另一半对应的结点
            Node last = nodeList.get(nodeList.size() - i - 1);
            if (last != null) {
                cur.next = last;
                //每次把last的指向设置为空
                last.next = null;
            }
            //将操作的后一半节点设置为当前节点
            cur = last;
            //如果单链表的个数为奇数，则在最后一次遍历的时候把最后一个节点指向中间节点
            if (i == nodeList.size() / 2 - 1 && nodeList.size() % 2 != 0 && cur != null) {
                Node middle = nodeList.get(nodeList.size() / 2);
                cur.next = middle;
                middle.next = null;
            }
        }
        return nodeList.get(0);
    }
}

/**
 *  原链表：1 2 3 4 5 6 7 
 *	重排后：1 7 2 6 3 5 4 
 */