数据结构：Day01 数据结构

剑指offer Day01

记录算法刷写的思考及理念：替换空格，反向打印链表，用两个栈实现队列

1.1 剑指 Offer 05. 替换空格

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

思考：
本质上是对字符串中的指定字符进行替换,其实开发中我们直接调用String中的自身replaceAll方法就可，但是这是算法，所以要进行将数据进行用手动实现replaceAll方法

//直接调用string中的replaceAll方法
	public String replaceSpace(String s) {
      return s.replaceAll(" ","%20");
    }

//手动实现
public String replaceSpace(String s) {
   char[] arr=s.toCharArray();
   StringBuilder builder=new StringBuilder();
   for(int i=0;i<arr.length;i++){
       if(arr[i]==' '){
          builder.append("%20");
       }else{
          builder.append(arr[i]);
       }
     }
  return new String(builder);
}

1.2 剑指 Offer 06. 从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

思考：
本质上就是链表的反转，定义好的链表，将链表中的每个数据进行拿取出来，在这里要明确认知链表的结构，可以借助栈【先入后出】的特点，将数据反向，亦可以遍历，暴力破解本题。

//借助栈的特点，直接将链表进行反向
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<Integer> stack=new Stack<>();
        while(head!=null){
            stack.push(head.val);
            head=head.next;
        }
        int[] arr=new int[stack.size()];
        for(int i=0;i<arr.length;i++){
            arr[i]=stack.pop();
        }
        return arr;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        ListNode tmp = head;
       int len=0;
        while(tmp!=null){
            len++;
            tmp=tmp.next;
        }
        int[] arr=new int[len];
        int index=len-1;
        while(head!=null){
            arr[index--]=head.val;
            head=head.next;
        }
        return arr;
    }
}

性能更差的暴力破解

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        List<Integer> list=new ArrayList();
        while(head!=null){
            list.add(head.val);
            head=head.next;
        }
        int[] arr=new int[list.size()];
        int len=arr.length;
        for(int i=0;i<arr.length;i++){
            arr[i]=list.get(len-i-1);
        }
        return arr;
    }
}

1.3 剑指 Offer 09. 用两个栈实现队列

用两个栈实现一个队列。队列的声明如下：
请实现它的两个函数 appendTail 和 deleteHead ，
分别完成在队列尾部插入整数和在队列头部删除整数的功能。
(若队列中没有元素，deleteHead 操作返回 -1 )

思路：
对于栈而言，是先入后出的特点，而队列，是先入先出，在这里就要考虑二者的区别，此时需要先去了解二者的区别，此时需要审题，需要用两个先入后出的栈来实现一个队列，此时根据题目意思，
①尾部插入整数最为简单，直接创建一个栈1【后面都以栈1作为基底】，然后在直接调用添加方法即可
②对于删除队列头部，可以去人为判断，当栈2不为空时，认为此时的栈2是倒序好的栈1，直接调用删除数据方法删除即可，
②判断栈1是否为空，若为空，则证明此时的栈1和栈2都为空，就返回-1
③直接进行循环遍历栈1，将栈1中的数据写入栈2，这样就将栈1的数据进行倒序，此时直接调用删除方法即可

class CQueue {

    Stack<Integer> stack1;
    Stack<Integer> stack2;
    public CQueue() {
        stack1=new Stack<>();
        stack2=new Stack<>();
    }
    
    public void appendTail(int value) {
        stack1.push(value);
    }
    
    public int deleteHead() {
        if(stack2.size()!=0){
           return stack2.pop();
        }
        if(stack1.size()==0){
            return -1;
        }
        while(stack1.size()!=0){
            stack2.push(stack1.pop());
        }
        return stack2.pop();
    }
}

另一种性能更高的两栈实现

class CQueue {
    Stack<Integer> A;
    Stack<Integer> B;

    public CQueue() {
        A = new Stack<Integer>();
        B = new Stack<Integer>();
    }
    
    public void appendTail(int value) {
        A.push(value);
    }
    
    public int deleteHead() {
        while(!A.empty()){
            B.push(A.pop());
        }
        int result = B.empty() ? -1 : B.pop();
        while(!B.empty()){
            A.push(B.pop());
        }
        return result;
    }
}

用一个栈来实现：

class CQueue {

    Stack<Integer> stack1;
    Stack<Integer> stack2;
    public CQueue() {
        stack1=new Stack<>();
        stack2=new Stack<>();
    }
    
    public void appendTail(int value) {
        stack1.push(value);
    }
    
    public int deleteHead() {
        if(stack2.size()!=0){
           return stack2.pop();
        }
        if(stack1.size()==0){
            return -1;
        }
        while(stack1.size()!=0){
            stack2.push(stack1.pop());
        }
        return stack2.pop();
    }
}