数据结构复习1---顺序表和链表

0引言

此笔记方便快速复习数据结构的基本组成和基本操作，列出了易错点和重点。

1顺序表

顺序表的结构体

顺序表是由一个数组和一个长度分量来实现的，需要注意的是，这个数组的长度是固定的常数。

#define MaxLen 100         //最多100个元素
typedef struct sList
{
   elementType data[MaxLen]; //定义存放元素的数组
   int listLen;              // 定义长度分量
}seqList;

顺序表的运算实现

初始化

分配内存并将长度设置为0。函数传参必须是指针类型，因为要对结构体数据进行赋值

void initialList(seqList *L)
{
	L = (seqList*) malloc(sizeof(seqList));//sizeof(seqList)为404
    L->listLen=0;
}

求表长度

返回表的长度，这个可以传结构体也可以传结构体指针。事实上传结构体指针效率更高。

int listLength(seqList L)
{
    return L.listLen ;
}

按序号取元素

首先判断给定的索引i是否合法，然后返回指定位置的元素值。

bool getElement(seqList L, int i, elementType &x)
{
	if(i<1 || i>L.listLen)
		return 0;  //序号i超出范围，取元素失败，返回0
	else
	{
		x=L.data[i-1];
		return 1;  //取元素成功，返回1；返回的值在x中
	}		
}

按值查找元素

从前往后，逐个查找。

int listLocate（seqList L，elementType x）
{
	int i;
    for(i=0;i<L.listLen;i++) 
        if (L.data[i]==x) 
            return i+1;  //数组的下标比元素序号少1
    return 0;   //如果找到了x从上个return语句返回；
                //执行到此，说明没有找到x，所以返回0.
}

插入运算

插入之前首先判断当前长度是否已经达到最长，如果没有，再判断索引是否合法，都没有问题的话，就通过后移元素插入，最后再将长度加一。

int listInsert(seqList *L, elementType x, int i)
{	int j;
	if(L->listLen==MaxLen)
		return 0;  //空间满
	else if(i<1 || i>L->listLen+1)
		return 1;  //序号超出范围
	else
	{	for(j=L->listLen-1; j>=i-1; j--)
		     L->data[j+1]=L->data[j];  //后移元素
		L->data[i-1]=x;  //插入元素x
		L->listLen++;    //长度增1
		return 2;
     }
}

删除元素

首先判断表是否是空表，然后再判断索引是否合法，最后通过前移删除指定位置的元素，最后记得将长度减一。

int listDelete(seqList *L, int i )
{	int j;
	if(L->listLen<=0)    
		return 0; //空表，返回值0
	else if(i<1 || i>L->listLen)
		return 1;  //删除的序号不在有效范围内
	else
	{    
		for(j=i; j<L->listLen; j++ )
			L->data[j-1]=L->data[j]; //循环前移表元素
		L->listLen--;  //修改表长度
		return 2;  //成功删除，返回值2.
	}
}

2链表

单链表的结构体

typedef struct  LNode
{    
	elementType   data;   // 数据域
    struct LNode* next;   // 指针域，结构（节点）自身引用                                       
} node, *linkList;  //“;”不能省略

带头结点的单链表运算实现

初始化链表

使用“引用”从子函数往主函数传递创建的链表。L是一个node*类型的数据，如果没有引用，子函数的操作不会影响到主函数。

void initialList(node * &L)
{        
		//申请内存产生头结点，OS根据内存使用情况,      
          //确定节点在内存中的位置，即：L的值。
          //所以，L在使用new node 前后值会不同      
      L=new node;     //或L=(node*)malloc(sizeof(node));
      L->next=NULL;  //next 域为空
}

求链表的长度

从头结点的后一个结点开始，遍历链表，每经过一个结点len加一，即可记录结点个数。

