第一类：链表的考察(链表的插入，删除，排序和逆转等)

数据的存储结构在计算机中主要有四种基本的存储方式：顺序存储、链接存储、索引存储、散列存储方式。我们知道，顺序存储的优点是支持随机访问结构中的数据，但是在插入和删除方面运算时会造成大量数据的移动，效率较低；而链接存储却有效的补充了顺序存储的不足，当需要频繁的插入和删除时，效率得到提高。而索引存储附件了索引表，在访问时通过索引项（由关键字和地址组成值对）去访问数据的存储地址，而散列存储的就是hash的存储方式，即根据关键字通过hash转换求的数据的存储地址。在面试的过程中，链表是其中重要考察内容，下面让我们来一起学习和交流常见的链表操作。

首先，让我们重温一下单链表的数据结构：

typedef int datatype;

typedef struct ListNode{

datatype data;//结点数据域

ListNode *next;//结点指针域

}ListNode,*Linklist;

一、在单链表的实现的基本运算操作

这些基本操作包括：1.查找单链表中的第i个结点 2.返回指定元素的索引号 3.单链表的插入和删除，这些都是最基本的操作，大家一定要熟练，直接上码图！

*
*author:xuzhaohu
functon:单链表的数据结构，查找、插入和删除
*/
#include <iostream>
using namespace std;

typedef int datatype;
typedef struct node
{
datatype data;
struct node *next;
}ListNode,*LinkList;

//查找单链表中的第i个节点的地址
ListNode * Locate(LinkList head,int i)
{
ListNode *p;
int index = 0;
if(head==NULL)
return NULL;
if(i<0)
return NULL;
p = head;
if(p!=NULL && index<i)
{
p=p->next;
index++;
}
return p;
}
//返回链表中第一个节点元素为 x 的值的索引号
int findValue(LinkList head,datatype x)
{
ListNode *p;
int index = 1;
if(head==NULL)
return 0;
p=head;
if(p!=NULL)
{
if(p->data == x)
return index;
else
{
p=p->next;
index++;
}
}
else
{
cout<<"单链表中没有这个值的元素"<<endl;
return 0;
}
}
//单链表的插入 分表首插入和表中插入
void InsertNode(LinkList &head,int i,datatype x)
{
ListNode *p,*q;
p = Locate(head,i-1);//注意是掺入前面的一个元素
q = new ListNode;
q->data = x;
if(i == 0)
{
q->next = head;
head = q;
}
else
{
q = p->next;
p->next = q;
}
}
//单链表的删除 ,也分表头删除和表中删除
void DeleteNode(LinkList &head,int i)
{
ListNode *p,*q;//q是删除节点p是其前一个节点
p = Locate(head ,i-1);//注意是找到前面一个元素
if(i==0)
{
q = head;
head=q->next;
delete q;
}
else
{	if(p==NULL)//i值给的有问题，索引值溢出后者为负值
cout<<"error"<<endl;
else if(p->next == NULL)//p恰好是最后一个元素
cout<<"no ith node"<<endl;
else
{
q = p->next;
p->next = q->next;
delete q;
}
}
}

int main()
{
return 0;
}

二、用链表实现对栈和队列

这是个基础也是非常重要的算法实现问题，既能考察对栈和队列的理解又考察了对链表的操作，因此，也是面试中应该着重学习的地方。

2.1 链栈的数据操作

/**
* author:xuzhaohu
* function:stackNode 先进后出
* date:
*/
#include<iostream>
using namespace std;
//与单链表相似，不同之处在与插入和删除只限定在表首进行，表头指针就是栈顶元素
typedef int datatype;
typedef struct node
{
datatype data;
struct node *next;
}StackNode,*LinkStack;
// 链栈的插入
void push(LinkStack &top,datatype x)
{
StackNode *p;
p = new StackNode;
//注意：链栈的插入只考虑单链表的表首插入
p->data = x;
p->next = top;
top = p;
}
//链栈的弹出
void pop(LinkStack &top,datatype &x)
{
StackNode *p;
if(top == NULL)
cout<<"underflow"<<endl;
else
{
//链栈的删除只考虑表首的删除
p = top;
x = top->data;
top = top->next;
delete p;
}
}
//读取链栈的栈顶元素
void GetTop(LinkStack top, datatype &x)
{
if(top == NULL)
cout<<"error";
else
x = top->data;
}
//置空链栈
void ClearStack(LinkStack &top)
{
top = NULL;
}
//判断链栈是否为空
int StackEmpty(LinkStack &top)
{
if(top == NULL)
return 1;
else
return 0;
}

int main()
{
return 0;
}

2.2链队列的数据操作

/**
*author:xuzh
*function:链队列的数据结构,先进先出
*/
#include<iostream>
using namespace std;

