面试常见算法题2--字符串替换和链表反转

1.请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字 符串为We%20Are%20Happy

替换后的字符串整体变长了,所以要进行字符串的移动,空格替换成%20,是一换三.可以先统计原来字符串中空格的个数(n),然后可以计算出新字符串的长度.new = old + 2*n;
我们可以定义一个new和一个old各自指向新老字符串的结尾,然后让old向new移动 如果是空格放入依次放入02%,如果不是空格 往后平移即可.

public class Solution {
    public String replaceSpace(StringBuffer str) {
    	int count = 0;
        for(int i =0;i<str.length();i++) {
            if(str.charAt(i)==' ') {
                count ++;
            }
        }
            int new_length = str.length() + 2*count;
            int new_end = new_length -1;//设置新字符串的最后一个下标
            int old_end = str.length()-1;//设置旧字符串的最后一个下标
            str.setLength(new_length);//设置新字符串大小防止数组越界
            while(old_end>=0 && new_end>=0) {
                if(str.charAt(old_end)==' ') {
                    str.setCharAt(new_end,'0');
                    new_end--;
                    str.setCharAt(new_end,'2');
                    new_end--;
                    str.setCharAt(new_end,'%');
                    new_end--;
                    old_end--;
                }else {
                    str.setCharAt(new_end,str.charAt(old_end));
                    new_end--;
                    old_end--;
                }
            }
          return str.toString();
        }  
        
    }

2.输入一个链表，按链表从尾到头的顺序返回一个ArrayList

(1)可以利用栈先进后出的特点来保存遍历结果,再new一个ArrayList保存弹栈的元素即可

import java.util.*;
public class Solution {
    //利用栈先进后出的特点
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> st = new Stack<>();
        while(listNode!=null) {
            st.push(listNode.val);
            listNode = listNode.next;//遍历数组放入栈中
        }
        ArrayList<Integer> list = new ArrayList<>();
        while(!st.empty()) {
            list.add(st.pop());//弹栈 再new一个数组保存弹出元素
        }
        return list;
    }
}

(2)数组逆置 new一个新的数组存放链表遍历结果,定义一个头索引和一个尾索引,让两个元素进行交换,并且一个向前走一个向后退,直到相遇遍历结束.元素也反转完毕.

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        while(listNode!=null) {
            list.add(listNode.val); 
                listNode=listNode.next;
            }
            int i =0;
            int j= list.size()-1;
            while(i<j) {
                int tmp =list.get(i);
                list.set(i,list.get(j));
                list.set(j,tmp);
                i++;
                j--;
            }
            return list;
        }
    }

(3)递归 递归遍历会使顺序反转

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        printListFromTailToHeadCore (listNode,list);//调用递归函数
        return list;
       }
    public void  printListFromTailToHeadCore(ListNode listNode,ArrayList<Integer> list) {
        if(listNode==null) {
            return;
        }//递归出口
        printListFromTailToHeadCore(listNode.next,list);
        list.add(listNode.val);//如果不为空就一直加入
        
    }
}