算法筆試題2-Java

（1）翻轉鏈表

鏈表節點定義：
public class ListNode<T> {
    T val;
    ListNode next;
}

翻轉鏈表關鍵在於處理中間狀態。中間狀態是有一部分鏈表已翻轉（用head表示），一部分鏈表未翻轉（用next表示），將next指向的節點加入到head指向的節點，
而且head移動到next的位置，next移動到next.next的位置，此時又回到中間狀態。一直迭代直到next爲null，此時鏈表所有已翻轉，head指向的就是翻轉鏈表的頭。

public ListNode reverse(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode next = head.next;
    head.next = null;
    while (next != null) {
        ListNode tmp1 = head;
        head = next;
        ListNode tmp2 = next.next;
        next.next = tmp1;
        next = tmp2;
    }
    return head;
}

 

（2）小易有一個長度爲N的正整數數列A = {A[1], A[2], A[3]..., A[N]}。
牛博士給小易出了一個難題:
對數列A進行從新排列,使數列A知足全部的A[i] * A[i + 1](1 ≤ i ≤ N - 1)都是4的倍數。
小易如今須要判斷一個數列是否能夠重排以後知足牛博士的要求。

輸入描述:

輸入的第一行爲數列的個數t(1 ≤ t ≤ 10),
接下來每兩行描述一個數列A,第一行爲數列長度n(1 ≤ n ≤ 10^5)
第二行爲n個正整數A[i](1 ≤ A[i] ≤ 10^9)

輸出描述:

對於每一個數列輸出一行表示是否能夠知足牛博士要求,若是能夠輸出Yes,不然輸出No。

輸入例子1:

2
3
1 10 100
4
1 2 3 4

輸出例子1:

Yes
No

/**
本題關鍵是肯定全部相鄰兩數相乘能被4整除的條件，設能被4整除的數個數爲t_4，能被2整除不能被4整除的數個數爲t_2，其它數個數爲t_1，則能被4整除須要知足以下條件：
（1）t_2>0時，t_4>=t1，此時把全部t_2數排在左邊，t_4/t_1間隔排在右邊便可，t_4/t_1數不存在也不影響
（2）t_2=0時，t_4必須有，則t_4>=1，把t_4插入全部t_1數中間須要的t_4數量最少，此時t_4=t_1-1，因此t_4>=t1-1，t_4數量多無影響
*/
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        for (int i = 0; i < t; i++) {
            int count = scanner.nextInt();
            int[] arr = new int[count];
            for (int j = 0; j < count; j++) {
                arr[j] = scanner.nextInt();
            }
            int t_4 = 0, t_2 = 0, t_1 = 0;
            for(int num: arr) {
                int n = num;
                if (n % 4 == 0) {
                    t_4++;
                }
                else if (n % 2 == 0) {
                    t_2++;
                }
                else {
                    t_1++;
                }
            }
            boolean can = false;
            if (t_2 > 0) {
                can = t_4 >= t_1;
            }
            else {
                can = t_4 > 0 && (t_4 >= t_1 - 1);
            }
            System.out.println(can ? "Yes" : "No");
        }
    }
}

（3）歸併兩個排好序的鏈表

 

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Main {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if (list1 == null) {
            return list2;
        }
        if (list2 == null) {
            return list1;
        }
        ListNode head = null, iter = null;
　　　　 // 肯定頭元素
        if (list1.val < list2.val) { 
            head = iter = list1;
            list1 = list1.next;
        } else {
            head = iter = list2;
            list2 = list2.next;
        }
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                iter = iter.next = list1;
                list1 = list1.next;
            } else {
                iter = iter.next = list2;
                list2 = list2.next;
            }
        }
        while (list1 != null) {
            iter = iter.next = list1;
            list1 = list1.next;
        }
        while (list2 != null) {
            iter = iter.next = list2;
            list2 = list2.next;
        }
        return head;
    }
}