typedef int datatype;
typedef struct node
{
datatype data;
struct node *next;
}QueueNode;
typedef struct
{
QueueNode *front;//队头指针
QueueNode *rear;//队尾指针
}LinkQueue;
QueueNode *p,*q;
LinkQueue QU;
datatype x;

//链队列的插入,只能在队尾插入
void EnQueue(LinkQueue &QU,datatype x)
{
QueueNode *p = new QueueNode;
p->data = x;
p->next = NULL;//p为最后一个元素
if(QU.front == NULL)
QU.front = QU.rear = p;
else
{
QU.rear->next = p;//队尾元素变为新的元素p，p为旧的队尾元素的下一个元素
QU.rear = p;
}
}
//链队列的删除，只能在队首操作
void DeQueue(LinkQueue &QU,datatype &x)
{
QueueNode *q;
if(QU.front == NULL)
cout<<"underflow"<<endl;
else
{
q = QU.front;
x = q->data;
QU.front = q->next;
delete q;
}
}
//读栈头元素
void GetFront(LinkQueue &QU,datatype &x)
{
if(QU.front == NULL)
cout<<"error"<<endl;
else
x = QU.front->data;
}
//清空队列
void ClearQueue(LinkQueue &QU)
{
QU.front = QU.rear = NULL;
}
//判定一个队列是否为空
int QueueEmpty(LinkQueue &QU)
{
if(QU.front == NULL)
return 1;
else
return 0;
}
int main()
{
return 0;
}

三、链表的综合操作

3.1.逆向链表的实现 ReverseList(ListNode &head)

思路：通过改变指针指向实现，代码如下：

//reverse the list
void ReverseList(LinkList &head)
{
ListNode *p,*q,*r;//相邻的两个指针
if(head == NULL)
cout<<"error"<<endl;
p = head;
q = p->next;
p->next = NULL;//首节点对应着 逆转后的 最后一个节点
while(q!=NULL)
{
if(q->next==NULL)
head = q;//表首指针指向最后一个元素
r = q->next;
q->next = p;
p = q;
q = r;
}
}

3.2尽量用最小的时间消耗完成对中间结点的查询

思路：用快慢指针实现，快指针步长为2，慢指针步长为1，同时遍历，当快指针遍历完成时，慢指针指向就是中间结点，复杂度为O(n),代码如下

//尽量用最小的时间消耗完成对中间结点的查询
void FindMindleNode(LinkList head)
{
ListNode *fast,*slow;//定义一个快慢指针，一个步长为2，一个步长为1
int index = 1;//中间节点的索引值
if(head == NULL)
{
cout<<"error"<<endl;
return ;
}
slow = fast = head;
if(head->next == NULL)
{
cout<<"the mid node is "<<index<<endl;
return ;
}
slow = slow->next;//慢指针走一步
fast = fast->next;//快指针走两步
while(fast!=NULL && slow!=NULL)
{
index++;
slow = slow->next;
if(fast->next == NULL)//如果fast的下一个指针就已经为空了，说明快指针已经遍历完成
fast = fast->next;//这时候让fast指针指向最后一个元素就行
else
fast = fast->next->next;
}
cout<<"the mid node is "<<index<<endl;
}

3.3用最小空间和时间找出该链表的倒数第m个元素

思路：同样可以采用双指针的，一个指针先遍历m个元素，然后第二个指针与第一个指针同时遍历链表，直到第一个指针遍历结束，则第二个指针遍历到的位置即为倒数第m个元素。代码如下

//get the mth element in the list
int GetLastM(LinkList head, int m)
{
ListNode *fast,*slow;
int i = 0;
fast = slow = head;
if(head == NULL)
return -1;
while(fast!=NULL)
{
i++;
fast = fast->next;
if(i>=m)
{
if(slow!=NULL)
slow = slow->next;
}
}
return slow->data;
}

3.4如何判断一个单向链表是否存在循环

思路：一、使用步长法判断，用不同步长遍历两次，看是否遇见。遇见则证明有环；二、如果链表中当前的node的下一个node不是前面的任何一个访问后的node，那么则没有环，否则有环。下面是思路一的代码

// Circle List 's last element->next = head
bool CircleList(LinkList head)
{
//define two different step pointer,if they meet,there is circle, or not
ListNode *fast,*slow;
if(head == NULL)
return false;
slow = head;
fast = head->next;
while(fast!=NULL && fast->next!=NULL && slow!=fast)
{
slow = slow->next;
fast = fast->next->next;
}
if(slow = fast)
return true;
else
return 0;
}

结束！小弟也在学习中，希望通过自己学到的和大家进行交流，如有不准确和正确的地方，请各位指正，小弟不甚感激！！^_^