数据结构面试之二——双向链表表、循环链表、有序链表的常见操作

数据结构面试之二——双向链表表、循环链表、有序链表的常见操作

题注:《面试宝典》有相关习题,但思路相对不清晰,排版有错误,作者对此参考相关书籍和自己观点进行了重写,供大家参考。

二、双向链表

双向链表的建立是在单链表的基础上,多了一个指向前驱的指针back。其他的操作类似,注意点就是在双向链表的操作,尤其插入、删除操作中需要修改两个指针的指向,一个是back指针,一个是next指针。

1.双向链表的构建【前面插入】

构建双向链表注意点:1)修改first指针(头指针)的指向。2)修改back、next指针。

//反向表头插入,从前面插入...

template<typename Type>
nodeType<Type>*doublyLinkedList<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->next = NULL;
              newNode->back = NULL;
             
              if(first == NULL)
              {
                     first = newNode;
              }
              else
              {
                     newNode->next = first;
                     first->back = newNode;
                     first = newNode;
              }
 
              cin >> num;
       }
       return first;
}

2.双向链表的插入节点【此处考虑插入后保证有序,直接插入排序】

节点的插入同单链表,依然需要考虑多种因素。分以下几类:

1)双向链表为空,“提示信息”并返回。

2)双向链表非空,待插入节点的元素值小于first节点,需要修改first指针。

3)双向链表非空,待插入节点的元素值为链表中间的节点,需修改back、next指向。

4)双向链表非空,待插入节点在最末尾节点以后,修改最末节点的指针。

 
//双向不循环链表
template<typename Type>
voiddoublyLinkedList<Type>::insertNode(const Type& insertItem)  //new
{
nodeType<Type> *current;
nodeType<Type> *trailCurrent;
nodeType<Type> *newNode;
bool found = false;
 
newNode = new nodeType<Type>;
newNode->info = insertItem;
newNode->next = NULL;
newNode->back = NULL;
 
//case 1: 空表
if(first == NULL)
{
        first = newNode;
}
else
{
        current = first;
        while( current != NULL)
        {
               if( current->info >= insertItem )
               {
                      found = true;
                      break;
               }
               else
               {
                      trailCurrent = current;
                      current = current->next;
               }
        }
 
        //case 2: 第一个节点
        if(current == first)
        {
               current->next = newNode;
               newNode->back = current;
        }
        else
        {
               //case 3: 中间节点
               if(current != NULL)
               {
                      newNode->next = trailCurrent->next;
                      current->back = newNode;
                      trailCurrent->next = newNode;
                      newNode->back = trailCurrent;
               }
               else  //case 4:最后一个节点前
               {
                      trailCurrent->next = newNode;
                      newNode->back = trailCurrent;
               }//end case 4
        }
}
}

3.双向链表的删除节点

同样需要考虑以下几点:

1) 链表为空,“提示信息”并返回。

2) 链表非空,查找删除的元素在链表是否存在。是的话,found=true;否的话,found=false。

3) 如果没有找到包含查找元素的节点,“错误提示”并返回。

4) 如果找到,主要节点位置。如果是头节点或末尾节点主要修改first指针,及节点的back、next指向;如果不是头节点或者末尾节点就是中间节点,主要back、next的指向,完成插入。

template<typename Type>
void doublyLinkedList<Type>::deleteNode(constType& deleteItem)   //new
{
  nodeType<Type> *current = new nodeType<Type>;
  nodeType<Type> *trailCurrent;
  bool found = false;
        
  //case 1: 空表
  if(first == NULL)
  {
         cout << "The List is NULL!" << endl;
         exit(1);
  }
  else
  {
         current = first;
         while( current != NULL)
         {
                if( current->info == deleteItem )
                {
                       found = true;
                       break;
                }
                else
                {
                       trailCurrent = current;
                       current = current->next;
                }
         }
 
         if(found)
         {
                //case 2: 第一个节点
                if(current == first)
                {
                       first = current->next;
                       delete current;
                }
                else
                {
                       //case 3: 中间节点
                       if(current != NULL)
                       {
                              if(current->next != NULL)  //case3.1:要删除的是中间节点.
                              {
                                     trailCurrent->next =current->next;
                                     current->next->back = trailCurrent;
                                     delete current;
                              }
                              else
                              {
                                     trailCurrent->next = NULL;//case3.2:要删除的为最后一个节点.
                                     delete current;
                              }
                       }
               
                }// end else
         }// end if
         else
         {
                cout << "The elem " <<deleteItem << " is not Exist in the List!" << endl;//case 4: 链表中无此节点.
         }
  }//end else
}//end

三、循环链表

       循环链表能保障从每一个节点出发都能检索链表。即:last指针的指向不再为空,而是指向了first(头结点)。

       循环链表在构建链表、查找元素、插入、删除、操作中要注意修改末尾节点指针的指向,保证链表的循环。

1.      前插式构建循环链表

【思路】:每次在first指针前面插入节点;插入每个节点后注意修改last->link的指向。

