发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2013/11/28/2013-11-28-CODE 146 Max Points on a Line/

访问原文「CODE 146. Max Points on a Line」

Given n points
on a 2D plane, find the maximum number of points that lie on the same straight line.

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
public int maxPoints(Point[] points) {
	// IMPORTANT: Please reset any member data you declared, as
	// the same Solution instance will be reused for each test case.
	Map<Float, Integer> kmap = new HashMap<Float, Integer>();
	int size = points.length;
	int total = 0;
	int sum_cloumn = 0;
	if (size <= 2) {
		return size;
	}
	for (int i = 0; i < size; i++) {
		sum_cloumn = 0;
		int add = 1;
		kmap.clear();
		for (int j = 0; j < size; j++) {
			if (j == i) {
				continue;
			}
			if (points[i].x == points[j].x && points[i].y == points[j].y) {
				add++;
				continue;
			}
			float k = 0;
			if (points[i].x != points[j].x) {
				k = (float) (points[j].y - points[i].y)
						/ (points[j].x - points[i].x);
				if (kmap.containsKey(k)) {
					kmap.put(k, kmap.get(k) + 1);
				} else {
					kmap.put(k, 1);
				}
			} else {
				sum_cloumn++;
			}
		}
		for (Float f : kmap.keySet()) {
			if (kmap.get(f) > sum_cloumn) {
				sum_cloumn = kmap.get(f);
			}
		}
		sum_cloumn += add;
		if (sum_cloumn > total) {
			total = sum_cloumn;
		}
	}
	return total;
}

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2013/11/27/2013-11-27-CODE 144 Insertion Sort List/

访问原文「CODE 144. Insertion Sort List」

###
Sort a linked list using insertion sort.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public ListNode insertionSortList(ListNode head) {
	// IMPORTANT: Please reset any member data you declared, as
	// the same Solution instance will be reused for each test case.
	ListNode node = new ListNode(0);
	ListNode tmp = head;
	while (null != tmp) {
		ListNode next = tmp.next;
		if (node.next == null) {
			tmp.next = node.next;
			node.next = tmp;
		} else {
			ListNode tmpNode = node;
			while (null != tmpNode.next && tmpNode.next.val <= tmp.val) {
				tmpNode = tmpNode.next;
			}
			tmp.next = tmpNode.next;
			tmpNode.next = tmp;
		}
		tmp = next;
	}
	return node.next;
}

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2013/11/26/2013-11-26-CODE 145 Sort List/

访问原文「CODE 145. Sort List」

Sort a linked list in O(n log n)
time using constant space complexity.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public ListNode sortList(ListNode head) {
	// IMPORTANT: Please reset any member data you declared, as
	// the same Solution instance will be reused for each test case.
	ArrayList<Integer> its = new ArrayList<Integer>();
	ListNode tmp = head;
	while (null != tmp) {
		its.add(tmp.val);
		tmp = tmp.next;
	}
	int[] is = new int[its.size()];
	for (int i = 0; i < its.size(); i++) {
		is[i] = its.get(i);
	}
	Arrays.sort(is);
	tmp = head;
	for (int i = 0; i < its.size(); i++) {
		tmp.val = is[i];
		tmp = tmp.next;
	}
	return head;
}

发表于   |   分类于   |   ❤

点击打开链接

最近新做了一个模板的LOGO，为了让其更具美观和平滑型因此需要把图片角部修改为圆角，PS新手不防学习一下。

1.打开PhotoShop,并找开要处理的图片;

2.使用工具栏中的”矩形”工具,并对其如下设置:
photoshop

在写有”注意”字样的地方,这个按钮表示用此工具建立路径,

路径的作用也就是为了我们 [ 3.转换成选区(快捷键:Ctrl+Enter) ] ;

4.快捷键:ctrl+shift+I 作用是:反相选取区域,如图:
photoshop

5.这时按键盘上的”DEL”键,将图片周边的删去;

