求职Leetcode题目(3)

1.Z字形转换

整体的思路是遍历字符串，遍历过程中将每行都看成新的字符串构成字符串数组，最后再将该数组拼接起来即可
如果 numRows=1 则说明当前字符串即为结果，直接返回
否则整个字符串需要经历，向下向右，向下向右，这样的反复循环过程，设定 down 变量表示是否向下，loc 变量表示当前字符串数组的下标
如果 down 为 true，则 loc+=1，字符串数组下标向后移动，将当前字符加入当前字符串中
如果 down 为 false，则表示向右，则 loc−=1，字符串数组下标向前移动，将当前字符加入当前字符串中
时间复杂度：O(n)，n为字符串s的长度 

 

class Solution {
    public String convert(String s, int numRows) {
        if(numRows == 1)
            return s;
        
        int len = Math.min(s.length(), numRows);
        String []rows = new String[len];
        for(int i = 0; i< len; i++) rows[i] = "";
        int loc = 0;
        boolean down = false;

        for(int i=0;i<s.length();i++) {
            rows[loc] += s.substring(i,i+1);
            if(loc == 0 || loc == numRows - 1)
                down = !down;
            loc += down ? 1 : -1;
        }
        
        String ans = "";
        for(String row : rows) {
            ans += row;
        }
        return ans;
    }
}

 2.字符串转换整数

         

 解题思路：

根据题意，有以下四种字符需要考虑：

• 首部空格： 删除之即可。
• 符号位： 三种情况，即 ''+'' , ''−'' , ''无符号" ；新建一个变量保存符号位，返回前判断正负即可。
• 非数字字符： 遇到首个非数字的字符时，应立即返回。
• 数字字符：
• 字符转数字： “此数字的 ASCII 码” 与 “ 0 的 ASCII 码” 相减即可。
• 数字拼接

注意数字越界处理：

代码实现：

class Solution {
    public int myAtoi(String s) {
        int res = 0, bndry = Integer.MAX_VALUE / 10;
        int i = 0, sign = 1, length = s.length();
        if(length == 0) return 0;
        while(s.charAt(i) == ' ')//使用while循环来跳过字符串开头的空白字符
            if(++i == length) return 0;
        if(s.charAt(i) == '-') sign = -1;
        if(s.charAt(i) == '-' || s.charAt(i) == '+') i++;//如果当前字符是正号或者符号，逃过这个符号
        for(int j = i; j < length; j++) {
            if(s.charAt(j) < '0' || s.charAt(j) > '9') break;
            if(res > bndry || res == bndry && s.charAt(j) > '7')
                return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
            res = res * 10 + (s.charAt(j) - '0');
        }
        return sign * res;
    }
}

3.两两交换链表中的节点

据说是今年美团二面的题目！

 解题思路：

利用stack
我们利用一个 stack，然后不断迭代链表，每次取出两个节点放入 stack 中，再从 stack 中拿出两个节点。
借助 stack 后进先出的特点，放进去的时候是 1,2 。拿出来的时候就是 2，1 两个节点了。
再把这两个节点串联起来，重复这个逻辑遍历完整个链表，就可以做到两两反转的效果了。
虽然用到了 stack，但因为只存了两个元素，所以空间复杂度还是 O(1)，时间复杂度是 O(n)。

 

 

class Solution {
	public ListNode swapPairs(ListNode head) {
		if(head==null || head.next==null) {
			return head;
		}
		//用stack保存每次迭代的两个节点
		Stack<ListNode> stack = new Stack<ListNode>();
		ListNode p = new ListNode(-1);
		ListNode cur = head;
		//head指向新的p节点，函数结束时返回head.next即可
		head = p;
		while(cur!=null && cur.next!=null) {
			//将两个节点放入stack中
			stack.add(cur);
			stack.add(cur.next);
			//当前节点往前走两步
			cur = cur.next.next;
			//从stack中弹出两个节点，然后用p节点指向新弹出的两个节点
			p.next = stack.pop();
			p = p.next;
			p.next = stack.pop();
			p = p.next;
		}
		//注意边界条件，当链表长度是奇数时，cur就不为空
		if(cur!=null) {
			p.next = cur;
		} else {
			p.next = null;
		}
		return head.next;
	}
}

 解法二：用迭代的方式

迭代实现就比 stack 方式复杂多了，需要很小心的处理节点的指向。
这里我们需要三个指针，a，b，tmp。
假设链表是
1->2->3->4->5->6
在迭代的时候，每次处理两个节点，于是第一轮 a 指向 1，b 指向 2。
第二轮的时候 a 指向 3，b 指向 4。第三轮的时候 a 指向 5，b 指向 6。
我们通过 a.next = b.next，以及b.next=a就把两个指针的位置反转了，于是1->2就变成2->1。
但这里有一个细节需要处理，当我们第二轮迭代的时候，a 指向 3，b 指向 4。按照题目要求，最终应该是2->1->4->3。
也就是节点 1 需要跟节点 4 串起来，只有两个指针就没法弄了，所以需要第三个指针 tmp，用来记录上一轮 a 的位置，然后下一轮迭代的时候，将原先的 a(也就是节点 1)指向 4

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
	public ListNode swapPairs(ListNode head) {
		//增加一个特殊节点方便处理
		ListNode p = new ListNode(-1);
		p.next = head;
		//创建a，b两个指针，这里还需要一个tmp指针
		ListNode a = p;
		ListNode b = p;
		ListNode tmp = p;
		while(b!=null && b.next!=null && b.next.next!=null) {
			//a前进一位，b前进两位
			a = a.next;
			b = b.next.next;
			//这步很关键，tmp指针用来处理边界条件的
			//假设链表是1->2->3->4，a指向1，b指向2
			//改变a和b的指向，于是就变成2->1，但是1指向谁呢？
			//1是不能指向2的next，1应该指向4，而循环迭代的时候一次处理2个节点
			//1和2的关系弄清楚了，3和4的关系也能弄清楚，但需要一个指针来处理
			//2->1，4->3的关系，tmp指针就是干这个用的
			tmp.next = b;
			a.next = b.next;
			b.next = a;
			//现在链表就变成2->1->3->4
			//tmp和b都指向1节点，等下次迭代的时候
			//a就变成3，b就变成4，然后tmp就指向b，也就是1指向4
			tmp = a;
			b = a;
		}
		return p.next;
	}
}