算法3-offer5替换空格-offer6从头到尾打印链表-

offer3 替换空格

StringBuilder、创建String通过字符数组、toCharArray()方法

需求
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

思路

方式1：遍历字符串 StringBuilder拼接字符串 判断空格

StringBuilder sb = new StringBuilder();
for(int i = 0 ; i < s.length();i++){
	s.charAt(i) == ' ' // 判断空格
	sb.append("%20");
	sb.append(s.charAt(i)); 
}
sb.toString(); // StringBuilder对象转换成 String对象

时间复杂度：O（N），遍历O（N）、每轮修改O（1），总的来说是O（N）；
空间复杂度：O（N），因为新建了StringBuilder对象；

方式2：遍历字符串 将空格替换后放入字符数组中 通过字符数组创建字符串对象

// s.length *3 是因为一个空格 要被替换成 三个字符 %20
char[] array = new char[s.length * 3];
// 设置size 表示存储在array中元素的个数 或者 索引
for(int i = 0; i <s.length;i++）{
	if(s.charAt(i) == ' '){
		array[size++] = '%';
}
// 通过字符数组创建字符串
String str = new String(array,0,size);
* 注意：这里的第三个参数长度 不能写array.length，因为array.length的值是固定的，就是s.length * 3

时间复杂度：O（N），遍历O（N）、每轮修改O（3），总的来说是O（N）；
空间复杂度：O（N），由于创建了一个长度是字符串三倍的字节数组，O（3N）；

方式3：使用String的replace方法

replace介绍

方法名	说明
String replace(char oldchar,char newchar)	返回从替换所有出现的字符串oldChar为newChar
String replace(CharSequence target,CharSequence replacement)	将与target匹配的字符串的每个字符串替换为指定replacement字符串

方式4：string转化为字符数组 遍历字符数组 与空格比较 StringBuilder拼接

for(char ch : s.toCharArray()){ }

* 介绍
char[] toCharArray() 将此字符串转换为新的字符数组。

方式5：采用双指针的形式 StringBuilder统计空格个数 left原始字符串末尾 right扩增后的字符串末尾

// 统计字符串中空格的个数
StringBuilder sb = new StringBuilder();
for(int i = 0 ;i <s.length() ; i++){
	if(s.charAt(i) == ' '){
		sb.append("  ");//如果字符是空格则再增加两个空格，因为题目要求将空格替换为%20
}
// 设置两个指针left right
int left = s.length-1;
s += sb.toString(); // 扩增字符串 
int right = s.length-1;
// 将字符串编程字节数组
char[] array = s.toCharArray();
// 比较字符是否是空格，是则替换 不是则不替换
while(left >= 0){
	if(array[left] == ' ' ){
		array[right--] = '0';
		array[right--] = '2';
		array[right--] = '%';
	}else{//字符不是空格
		array[right--] = array[left];
	}
	left--；
}

图示：

代码

方式1：遍历字符串 StringBuilder拼接 charAt获取字符串每一个元素

// idea_Face - offer2 - Test419
public static String replaceSpace1(String s){
        StringBuilder sb = new StringBuilder();
        for(int i = 0;i <s.length();i++){
            if (s.charAt(i) == ' '){
                sb.append("%20");
            }else{
                sb.append(s.charAt(i));
            }
        }
        return sb.toString();
    }

方式2：遍历字符串 组成字符数组 通过字符数组创建String对象

public static String replaceSpace2(String s){
        // 创建字符数组 字符数组的长度也是固定的，直接使用数组.length则长度是给定的 s.length()*3
        char[] array = new char[s.length()*3];
        int size = 0;
        // 遍历字符串
        for(int i = 0;i<s.length();i++){
            if (s.charAt(i) == ' ') {
                array[size++] = '%';
                array[size++] = '2';
                array[size++] = '0';
            }else{
                array[size++] = s.charAt(i);
            }
        }
        String str = new String(array,0,size);
        return str;
    }

方式3：使用replace方法

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

方式4：字符串转为字符数组 增强for循环 StringBuilder拼接

public static String replaceSpace4(String s){
        StringBuilder res = new StringBuilder();

        for (char c : s.toCharArray()) {
            if (c == ' ') {
                res.append("%20");
            } else {
                res.append(c);
            }
        }
        return res.toString();

    }

方式5：采用双指针 StringBuilder统计空格数 扩展字符串

public static String replaceSpace5(String s){
        // 判断字符串长度，如果为空或 长度为0 则返回s
        if(s== null|| s.length() == 0){
            return s;
        }
        // 创建StringBuilder对象用于统计字符串中的空格数 并进行字符串的扩充
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < s.length() ; i++){
            if(s.charAt(i) == ' '){
                sb.append("  ");
            }
        }
        // StringBuilder对象用于统计空格个数，如果为0，说明没有空格，直接返回字符串即可
        if(sb.length() == 0){
            return s;
        }
        // 使用双指针处理，left表示原始字符串末尾，right表示扩增字符串末尾
        int left = s.length()-1;
        s += sb.toString(); // 扩增字符串
        int right = s.length()-1;

        // 字符串转换为字符数组
        char[] array = s.toCharArray();
        while(left >= 0){
            if(array[left] == ' '){
                array[right--] = '0';
                array[right--] = '2';
                array[right--] = '%';
            }else{
                array[right--] = array[left];
            }
            left--;
        }
        return new String(array);
    }

错误注意

split方法，通过空格分割字符串

// 使用StringBuilder对象、String的split方法(问题：对于字符串中都是空格的案例执行结果不对）
    public static String replaceSpace(String s){
        StringBuilder sb = new StringBuilder();
        String[] sArray = s.split(" ");
        for(int i = 0 ; i<sArray.length ;i++){
            if(i != sArray.length - 1){
                sb.append(sArray[i]).append("%20");
            }else {
                sb.append(sArray[i]);
            }
        }
        return sb.toString();
    }

offer6 从头到尾打印链表

需求
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
案例：
输入：head = [1,3,2]
输出：[2,3,1]

思路

方式1：采用Stack的形式

// 创建Stack栈
Stack < T > stack = new Stack< T >();
// 注意不能直接使用head头结点进行操作，应该采用如下形式：
ListNode temp = head;
// 将链表元素存放到Stack中
while(temp != null){
	// 将元素压入栈
	stack.push(temp);
	temp = temp.next();
}
// 将链表中节点的内容放入数组中
int[] array = new int[stack.size()];
while(!stack.empty()){
	array[i++] = stack.pop().val;
}

方式2：

代码

方式1：使用Stack栈的形式

   public int[] reversePrint(ListNode head) {
       Stack<ListNode> s = new Stack<ListNode>();
       ListNode temp = head;
       while(temp != null){
           s.push(temp);
           temp = temp.next;
       }
       int[] array = new int[s.size()];
       int i = 0;
       while(!s.empty()){
           ListNode ln = s.pop();
           array[i++] = ln.val;
       }
       return array;
   }

扩展

java中一个基本的链表节点。

public class ListNode { // 用类来做一个节点
     int val; // 设置一个成员变量
     ListNode next; // 使用类来做指针，指向下一个
     ListNode(int x) { val = x; } 
     // 带参构造方法，由于两个参数的名字不同，所以不同使用this.参数名 表示当前对象的成员
 }

java中没有指针的概念，只有引用数据类型，所以使用一个节点来充当指针。

java中的栈stack

概述
栈继承自Vector，说明栈底层也是一个数组；
栈stack具有先进后出的特点，出栈和入栈都是在栈顶操作的；
常用方法

方法名	说明
Stack()	创建一个空栈 栈的扩容是调用了Vector类的addElement方法
E pop()	删除此栈顶的对象，并返回该对象
E push(E item)	将对象送到栈顶，并返回入栈的对象
E peek()	查看栈顶的对象，但不从栈中删除它
Boolean empty()	判断栈是否为空