解题---＞在线OJ(三)

1.找出数组中重复的数字

1.找出数组中重复的数字

解题思路：
1.利用hashMap来解决；
2.遍历整个数组，如果hashMap当中不包含此数组元素，就存进hashMap当中；
3.如果hashMap当中包含此数组元素，就返回此数组元素

    public static int findRepeatNumber(int[] nums) {
        HashMap<Integer,Integer> hashMap=new HashMap<>(nums.length);
        hashMap.put(nums[0],0);
        for(int i=1;i<nums.length;i++){
            if(!hashMap.containsKey(nums[i])){
                hashMap.put(nums[i],i);
            }else{
                return nums[i];
            }
        }
        return -1;
    }

2.替换空格

2.替换空格

运用字符串中的replace
用 %20 来替换 字符串中的空格

class Solution {
  public static String replaceSpace(String s) {
        return s.replace(" ","%20");
    }
}

3.删除排序链表中的重复元素

3.删除排序链表中的重复元素

解题思路：
1.首先，进行判断，看head是否为空；
2.设置一个暂时的节点，然后去遍历整个链表
3.如果当前节点和下一个节点的值一样的话，就把当前节点的下一个节点 换成当前节点下一个节点的下一个节点，也就相当于 将当前节点的下一个节点被当前节点的下一个节点的下一个节点所覆盖；
4.如果当前节点的值和下一个节点的值不一样的话，就把当前节点往后挪，继续判断：当前节点和下一个节点的值是否一样。

class Solution {
      public ListNode deleteDuplicates(ListNode head) {
          if(head==null){
            return head;
        }
        //后续将拿着这个cur去操作，之后返回的是head
        ListNode cur=head;
        while(cur.next!=null){
            if(cur.val==cur.next.val){
              cur.next=cur.next.next;
            }else{
                cur=cur.next;
            }
        }
        return head;
    }
}

4.合并两个有序数组

4.合并两个有序数组

1.利用arraycopy来将两个数组合并为一个数组；
2.将合并后的nums1数组进行排序，利用Arrays.sort()方法来完成；

class Solution {
      public static void merge(int[] nums1, int m, int[]nums2, int n) {
        //复制nums2数组，从0下标开始复制,复制长度为n
        //粘贴到nums1数组，从m下标开始粘贴
        System.arraycopy(nums2,0,nums1,m,n);
        Arrays.sort(nums1);
        
    }
}

5.反转链表

5.反转链表

解题思路：
1.首先，判断head是否为空；
2.创建两个节点，一个指向head，一个指向null;
3.遍历整个链表；
4.先记录下now节点的下一个节点；
5.然后将now节点的next指向prev节点，这就完成了一部分的反转；
6.如此循环，等到now节点指向null时，退出循环，返回prev节点

class Solution {
     public ListNode reverseList(ListNode head) {
        if(head==null){
            return head;
        }
        ListNode now=head;
        ListNode prev=null;
        while(now!=null){
            ListNode nowNext=now.next;
            now.next=prev;
            prev=now;
            now=nowNext;
        }
        return prev;
    }
}

6.用栈实现队列

6.用栈实现队列

解题思路：
1.队列是先进先出的，栈是先进后出的
2.用栈完成队列，是需要两个栈的，队列（eg:队头1,2,3,4,5队尾）入其中一个栈，由这个栈出，入另一个栈（栈底5,4,3,2,1栈顶），然后，如果需要出栈的话，就从第二个栈出，出栈的顺序就是：1，2，3，4，5，就和队列一致了。

class MyQueue {

Stack<Integer> stack1;
    Stack<Integer> stack2;

    public MyQueue() {
        stack1=new Stack<>();
        stack2=new Stack<>();
    }

    public void push(int x) {
        stack1.add(x);
    }
    //int pop() 从队列的开头移除并返回元素
    public int pop() {
        if(stack2.isEmpty()){
            while(!stack1.isEmpty()){
                stack2.add(stack1.pop());
            }
        }
        return stack2.pop();
    }
    //int peek() 返回队列开头的元素
    public int peek() {
        if(stack2.isEmpty()) {
            while (!stack1.isEmpty()){
                stack2.add(stack1.pop());
            }
        }
        return stack2.peek();
    }
    //boolean empty() 如果队列为空，返回 true ；否则，返回 false
    public boolean empty() {
        return stack1.isEmpty() &&stack2.isEmpty();
    }
}

7.用队列实现栈

7.用队列实现栈

解题思路：
队列是先进先出，栈是先进后出
1.利用两个队列来完成栈；
2.先把元素入队列1：eg:queue1:1
3.然后再把队列1的元素和队列2的元素进行交换：eg:queue1:null;queue2:1;
4.重复第二步：将元素入队列1；eg:queue1:2
5.然后此时队列2不为空，将队列2中的元素全部出队列，然后再进入队列1；此时queue1:2,1
6.重复第三步，将队列1和队列2的元素进行交换，此时：queue1:null,queue2:2,1
就这样重复4-6步骤，就完成了用两个队列完成一个栈。

class MyStack {

      Queue<Integer> queue1;
    Queue<Integer> queue2;
    int top;
    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    public void push(int x) {
        queue1.offer(x);
        top=x;
        while (!queue2.isEmpty()){
            queue1.offer(queue2.poll());
        }
        Queue temp=queue1;
        queue1=queue2;
        queue2=temp;
    }

    public int pop() {
        return queue2.poll();
    }

    public int top() {
        return queue2.peek();
    }

    public boolean empty() {
    return queue2.isEmpty();
    }
}

8.回文链表

8.回文链表

解题思路：
1.创建一个StringBuilder,遍历整个链表，将每个节点的值都加到stringBuilder上；
2.然后，比较stringBuilder和stringBuilder反转后的字符串是否相等，如果相等，就返回true,否则，返回false.

class Solution {
    public static boolean isPalindrome(ListNode head) {
        StringBuilder stringBuilder=new StringBuilder();
        while(head!=null){
            stringBuilder.append(head.val);
            head=head.next;
        }
        if(stringBuilder.toString().equals(stringBuilder.reverse().toString())){
            return true;
        }
        return false;
    }
}