CTCI 2.7

Implement a function to check if a linked list is a palindrome.

Reverse the second half of the list and then compare it with the first half.

/* Assume that we can destroy the list, reverse the second half of the list and compare it with the first
half. If we were not permit to destroy the list, change the list to an array and then check if it is a
palidrome.
*/

public class IsPalidrome {
    public boolean isPalidrome(Node head) {
        if(head == null || head.next == null) return true;
        int cnt = 0;
        Node temp = head;
        while(temp != null) { cnt++; temp = temp.next; }
        int half = cnt / 2;
        temp = head;
        while(half > 1) { temp = temp.next; half--; }
        Node sent = new Node(0);
        //break the list into two parts
        Node temp1 = temp.next, temp2 = temp.next; temp.next = null;
        //reverse the second half
        while(temp1 != null) {
            temp2 = temp1.next;
            temp1.next = sent.next;
            sent.next = temp1;
            temp1 = temp2;
        }
        //check if it is palidrome
        Node head1 = head, head2 = sent.next;
        while(head1 != null && head2 != null) {
            if(head1.val == head2.val) {
                head1 = head1.next;
                head2 = head2.next;
            }
            else return false;
        }
        return true;
    }

    public static void main(String[] args) {
        Node node1 = new Node(1); Node node11 = new Node(1); node1.next = node11;
        Node node2 = new Node(1); Node node22 = new Node(2); node2.next = node22;
        Node node31 = new Node(1); Node node32 = new Node(2); Node node33 = new Node(1); node31.next = node32; node32.next = node33;
        Node node41 = new Node(1); Node node42 = new Node(3); Node node43 = new Node(2); Node node44 = new Node(1);
        node41.next = node42; node42.next = node43; node43.next = node44;
        IsPalidrome ip = new IsPalidrome();
        System.out.println(ip.isPalidrome(node1));
        System.out.println(ip.isPalidrome(node2));
        System.out.println(ip.isPalidrome(node31));
        System.out.println(ip.isPalidrome(node41));
    }
}

CTCI 2.7

时间: 2024-08-24 04:58:15

CTCI 2.7的相关文章

CTCI 3.4

In the classic problem of the Towers of Hanoi, you have 3 towers and Ndisks of different sizes which can slide onto any tower.The puzzle starts with disks sorted in ascending order of size from top to bottom (i.e., each disk sits on top of an even la

CTCI 2.3

Implement an algorithm to delete a node in the middle of a singly linked list, given only access to that node.EXAMPLEInput: the node c from the linked list a->b->c->d->eResult: nothing isreturned, but the new linked list looks like a- >b- &

CTCI 1.3

Description: Given two strings, write a method to decide if one is a permutation of the other. We could use the same idea from CTCI 1.1. The only difference is that in 1.1 we just need to know whether one character appear or not, in this problem we n

CTCI 2.1

Write code to remove duplicates from an unsorted linked list.FOLLOW UPHow would you solve this problem if a temporary buffer is not allowed? /* Use a HashSet to record whether a val has appeared or not. We assume that the linked list is singly linked

CTCI 2.2

Implement an algorithm to find the kth to last element of a singly linked list. Classical "Runner" Technique of linkedlist /*Use two pointers, forward one K nodes, then the two pointers form a "window" contains K nodes. Then move two p

CTCI 3.3

Imagine a (literal) stack of plates. If the stack gets too high, it might topple. Therefore, in real life, we would likely start a new stack when the previous stack exceeds some threshold. Implement a data structureSetOf Stacks that mimics this. SetO

CTCI 3.1

Describe how you could use a single array to implement three stacks. Divide the array into three fixed parts, each stands for a stack. /*Fixed Size Stacks*/ import java.util.*; public class ThreeStacks { int stackSize = 100; int[] buffer = new int[st

CTCI 1.2

Since I mainly use Java, this problem seems meaning less for me to implement it with Java. Just use StringBuilder to append each character in string from the end to the start. The time complexity is O(N) and space complexity is O(N), too. If using C+

CTCI 4.8

You have two very large binary trees: T1, with millions of nodes, and T2, with hundreds of nodes. Create an algorithm to decide if T2 is a subtree of T1. A tree T2 is a subtree of T1 if there exist a node in T1 such that the subtree of nis identical