算法笔记4.链表，栈与队列，kmp

链表

一般链表都是结构体加指针实现（动态链表，效率慢），但是这是算法的笔记，所以为了效率考虑是用数组模拟的

单链表

在笔试题里面用的最多的是邻接表，邻接表最主要用于存储图和树

我们用两个数组来表示链表，一个存储值，一个存储指针（值数组的索引，最后一个用-1表示没有下一节点）。这两个数组的同一个下标代表链表的一个节点。

int e[N],ne[N],idx,head;
//e存储值，ne存储指针，idx存储我们现在用到了哪个点，head表示头节点的下标

//初始化
void init()
{
    head = -1; //还没有存东西，所以是-1
    idx = 0;   //还没有存东西，所以可用的点是0
}

//将x插入到头节点
void add_to_head(int x)
{
    //在未使用的空间存储值
    e[idx] = x; 
    //x节点指向原本的头节点
    ne[idx] = head;
    //更新头节点指针
    head = idx;
    //更新未使用索引
    idx++
}

//将x插入到下标是k的节点的后面
void add(int x, int k)
{
    //在未使用的空间存储值
    e[idx] = x;
    //x节点指向原本k指向的节点
    ne[idx] = ne[k];
    //让k节点指向x节点
    ne[k] = idx;
    //更新未使用索引
    idx++
}

//删掉k节点后面的节点
void remove(int k)
{
    //我们直接抛弃这一块就行了
    ne[k] =  ne[ne[k]];
}

双链表

一般是用来优化某些题.

双链表每个节点我们会有两个指针，一个指向前一个指向后。

所以我们需要三个数组，一个存值，一个存指向左边的索引，一个存指向右边的索引。

//在数组中用0来存储左端点，用1来存储右端点

int m;
int e[N],l[N],r[N],idx;

//初始化
void Init()
{
    //左指右，右指左
    r[0] = 1, l[1] = 0;
    idx = 2;
}

//在k的右边插入一个点
void add(int k, int x)
{
    e[idx] = x;
    //新节点的右边指向k的右边
    r[idx] = r[k];
    //新节点的左边指向k
    l[idx] = k;
    //原本k的右边的节点左边指向新节点
    l[r[k]] = idx;
    //k的右边指向新节点
    r[k] = idx;
    idx++;
}//在k的右边插入一个点，就调用add(l[k], x)

//删除第k个点
void remove(int k)
{
    r[l[k]] = r[k];
    l[r[k]] = l[k];
}

栈与队列

栈

先进后出

int stk[N], tt;

//插入
stk[++tt] = x;

//弹出
tt--;

//栈顶
stk[tt];

//判断栈是否为空
//tt大于0就是不空，不然就是空

队列

先进先出

//在队尾插入元素，在队头弹出元素
int q[N], hh, tt;

//插入
q[++tt] = x;

//弹出
hh++;

//判断是否为空
//hh小于等于tt就不为空，否则为空

//取出队头元素
q[hh];

kmp

kmp算法是用来解决在长字符串中查找子字符串问题的。比如字符串“abcdefg”中查找“cde”。

思想

首先，引入一个前缀表的概念，前缀表指的是前缀和后缀相同的长度。比如字符串“abab”，前缀和后缀都是ab，长度就是2。

我们一般会用一个next数组存储题目中子字符串的前缀表。数组的第几个元素存储的就是第几个子字符串的子串。比如“abab”的第一个子串是“a”，第二个子串是“ab”，所以“abab”的next数组就应该是｛0，0，1，2｝。

接下来是算法部分。

我们不用先前缀表，假如说我们有一个长字符串“aecdaefg”，查找子串“aef”，我们从第一个字符开始，一个一个匹配，长字符串中前三个字符是“aec”，匹配到c的时候会发现不是我们要查找的，而我们要查找的字符串“aef”中这三个字符不重复，也就是说我们不用从长字符串的“e”开始匹配，可以直接排除第二个，从第三个开始匹配。

这样的话，我们遍历长字符串就不需要回退了（原本已经指向c了，如果不跳过e，就要回退到e），现在子串还需要回退，我们原本已经匹配到子串的c了，再匹配又要回到a开始。

接下来我们用前缀表优化这个问题，假设有个长字符串“aacaadefg”，一个子串“aacaab”。我们从第一个字符开始遍历后，长字符串指向d停止，子串指向b停止。我们将子串“b”之前的视为一个子子串，会发现它的前缀和后缀重复长度是2。我们就可以将子串的第一个aa对准长串的第二个aa，这样长串的指向的是d，子串指向的是c，从这里继续匹配。大概效果：

"aacaadefg"
"   aacaab"
      I

两个字符串都从大写i指向的位置继续匹配（空格只是为了对齐）。

上面的是怎么利用前缀表找，接下来说一下怎么得前缀表（也会利用优化过的回退机制）

在GetNeed（下面的代码）中，我们每次循环其实都是相当于基于上一次循环，假如我们上一次判断的是“abcab”，我们的next[j-1]存储的就是2。

为什么要回退到next，因为next中存储的值不仅可以当长度用，还可以当做索引，是上一个相同长度前缀的下一元素的索引。这样只要判断一次（假如是相等，直接++就可以存入了。假如不想等，再去取上一次相等的）

假如我们下一次循环要判断的子串是“abcabc”，我们会发现j刚好指向第一个c，i指向第二个c。然后j就可以++（之前是2）再存进去。

代码

int* GetNext(std::string s)
{
	int j = 0;
	int* next = new int[s.size()];
	next[0] = 0; //初始化，第一个子串肯定是0
	for (int i = 1; i < s.size(); i++)
	{   
		//i指后缀末尾，j指前缀末尾
		while (j > 0 && s[i] != s[j]) j = next[j - 1];  //前后缀不相同，去找j前一位的最长相等前后缀（会利用上一个相同的结果）
		if (s[i] == s[j]) j++;  //前后缀相同，j指针后移

		next[i] = j;
	}
	return next;
}

int strSTR(std::string s, std::string t)	//这个函数是从s中找到t，如果存在返回t出现的位置，如果不存在返回-1
{
	if (t.size() == 0)	return 0;
	int* next = GetNext(t);
	int j = 0;
	for (int i = 0; i < s.size(); i++) {
		while (j > 0 && s[i] != t[j])	j = next[j - 1];
		if (s[i] == t[j])	j++;
		if (j == t.size())	return i - t.size() + 1;
	}
	return -1;
}