template<typename Type>
void cycleList<Type>::bulidCycListBackward() //前插构造循环链表.
{
        Type newItem;
        while(cin >> newItem, newItem != -999)
        {
               nodeType<Type>* newNode = newnodeType<Type>;
               newNode->info = newItem;
               newNode->link = NULL;
 
               if(first == NULL)
               {
                      first = newNode;
                      last = newNode;
                      first->link = first;
                      last->link = first;
               }
               else
               {
                      newNode->link = first;
                      last->link = newNode;
                      first = newNode;
               }
        }
        cout << "输入完毕!" << endl;
}

2.      循环链表插入元素[后插入]

【思路】:同构造循环链表,每次在last指针后面插入节点;插入每个节点后注意修改last->link的指向。

//只在last末尾插入
template<typename Type>
voidcycleList<Type>::insertCycList(const Type& newItem)
{
nodeType<Type> *newNode = new nodeType<Type>;
newNode->info = newItem;
newNode->link = NULL;
 
if(first == NULL)        //链表为空...
{
        first = newNode;
        last = newNode;
        first->link = first;
        last->link = first;
}
else                   //链表非空...
{
        last->link = newNode;
        newNode->link = first;
        last = newNode;
}
cout << newItem << "was inserted!" <<endl;
}

3.      删除循环链表节点

考虑到是否为空链表、删除元素在链表中不存在、及节点存在(节点的位置可能为共分头、中间、尾),所以分为以下5种情况分别处理。:

//case1:链表为空。
//case2:链表非空,删除节点为头节点。
//case3:链表非空,删除节点为尾节点。
//case4:链表非空,删除节点为中间节点。
//case5:链表非空,不存在=deleteItem的节点。
template<typename Type>
voidcycleList<Type>::delCycList(const Type& deleteItem)
{
nodeType<Type> *current = new nodeType<Type>;
nodeType<Type> *trailCurrent = new nodeType<Type>;
nodeType<Type> *temp ;
bool found = false;
 
if( first == NULL )
{
        cout << "The List is Empty!" << endl;//case1
        return;
}
if( first->info == deleteItem )      //case2
{
        temp = new nodeType<Type>;
        temp = first;
        first = first->link;
        last->link = first;
        cout << "The node has" << deleteItem<< " was deleted! " << endl;
        delete temp;
        return;
}
else                                             //cas3,case4.需要查找后定位。
{
        current = first->link;
        while( !found && current != first)
        {
               if( current->info == deleteItem )
               {
                      found = true;
                      break;
               }
               else
               {
                      trailCurrent = current;
                      current = current->link;
               }
        }// end while
 
        if(found)
        {    
               temp = new nodeType<Type>;
               if(current == last)                        //case3
               {
                      temp = last;
                      trailCurrent->link = last->link;       //last->link = first
                      last = trailCurrent;
               }
               else
               {
                      temp = current;
                     trailCurrent->link= current->link;
               }
               cout << "The Elem : " <<deleteItem << " was deleted! " << endl;
               delete temp;
        }
        else
        {
               cout << "The Elem : " <<deleteItem << " was not Exist in the List! " << endl;
        }
}//end else
}

四、有序链表

注意:此处有序链表无非是在之前的一、单链表的操作的基础上,在插入元素的时候,按顺序插入,考虑的排序。

为了体现有序的特点,特通过递归实现了有序链表的逆序打印。关于有序链表或者链表的非递归实现,可以通过栈实现。下一节会分析并实现。

1.      有序链表的插入

考虑以下三种情况:

1) 当前链表为空;

2) 当前链表非空,要插入的元素值小于头结点的元素值;

3) 当前链表非空,要插入的元素值大于头结点的元素值,可以考虑找到第一个大于其的元素则停止搜索,插入其前即可。

template<typename Type>
void orderedLinkedListType<Type>::insertNode(constType& newItem)
{
nodeType<Type>* current;
nodeType<Type>* trailCurrent;
nodeType<Type>* newNode;
 
bool found = false;
 
newNode = new nodeType<Type>;
newNode->info = newItem;
newNode->link = NULL;
 
if(first == NULL)                           //case1:链表为空.
{
        first = newNode;
        last = first;
}
else
{
        current = first;                     
        while( !found && current != NULL)       //循环查找
        {
               if(current->info >= newItem)
               {
                      found = true;
                      break;
               }
              else
               {
                      trailCurrent = current;
                      current = current->link;
               }
        }//end while
 
        //first 特殊处理..
        if(current == first)                //case2:新插入的元素小于first节点的元素值..
        {
               newNode->link = first;         
               first = newNode;
        }
        else //其他..
        {
               newNode->link = current;       //case3:新插入的节点在非first位置
               trailCurrent->link = newNode;
        }
}//end else
}

2.      递归实现有序链表的逆序打印

template<typename Type>
voidorderedLinkedListType<Type>::printListReverse() const   //逆序打印.
{
     reversePrint(first);
     cout << endl;
}
 
//递归实现单链表的逆序打印.
template<typename Type>
voidorderedLinkedListType<Type>::reversePrint(nodeType<Type>* current)const  //逆序打印
{
if(current != NULL)
{
        reversePrint(current->link);
        cout << current->info << "\t";
}
}



发布了359 篇原创文章 · 获赞 2735 · 访问量 329万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 代码科技 设计师: Amelia_0503

分享到微信朋友圈

×

扫一扫,手机浏览