6.Ctrl+D取消选区;

7.保存时可保存成:.GIF或.PNG这两种格式都可保存成透明的

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2013/11/26/2013-11-26-CODE 143LRU Cache/

访问原文「CODE 143. LRU Cache」

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.
get(key) - Get the value (will always be positive) of the key if the
key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already
present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
public class LRUCache {
    
    private int capacity;
    private Map<Integer, Entry> nodes;
    private int currentSize;
    private Entry first;
    private Entry last;
    
    public LRUCache(int capacity) {
        this.capacity = capacity;
        currentSize = 0;
        nodes = new HashMap<Integer, Entry>();
    }
    
    public int get(int key) {
        Entry node = nodes.get(key);
        if(node != null){
            moveToHead(node);
            return node.value;
        } else {
            return -1;
        }
    }
    
    public void set(int key, int value) {
        Entry node = nodes.get(key);
        if(node == null){
            if(currentSize >= capacity){
                nodes.remove(last.key);
                removeLast();
            } else {
                currentSize ++;
            }
            node = new Entry();
        }
        
        if(currentSize == 1){
            first = node;
            last = node;
        }
        
        node.key = key;
        node.value = value;
        moveToHead(node);
        nodes.put(key, node);
    }
    
    private void moveToHead(Entry node){
        if(node == first)
            return;
        
        // delete current node from doubly linked list
        if(node.pre != null){
            node.pre.next = node.next;
        }
        if(node.next != null){
            node.next.pre = node.pre;
        }
        
        if(last == node){
            last = node.pre;
        }
        
        if(first != null){
            node.next = first;
            first.pre = node;
        }
        first = node;
        node.pre = null;
        
    }
    
    private void removeLast(){
        if(last != null){
            if(last.pre != null){
                last.pre.next = null;
            } else {
                first = null;
            }
            last = last.pre;
        }
    }
}
class Entry{
    Entry pre;
    Entry next;
    int key;
    int value;
}

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2013/11/25/2013-11-25-CODE 142 Binary Tree Postorder Traversal/

访问原文「CODE 142. Binary Tree Postorder Traversal」

