数据结构面试之一——单链表常见操作
数据结构面试之一——单链表常见操作
题注：《程序员面试宝典》有相关习题，但思路相对不清晰，排版有错误，本文对此参考相关书籍和自己观点进行了重写，供大家参考。
1.查找链表元素
Step1：置查找标记bfound=false;判断链表是否为空，是，提示“不能查找空链表”；否，进入step2。
Step2：从链表头开始查找，判断（当前点的info是否与待查找元素值相等&&指针未指向末尾），是，“查找结束，bfound=true”，否，继续查找。
Step3：判断bfound= = true，是，“提示查找成功”，否，“提示查找失败”。
/查找单链表元素
template<typename Type>
void linkedlistType<Type>::search(const Type& searchItem)
{
nodeType<Type> *current;
bool found = false;
if(first == NULL) //1.空链表
{
cout << "WARNING: Can not search an empty list!" << endl;
return;
}
else
{
current = first;
while(!found && current != NULL)
{
if(current->info == searchItem)
{
found = true;
break;
}
else
{
current = current->link;
}
}
if(found)
{
cout << searchItem << " was found in the List! " << endl;
}
else
{
cout << searchItem << " was not found in the List! " << endl;
}
}
}
2.删除链表元素值
Step1：置查找标记bfound=false; 判断链表是否为空，是，提示“不能对空链表进行删除操作”；否，进入step2。
Step2：判断待删除元素值是否与头节点元素值相等，是，调整头节点指针；否，进入step3。
Step3：判断链表中是否存在该元素，否，“提示元素不存在”；是，进入step4。
Step4：判定要删除元素是否与末尾节点元素值相等，是，调整末尾last指针；否，此时为中间节点，需要调整trailCurrent和Current指针的指向。
//删除单链表元素
template<typename Type>
void linkedlistType<Type>::deleteNode(const Type& deleteItem)
{
nodeType<Type> *tempNode = new nodeType<Type>;
nodeType<Type> *current = new nodeType<Type>;
nodeType<Type> *trailCurrent = new nodeType<Type>;
bool found;
//链表为空 case1
if(first == NULL)
{
cout << "Can not delete an empty List!" << endl;
}
else
{
if( first->info == deleteItem )
{
//要删除的也是第一个节点(仅一个节点，或不止一个节点) case2
tempNode = first;
first = first->link;
if(first == NULL)
{
last = NULL;
}
delete tempNode;
}
else
{
//先查找，后判断... case3
found = false;
trailCurrent = first;
current = first->link;
while((!found) && (current != NULL))
{
if(deleteItem != current->info)
{
trailCurrent = current;
current = current->link;
}
else
{
found = true;
}
}
if(found)
{
//能找到...
trailCurrent ->link = current->link;
if(current == last)
{
last = trailCurrent; //case 3a
}
delete current; //case 3b
}
//不存在该点...case4
else
{
cout << "The deleteItem is not Exist in the List! " << endl;
} //end else
}//end else
}//end else
}// end deleteNode
3.单链表逆置[迭代实现]
Step1：判断链表是否为空，是，提示“不能对空链表进行逆置操作“；否，进入Step2；
Step2：从第2个节点开始，依次将每个节点插入到第一个节点的前面，判断指针是否指向了链表尾部，是，返回头指针结束；否，继续迭代后面的链表元素。
template<typename Type>
nodeType<Type>* linkedlistType<Type>::reverseList() //逆置单链表
{
if(first == NULL)
{
cout << "Can't reverse empty List!" << endl;
}
else
{
nodeType<Type>* p = first;
nodeType<Type>* q = p->link;
while(q != NULL)
{
p->link = q->link;
q->link = first;
first = q;
q = p->link;
}
}
return first;
}
4．单链表排序[直接插入排序]
思路：分为以下几种情况：
1） 单链表为空；
2） 单链表非空，但仅含一个元素，无需排序已经有序；
3） 待插入元素小于头结点的元素；
4） 待插入元素为前已有序的中间的元素值；
5） 待插入的元素前所有元素都比其小，直接插到末尾。
分别用lastInOrder记录已经有序的最后一个节点，firstOutOfOrder第一个尚未排序（正待参与）排序的节点。current用于记录循环的节点，trailCurrent记录current前的节点。
template<typename Type>
void linkedlistType<Type>::sortList() //单链表排序
{
nodeType<Type>* current;
nodeType<Type>* trailCurrent;
nodeType<Type>* lastInOrder;
nodeType<Type>* firstOutOfOrder;
lastInOrder = first;
//case1,表为空.
if(first == NULL)
{
cout << "Can't Sort of empty List!" << endl;
return;
}
//case2,表不为空,但表长为1,仅含1个元素.
if(first->link == NULL)
{
cout << "The List Was Already ordered!" << endl;
return;
}
while(lastInOrder->link != NULL)
{
firstOutOfOrder = lastInOrder->link;
//case3,要插入的元素小于第1个元素.
if(firstOutOfOrder->info < first->info)
{
lastInOrder->link = firstOutOfOrder->link;
firstOutOfOrder->link = first;
first = firstOutOfOrder;
}
else
{
trailCurrent = first;
current = first->link;
while(current->info < firstOutOfOrder->info)
{
trailCurrent = current;
current = current->link;
}
//case4,要插入的元素在前已有序元素的中间.
if(trailCurrent != lastInOrder)
{
lastInOrder->link = firstOutOfOrder->link;
firstOutOfOrder->link = current;
trailCurrent->link = firstOutOfOrder;
}
else
{
//case5,要插入的元素大于最后一个已经有序的元素.
lastInOrder = lastInOrder->link;
}//end else
}//end else
}//end while
}
5.单链表在不知道链表长度的前提下求链表中间节点的值。
思路：分以下几种情况：
1） 链表为空；
2） 链表非空，但仅有一个或两个节点；可以直接返回第一个节点的元素值。
3） 链表非空，但含有三个或三个以上的节点，可以通过定义两个指针，一个指针的跳步为2次的时候，另一个指针的跳步为1次，当跳至结尾时，另一个节点恰好在中间位置。
//不知道表长的前提下求单链表中间元素
template<typename Type>
Type linkedlistType<Type>::midValOfList()
{
nodeType<Type> *current;
nodeType<Type> *halfCurrent;
if(first == NULL) //case1,没有节点
{
cout << "链表为空!" << endl;
return -1;
}
else if(first->link == NULL || first->link->link == NULL) //case2,仅一个节点或两个节点.
{
return first->info;
}
else //case3,含有三个或三个以上的节点.
{
current = first;
halfCurrent = current;
while(current->link != NULL)
{
current = current->link;
if(current->link != NULL)
{
if(current->link != NULL)
{
halfCurrent = halfCurrent->link;
current = current->link;
}//end if
}
}//end while
return halfCurrent->info;
}//end else
}
6.单链表建立
思路：单链表的建立可分为根据插入新节点的位置的不同而分为两种，1：在链表末尾插入元素的建立方式；2：在链表前面插入元素建立链表的方式。
对应1末尾插入分为两步：
Step1：如果当前链表为空，则置first=last=newNode；否则，进入Step2。
Step2：插入新结点元素，修改last指针。
对于2链表first指针前插入：主要需要保证插入元素后，修正first节点即可。
//正向末尾插入
template<typename Type>
nodeType<Type>* linkedlistType<Type>::buildListForward()
{
nodeType<Type> *newNode;
int num;
cout << " Enter a list of integer end with -999. " << endl;
cin >> num;
while(num != -999)
{
//..add
newNode = new nodeType<Type>;
newNode->info = num;
newNode->link = NULL;
if(first==NULL)
{
first = newNode;
last = newNode;
}
else
{
last->link = newNode;
last = newNode;
}
cin >> num;
}
return first;
}
//反向表头插入，从前面插入...
template<typename Type>
nodeType<Type>* linkedlistType<Type>::buildListBackward()
{
nodeType<Type> *newNode;
int num;
cout << " Enter a list of integer end with -999. " << endl;
cin >> num;
while(num != -999)
{
//..add
newNode = new nodeType<Type>;
newNode->info = num;
newNode->link = first;
first = newNode;
cin >> num;
}
return first;
}
7.单链表的测量长度
思路：链表的长度等效为节点个数，指针非空则循环判断即可。
//求解链表长度
template<typename Type>
int linkedlistType<Type>::length()
{
int count = 0;
nodeType<Type> *current;
current = first;
while(current != NULL)
{
count++;
current = current->link;
}
return count; //节点个数等效为长度.
}
8.单链表的插入
思路：链表的插入也同链表的建立一样分为前向、后向插入两种形式，注意first、last指针的指向问题。
//在前面插入
template<typename Type>
void linkedlistType<Type>::insertFirst(const Type& newItem)
{
//last no use.
nodeType<Type> *newNode = new nodeType<Type>;
newNode->info = newItem;
newNode->link = first; //在前面加入...
first = newNode;
}
//在后面插入元素...
template<typename Type>
void linkedlistType<Type>::insertLast(const Type& newItem)
{
nodeType<Type> *newNode = new nodeType<Type>;
newNode->info = newItem;
newNode->link = NULL; //在后面加入...
if(first == NULL)
{
first = newNode;
last = newNode;
}
else
{
last->link = newNode;
last = newNode;
}
}
后续陆续会有栈、队列、二叉树、图、排序、查找等的相关分析，希望大家关注！