数据结构复习篇:线性表

数据结构与算法，是编写高质量程序的内功之一，在打算步入社会寻找自己的第一份工作之际，我准备用一周左右的时间来复习一遍数据结构与算法。在任何时候重视基础知识，都不是一件多余的事。

复习用书：《数据结构与算法分析 C++版》第二版 [美] Clifford A.Shaffer著，张铭、刘晓丹 等译 电子工业出版社

一、线性表

线性表是这样一种表结构，它的元素element存放在一个连续的表中，这个表的关键之处就在于“连续”（注意，这里仅是指逻辑上的连续，在线性表中，有一种链表实现，其内存不要求连续），就是说当一个元素添加进一个表，或一个元素从表中删除的时候，表中元素的排列就像有一条线把它们串起来一样。我相信这样的解释已经显得啰嗦了，因为线性表这个名字，本来就很形象。

从程序设计的角度，我们先定义用户所关心的线性表的界面，就好像我们找女友的时候，先在心中描绘一个梦中情人的形象：

/*
定义线性表的界面,作为顺序表或链表的公用接口
*/
#ifndef LISTINTERFACE_H
#define  LISTINTERFACE_H
template < class  T >   class  ListInterface
{
public :
     // 向线性表的栅栏的right partition的第一个位置插入一个元素,返回值表示插入是否成功
     virtual   bool  insert( const  T & ) = 0 ;
     // 删除栅栏的right partition的第一个位置的元素,返回值表示删除是否成功,被删除的值通过形参返回
     virtual   bool  remove(T & ) = 0 ;
     // 清空所有元素,但不销毁内存
     virtual   void  clear() = 0 ;
     // 还有其他接口函数,比较简单,不作重点.
};

#endif

一般有两种实现：

1、基于数组的顺序表（Array_based List）：访问第i个元素的时间代价为O(1)，删除或插入一个元素的代价为O(n)。

2、链表（Linked List）：访问第i个元素的时候代价为O(1)，删除或插入一个元素的代价为O(n)。

由此可见，这两种表各具特色。在应用中，应该考虑对表中元素是访问多，还是修改多。前者采用AList，后者采用LList。

以下是这两种实现：（由于是复习，我只挑我认为关键的写出来。这对于找工作的人，应付笔试也许有一定帮助）

 

#include  " ListInterface.h "
#include  < iostream >
using   namespace  std;

// 用数组实现线性表AList(array_based list)
template < class  T >   class  AList
            : public  ListInterface < T >
{
private :    
     int  maxSize;     // 顺序表的最大长度
     int  listSize;     // 实际长度
     int  fence;     // 栅栏位置,后面将发现这与链表的栅栏是不同的
    T  * listArray;     // 一个指向顺序表数组的指针
public :
    AList( int  size  =   100 )
    {
        listArray  =   new  T[size];
        maxSize  =  size;
        fence  =  listSize  =   0 ;
    }
     ~ AList()
    {
        delete [] listArray; 
    }

     bool  insert( const  T &  element)
    {
         if  (listSize  ==  maxSize)
        {
             return   false ;     // 表满,无法再插入元素
        }
         for  ( int  i = listSize - 1 ; i >= fence; i -- )     // 把栅栏右边的所有元素往后挪一位
        {
            listArray[i + 1 ]  =  listArray[i];
        }
        listArray[fence]  =  element;     // 给插入的元素赋值
         ++ listSize;
         return   true ;
    }
    
     bool  remove(T &  elemet)
    {
         if  (fence  ==  listSize)
        {
             return   false ;     // 栅栏右边没有元素可以删除
        }
        elemet  =  listArray[fence];     // 把将要删除的值传给外面的参数
         for  ( int  i = fence + 1 ; i < listSize; i ++ )     // 把栅栏右边第二个及后面的元素往前挪一位
        {
            listArray[i - 1 ]  =  listArray[i];
        }
         -- listSize;
         return   true ;
    }

     void  clear()
    {
        delete [] listArray;
        listArray  =   new  T[maxSize];
    }

};    

/*
用链表实现线性表,首先定义一个结点类型Node
其次,定义一个链表(Linked_List)LList
*/

template < class  T >   class  LList;     // 注意,声明友元模板时,必须先进行前向声明

template < class  T >   class  Node
{
    friend  class  LList < T > ; // 声明友元类,这样LList便可以访问Node类的私有成员
private :
    T element;
    Node  *  next;     // 指向下一个结点的指针
public :
    Node( const  T &  eVal, Node  *  nVal  =  NULL)
    {
        element  =  eVal;
        next  =  nVal;
    }
    Node(Node  *  nVal  =  NULL)
    {
        element  =   0 ;
        next  =  nVal;
    }
     ~ Node(){}
};

template < class  T >   class  LList
            : public  ListInterface < T >
{
private :
    Node < T >   *  head;         // 头指针
    Node < T >   *  tail;         // 尾指针
    Node < T >   *  fence;     // 注意,链表的栅栏跟顺序表AList已经完全不同了
     int  leftcnt,rightcnt;     // 栅栏左,右两边的元素个数,注意,栅栏所指的元素,属于左边,
                 // 这与顺序表不同.原因在于,链表有一个头结点(head)不属于表中元素
                 // 由于已经约定了栅栏右边的元素都必须是表中元素,而栅栏可能指
                 // 向头结点,故不应该把栅栏所指的结点归为右边的元素

public :
    LList()
    {
        head  =  tail  =  fence  =   new  Node < T > ;
        leftcnt  =  rightcnt  =   0 ;
    }
     ~ LList()
    {
        clear();
        delete head;
    }
     void  clear()
    {
         while  (head -> next  !=  NULL)
        {
            fence  =  head;
            head  =  head -> next;
            delete fence;            
        }
    }

     bool  insert( const  T &  element)
    {
        fence -> next  =   new  Node < T > (element,fence -> next);         // 完成插入
        
         if  (fence  ==  tail)     // 如果在尾部插入了一个新元素
        {
            tail  =  fence -> next;    
        }
         ++ rightcnt;
         return   true ;
    }

     bool  remove(T &  element)
    {
         if  (fence  ==  tail)
        {
             return   false ;     // 栅栏右边没有元素可删除
        }

        Node < T >   *  tmpPtr  =  fence -> next;
        element  =  tmpPtr -> element;     // 把将删除的值传给外面的参数

        fence -> next  =  tmpPtr -> next;     // 完成移去

         if  (tail  ==  tmpPtr)         // 如果链表尾就是将要被删除的结点
        {
            tail  =  fence;         // 重新设置表尾指针
        }

        delete tmpPtr;             // 完成删除内存
         -- rightcnt;

         return   true ;
    }
};

应该如何把这么多数据结构的知识牢记在脑中，是我一直经常思考的问题。但我到现在还没有找到一种一劳永逸的方法，事实上，我觉得一劳永逸的想法或许从根本上就是错误的。

要理解它！要用图形的方法去想象它！比如链表的插入删除，书中都有图示，那就是一种把抽象的程序形象化的方法。写程序的时候，应该是按照脑中想象的那个画面来写，而不是看着笔下的那张白纸。

编程，有时候就是画画。