Given a binary tree, return the postorder traversal of its nodes’ values.
For example:
Given binary tree {1,#,2,3},

1
 \
  2
 /
3

return [3,2,1].

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
public ArrayList<Integer> postorderTraversal(TreeNode root) {
	// IMPORTANT: Please reset any member data you declared, as
	// the same Solution instance will be reused for each test case.
	if (null == root) {
		return new ArrayList<Integer>();
	}
	ArrayList<Integer> result = new ArrayList<Integer>();
	Stack<TreeNode> stack = new Stack<TreeNode>();
	while (!stack.isEmpty() || null != root) {
		if (null != root) {
			stack.push(root);
			root = root.left;
		} else {
			root = stack.peek();
			if (null != root.right) {
				TreeNode right = root.right;
				stack.peek().left = null;
				stack.peek().right = null;
				stack.push(right);
				root = right.left;
			} else {
				stack.pop();
				result.add(root.val);
				root = null;
			}
		}
	}
	return result;
}

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2013/11/25/2013-11-25-CODE 141 Binary Tree Preorder Traversal/

访问原文「CODE 141. Binary Tree Preorder Traversal」

Given a binary tree, return the preorder traversal of its nodes’ values.
For example:
Given binary tree {1,#,2,3},

1
 \
  2
 /
3

return [1,2,3].
Note: Recursive solution is trivial, could you do it iteratively?

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
public ArrayList<Integer> preorderTraversal(TreeNode root) {
	// IMPORTANT: Please reset any member data you declared, as
	// the same Solution instance will be reused for each test case.
	if (null == root) {
		return new ArrayList<Integer>();
	}
	ArrayList<Integer> result = new ArrayList<Integer>();
	Stack<TreeNode> stack = new Stack<TreeNode>();
	while (!stack.isEmpty() || null != root) {
		if (null != root) {
			result.add(root.val);
			if (null != root.right) {
				stack.push(root);
			}
			root = root.left;
		} else {
			TreeNode node = stack.pop().right;
			result.add(node.val);
			if (null != node.right) {
				stack.push(node);
			}
			root = node.left;
		}
	}
	return result;
}

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2013/11/25/2013-11-25-CODE 140 Reorder List/

访问原文「CODE 140. Reorder List」

Given a singly linked list L: L0→L1→…→Ln-1→Ln,
reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…
You must do this in-place without altering the nodes’ values.
For example,
Given {1,2,3,4}, reorder it to {1,4,2,3}.

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
public void reorderList(ListNode head) {
	// IMPORTANT: Please reset any member data you declared, as
	// the same Solution instance will be reused for each test case.
	if (null == head) {
		return;
	}
	ListNode tmpHead = head;
	int size = 0;
	while (tmpHead != null) {
		size++;
		tmpHead = tmpHead.next;
	}
	Queue<ListNode> q = new LinkedList<ListNode>();
	Stack<ListNode> s = new Stack<ListNode>();
	tmpHead = head;
	for (int i = 0; i < (size + 1) / 2; i++) {
		q.offer(tmpHead);
		tmpHead = tmpHead.next;
	}
	while (tmpHead != null) {
		s.push(tmpHead);
		tmpHead = tmpHead.next;
	}
	ListNode newNode = new ListNode(0);
	ListNode newTmpNode = newNode;
	while (!q.isEmpty() && !s.isEmpty()) {
		newTmpNode.next = q.poll();
		newTmpNode = newTmpNode.next;
		newTmpNode.next = s.pop();
		newTmpNode = newTmpNode.next;
	}
	if (!q.isEmpty()) {
		newTmpNode.next = q.poll();
		newTmpNode = newTmpNode.next;
	}
	newTmpNode.next = null;
	head = newNode.next;
}

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2013/11/24/2013-11-24-CODE 139 Linked List Cycle II/

访问原文「CODE 139. Linked List Cycle II」

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.
Follow up:
Can you solve it without using extra space?
点击打开链接

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
public ListNode detectCycle(ListNode head) {
	// IMPORTANT: Please reset any member data you declared, as
	// the same Solution instance will be reused for each test case.
	// Empty linked list
	if (head == null)
		return null;
	ListNode fast = head;
	ListNode slow = head;
	// Find meeting point
	while (fast != null && fast.next != null) {
		slow = slow.next;
		fast = fast.next.next;
		if (fast == slow)
			break;
	}
	// Error - there is no meeting point, and therefore no loop
	if (fast == null || fast.next == null)
		return null;
	/*
	 * Move slow to Head. Keep fast at meeting Point. Each are k steps from
	 * the loop Start. If they move at the same pace, they must meet at Loop
	 * Start.
	 */
	slow = head;
	while (slow != fast) {
		slow = slow.next;
		fast = fast.next;
	}
	// Now fast points to the start of the loop.
	return fast;
}

发表于   |   分类于 ，   |   ❤

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2013/11/24/2013-11-24-CODE 138 Linked List Cycle/

访问原文「CODE 138. Linked List Cycle」

Given a linked list, determine if it has a cycle in it.
Follow up:
Can you solve it without using extra space?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public boolean hasCycle(ListNode head) {
     // IMPORTANT: Please reset any member data you declared, as
     // the same Solution instance will be reused for each test case.
     if(null == head){
         return false;
     }
 	ListNode first = head;
 	ListNode second = head;
 	while(first.next != null && first.next.next !=null){
 		if(first.next.equals(second) || first.next.next.equals(second)){
 			return true;
 		}
 		first = first.next.next;
 		second = second.next;
 	}
 	if(first.next != null && first.next.equals(second)){
 		return true;
 	}
 	return false;
 }