int listLength(node* L)
{  
   int len=0;  //保存长度值
   node *p=L->next;  //p指向第一个元素节点
   while(p!=NULL)
   {  
      len++;  //p!=NULL说明存在元素节点，计数加1
      p=p->next;  //p的指向后移一个节点
   } 
   return len;   //返回总计数值，即长度 
}

按序号取元素

从头结点的下一个结点开始，移动序号次即可得到目标元素。但要注意是否已经到达表尾。

node* getElement(node *L, int i) 
{
    node* p=L->next;
    int j=1;    //从1号元素开始搜索。
    while( (j!=i) && (p!=NULL) )   //当前节点不是目标节点，             
                                        //又不为空，继续处理下一个节点
    {   
    	p=p->next;
        j++;
    }
    
    return p;  //当j==i时，p为目标节点；
               //否则p==NULL，序号超出范围，取元素失败。
}

按元素值查找元素

遍历查找，注意是否到达表尾。

node* listLocate(node *L, elementType x, int* j)
{
    node *p=L->next;	(*j)=1;
    while((p!=NULL) && (p->data!=x))  
    {    
        p=p->next;
         (*j)++;  //元素序号加1。
    }
    if (p==NULL)   //如果p为空指针，
	    (*j)=0;           //元素x不在链表中，(*j)=0
    return p;
} 

插入节点算法

注意首先遍历到指定位置的前一个，然后如图思路插入结点。

bool listInsert(node* L, int i, elementType x )
{	
	node* p=L;
	node* S;
	int k=0;
	while(k!=i-1 && p!=NULL)
	{     //搜索ai-1节点指针	
	    p=p->next;           //p指向下一个节点
		k++; 	
	}
	if(p==NULL)
		return false;    //i超范围，不能插入，
	else    
	{      //此时，k=i-1，p为a1-1节点的指针
		 S=new node;           // 创建一个新节点
		 S->data=x;               //装入数据
		 S->next=p->next;    //插入新节点
		 p->next=S;
         return true;             //正确插入，返回true
	}
}

删除结点算法

bool listDelete( node* L, int i )
{ 	  
	node* u;
	node* p=L;
	int k=0;
	while(k!=i-1 && p!=NULL)
	{    //搜索ai-1节点
		p=p->next;
		k++;
	}
	if(p==NULL || p->next==NULL)
	  return false;  //删除位置 i 超出范围，删除失败，返回false
	else
	{                      //此时，p指向ai-1
	  u=p->next;              //u指向待删除节点 ai
	  p->next=u->next;   //ai-1的next指向ai+1节点，
	                                  //或为空（ai-1为最后节点）
	  delete u;  //释放删除节点占据的控件，此句必须，
	                 //否则这个节点的内存将称为垃圾内存(内存泄漏)
	  return true;   //删除成功，返回true
	}
}

头插法

头插法为倒序插入。

void createListH( node *& L ) 
{	L= new node;
	L->next=NULL;  //产生头结点
	cin >> x;
	while(x != End_of_Symbol ) 
    {   
    	u = new node;   u->data=x;   //产生元素节点
	    u->next=L->next;
	    L->next=u;   //头结点后接入新结点
	    cin>>x;
	}
}

尾插法

尾插法的关键是保留尾结点指针R，使快速定位到表尾。

void createListR (node * & L)   {
		L=new node;   //申请头结点
		R=L;                 //尾指针
		cin>>x;
		while(x!=End_of_Symbol)  {
		    u=new node;   u->data=x;
		    R->next=u;  //接入新结点
		    R=u;            //修改尾指针
		    cin>>x;
		}
		R->next=NULL;	 //这一句有没其他实现方式？
}

销毁链表

遍历链表，逐个销毁。注意这个必须传引用，因为最后要给L复制NULL。

void destroyList( node* & L )
{
	  node *p,*pTemp;
	  p=L;
	  while(p)
	  {
		    pTemp=p->next;
		    delete(p);      //或：free(p);
		    p=pTemp;
	  }
	  L=NULL;
}