数据结构重现之一 ----------表

最近在学习，准备找工作，想把学习到的东西掌握好，于是就一遍理论一遍实践，把自己学到的贴出来，就算是原来文章中有的，我也要通过自己的双手把他敲出来，这样子我觉得总会有收获的。看到之一当然会陆续有之二，················。如果大家看了有什么建议，不啻吝教，我觉得学习需要分享，不分享学到了也没有多大作用，不知道你觉得如何？好了，废话就少说了，直入正题。

今天看了数据结构中俗称最简单，最基本的三种数据结构：表、栈和队列。

他们的共同点就是：具有相同类型的数据的集合。

对其进行的操作应该是根据特定的环境而设计的，但是他们都应该有最起码的操作。

表：应该具有的按下标访问，查找，插入、删除等操作。

概念有了之后，我们就要考虑怎么存储数据了，以方便我们进行以上的这些操作。评估了一下，其实各有各的好处，你使用数组来存储，没问题，访问的速度很快，但是在插入删除上就会降低了效率，使用链表吧，插入删除挺方便的，但是访问上就会耗时间，所以说还是按照你所处的环境而定的，但是我们应该掌握不同情况的处理方式。

 

本人使用的是C++语言

实现：

 

 

//definition the LIST
#ifndef   _LIST_H
#define  _LIST_H
#include <iostream>
using namespace std;

template <typename  T>
class Node{
public:  T  m_data;
       Node<T> *next;
      Node(const T data)  : m_data(data),next(NULL){}
   Node(){next=NULL;}
   ~Node(){}    
   bool operator >(Node<T> it){
    if (this->m_data > it.m_data)
    {  return true;
    }
    else return false;
   }
};

//typedef Node<T>  *PNode;
template <typename T>
class myList
{ private: int m_count;
              Node<T> *m_head;
              Node<T> * Find(T e, Node<T> * p); 
     void Delete(T e,Node<T> * p);
     Node<T> *FindPrevious(T e,Node<T> * p);    

  public: myList();
       ~myList();
    bool IsEmpty();
    bool isLast(const Node<T> * const p);
    Node<T> * Find(T e);   //interface
             void Delete(T e);
            Node<T> *FindPrevious(T e);
   void Insert(T e,Node<T> * p);
   void Insert(T e);
   void DestroyList(Node<T> * p);
   Node<T> * First();
   Node<T> *Last();
   int  GetCount();
   void Print();
   void Sort();
};

 

#endif

template <typename T>
void myList<T>::Sort()            //排序的思想是在原来链上找出最小的，然后抽出来，再重新在链表中再找最小的再抽出来排成一个有序额链表。
{
 Node<T>* head=new Node<T>; //
 Node<T>* p;
 Node<T>* q;
 Node<T>* beforTarget;
 Node<T>* target;

 head->next=NULL;
 
  while (m_head->next!=NULL)
  {
   q=target=m_head->next;
   beforTarget=m_head;

   p=q->next;
   if (NULL==p)
   { 
    beforTarget->next=target->next;
   target->next= head->next;
   head->next=target;
   m_head->next=head->next;
   head->next=NULL;
   delete  head;
   return;
   }

        while(NULL!=p)
          {
            if (*p > *target)
             {
         target=p;
          beforTarget=q;
             }
          q=p;
        p=p->next;
            }
  beforTarget->next=target->next;
  target->next=head->next;
  head->next=target;
    }
}

template <typename T>
int myList<T>::GetCount()
{
 return m_count;
}

template <typename T>
Node<T> * myList<T>::First()
{
 return m_head->next;
}

template <typename T>
Node<T> * myList<T>::Find( T e )
{
return  Find(e,m_head);
}

template <typename T>
inline myList<T>::myList()
{
 m_count=0;
 m_head=new Node<T>;
 m_head->next=NULL;
}

template <typename T>
myList<T>::~myList()
{
 DestroyList(m_head);
 if (NULL!=m_head)
 {  delete m_head;
    m_head=NULL;
 }
}

template <typename T>
inline bool myList<T>::IsEmpty()
{
 return 0==m_count;
}

template <typename T>
bool myList<T>::isLast( const Node<T> * const p )
{
  return NULL==p->next;
}

template <typename T>
Node<T> * myList<T>::Find( T e, Node<T> * p )
{
 Node<T> * tmp;
 tmp=p->next;
 while (NULL!=tmp && tmp->m_data!=e )
 {     tmp=tmp->next;
 }

 return tmp;
}

template <typename T>
Node<T> * myList<T>::FindPrevious( T e,Node<T> * p )
{
 Node<T> *tmp;
 tmp=p;
 while (NULL!=tmp->next && e!=tmp->next->m_data)
 {  tmp=tmp->next;
 }

 return tmp;
}

template <typename T>
Node<T> * myList<T>::FindPrevious( T e )
{
   return FindPrevious(e,m_head);
}

template <typename T>
void myList<T>::Insert( T e,Node<T> * p )
{
 Node<T> *tmp=new Node<T>;
 if (NULL!=tmp)
 { tmp->m_data=e;
     tmp->next=p->next;
     p->next=tmp;
  m_count++;
 }
}

template <typename T>
void myList<T>::Insert( T e )
{
 Insert(e,Last());
}

template <typename T>
void myList<T>::Delete( T e )
{
 Node<T> * tmp=FindPrevious(e);
 if (NULL!=tmp)
 {   
  Node<T> *p=tmp->next;
  tmp->next=p->next;
  delete p;
  m_count--;
 }
}

template <typename T>
void myList<T>::DestroyList( Node<T> * p )
{
 Node<T> * tmp=p->next;
 while (NULL!=tmp)
 {  p->next=tmp->next;
    delete tmp;
    tmp=p->next;
 }
 m_count=0;
}

template <typename T>
Node<T> * myList<T>::Last()
{
 Node<T> *p=m_head;
 while (p->next!=NULL)
 {   p=p->next;
 }

 return p;
}
template <typename T>
void myList<T>::Print()
{
 const  Node<T> * tmp= m_head->next;
 while (tmp)
 {  cout<<tmp->m_data<<"\t";
   tmp=tmp->next;
 }
 cout<<endl;
}

 

//测试
void main()
{
 myList<int> *list=new myList<int>();
 if (list->IsEmpty())                                      //判断是否为空
 {
  cout<<"The list is empty"<<endl;
 }
 int m=9;

//插入数据
 list->Insert(3);
 list->Insert(m);
 list->Insert(6);
list->Insert(8);

//查找数据
 Node<int> *p=list->Find(3);
 if (p)
 {  
  cout<<"the value of P is: " << p->m_data <<endl;
 }

//取得节点个数

 int num=list->GetCount();
 cout<<"The list has "<<num<<" nodes"<<endl;

 

//打印

 list->Print();

//排序
 list->Sort();
 cout<<"After sort :"<<endl;
 list->Print();

 

//删除
 list->Delete(3);
 cout<<"After delete:"<<endl;
 list->Print();
 delete list;
 list=NULL;
 getchar();
 return;
}