java简单算法总结

1
2
3
4
function reverseString(str) {
    return str.split('').reverse().join('');
}
reverseString("hello");

1
2
3
4
5
6
7
8
9
10
11
12
public static int factorialize(int num) {
    if (num <= 1) {
        return 1;
    } else {
        return num * factorialize(num-1);
    }

}

public static void main(String[] args) {
    System.out.println(factorialize(5));
}

1
2
3
4
5
6
7
8
9
10
11
public boolean palindromeNumber(int num) {
        
       int reverse = 0,temp = num;
       while(temp>0){
       //  temp%10 取余 temp/10 取整
           reverse = reverse*10+temp%10;
           temp = temp/10;
       }
       return reverse==num;
    }

1
2
s=s.replaceAll("\pP|\pS|\pZ", "")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public boolean isPalindrome(String s) {
        if (s == null) {
            return false;
        }
        s = s.replaceAll("\pP|\pS|\pZ", "").toLowerCase();
        char[] arr = s.toCharArray();
        int front = 0, end = arr.length - 1;
        while (front < end) {
            if (arr[front++] != arr[end--]) {
                return false;
            }
        }
        return true;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/**
 * 定义链表类
 **/
 class ListNode{
		int val;
		ListNode next;
		ListNode(int x){
			val = x;
		}
	}
	/**
     * @param head a ListNode
     * @return a boolean
     */
    public boolean isPalindrome(ListNode head) {
   
        if(head==null){
    		return true;
    	}
    	//找到中间节点
    	ListNode middle = findMiddle(head);
    	//对中间节点之后的节点进行反转，重新赋值给middle链表，
    	middle= reverse(middle.next);
    	//两个链表的长度不一样，但是middle的节点比较少，也就是middle会先结束循环，如果middle.next还有节点就跳出循环，说明该链表不是回文链表，反之是回文链表。
    	while(head!=null&&middle!=null&&head.val==middle.val){
    		head = head.next;
    		middle = middle.next;
    	}
    	return middle==null;
    }
     // 找到两个链表的中间节点
     //当链表长度为奇数时，slow刚好是链表中间节点。fast在最后一个节点 。当链表长度为偶数时，slow的节点刚好到中间节点的前一个节点。fast在倒数第二个节点。slow.next就是下一个链表的头结点。
     public  ListNode findMiddle(ListNode head){
    	if(head==null){
    		return null;
    	}
    	ListNode slow = head,fast = head.next;
    	while(fast!=null&&fast.next!=null){
    		slow = slow.next;
    		fast = fast.next.next;
    	}
    	return slow;
    }
    //反转链表
    public  ListNode reverse(ListNode head){
    	ListNode prev = null,temp = null;
    	while(head!=null){
    		temp = head.next;
    		head.next = prev;
    		prev = head;
    		head = temp;
    	}
    	
    	return prev;
    }