剑指offer 笔记-＞拓展 (持续更新)

二维数组中的查找

vector< vector< int> >Q;

  这里int>和>之间一定要有空格；

对于vertor替换成二维数组的使用

  我们知道二维数组有行和列，即a[ h ][ L ];
  在vector里，a[ h ] 相当于 Q[ Q.size()-1 ];
  a[ h ][ L ]相当于 Q[ Q.size()-1 ][ Q[ Q.size()-1 ].size() -1 ]

替换空格

string 用法

string s
   求长度： s.length()
   匹配是否相等 （注意匹配的是字符）：s[ i ]==’ ’
  在string后面加字符串： s.append(" ") or s.append(temp) //string temp
  在string后面加字符：s+=str //char str

从尾到头打印链表

逆转链表

有两种方法：

初定义：

typedef struct node {
	int data;
	struct node* next;
}Node, * LinkList;//Node 是对这一结构体的重命名 
				  // *LinkList是指向这一类型结构体的指针

int main()
{
	LinkList L; //创立一个指针
	L = new Node; //创建头指针
	L->next = NULL; //创建完成
	Node* p; //创建另一个指针 即相当于 Link List p
	p = L; //使指针指向头指针这个位置
	Node* pop = L;
	//开始进行插入数值
	for (int i = 1; i <= 7; i++)
	{
		LinkList temp; //创立子元素
		temp = new Node; //赋予空间
		temp->data = i;
		temp->next = p->next; //尾插法
		p->next = temp;
	}

	//输出
	Node* ip;
	cout << "转置之前：";
	for (ip = L->next; ip; ip = ip->next)
		cout << ip->data << (p->next ? ' ' : '\n');
}

1. 在原有的链上改变链的反向

LinkList Lpre, Lnow, phead;
	Lpre = NULL;
	Lnow = L;
	while (Lnow)
	{
		LinkList Lnext = Lnow->next;
		if (Lnext == NULL)
			phead = Lnow;
		Lnow->next = Lpre;
		Lpre = Lnow;
		Lnow = Lnext;
	}
	cout << "转置之后：";
	for (ip = phead; ip->next; ip = ip->next)
		cout << ip->data << (ip->next ? ' ' : '\n');

2. 重新建立新链，使新链为逆转后的链

//② 重新建立新链，使新链为逆转后的链

	LinkList A, y;
	Node* lo;
	A = new Node;
	A->next = NULL;
	lo = A;
	y = pop->next;
	while (y)
	{
		LinkList pr = y->next;
		y->next = A;
		A = y;
		y = pr;
	}
	cout << "转置之后：";
	for (ip = A; ip->next; ip = ip->next)
		cout << ip->data << (ip->next ? ' ' : '\n');

vector添加

vector类型的数组添加不能使用数组那样的形式；
应该 Q.push_back( data )

重建二叉树

已知前序和中序，让我们重新构造二叉树，这里就有一个小问题了，什么是重构的二叉树？
于是翻了一下资料：

二叉树的重构是指通过二叉树的遍历结果得到二叉树的构造。

这是二叉树中的经典问题
单独写吧

传送门！

用两个栈实现队列

区分一下：
栈相当于一个容器，先进后出；而队列相当于一根管道，先进先出。
用两个栈实现队列push和pop功能，即

class Solution
{
public:
    void push(int node) {
        while(!stack2.empty())
        {
            stack1.push(stack2.top());
            stack2.pop();
        }
        stack1.push(node);
    }

    int pop() {
        while(!stack1.empty())
        {
            stack2.push(stack1.top());
            stack1.pop();
        }
        int temp=stack2.top();
        stack2.pop();
        return temp;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

旋转数组的最小数字

由题可知，是在一串递增或相同的数组中，进行旋转过后来就的最小数字，这里不能用单纯遍历，不然会TLE，所以需要寻找更快的方法，这里选用的是我们常见的二分法。

假设数组为 A=[ 8 9 1 4 5 7 ]
根据二分法，left=0，right=6-1；
如果 A[ left ] > A[ right ]
那么left=mid+1;
这里不难看出当A[ left ] < A[ right ] 时，left标位指向的就是最小的数字。
如果 B=[ 7 9 1 4 5 7 ]
这个时候，我们需要把right像前移，再来比较，
即right–
那为什么不能这里也是left++呢？
看这个例子 C=[ 7 9 11 12 19 7 ]
这样就