数据结构——线性表算法题

1. 在第4个元素之前插入元素25（顺序表）。
   思想:
   ① 将第 n 到 i 个元素均向后移动一个位置
   ②将新元素放置在第 i 个位置

Status  ListInsert_Sq ( Sqlist  &L ，int  i ，ElemType  e )  {
	if  ( i < 1 || i > L.length +1 )  return  ERROR ；
	if  ( L.length >= L.listsize )     // 越界处理 
		q = & ( L.elem[i-1]) ；
	for  ( p = & L.elem[L.length-1] ；p >= q ；- - p )
		* (p+1) = * p ；  // 后移元素
	* q = e ；  // 插入新元素
	++L.length ；
	return  OK ；
}
//越界处理
if  ( L.length >= L.listsize )  {
	newbase = ( ElemType * ) realloc ( L.elem , ( L.listsize + LISTINCREMENT ) * sizeof(ElemType) )；
	if  ( ! newbase )  exit(OVERFLOW) ；
	L.elem = newbase ;
	L.listsize += LISTINCREMENT ;
}

2. 删除第4个元素25，
   思想:
   ①保存第 i 个数据元素
   ② 将第 i+1 到 n 个元素均向前移动一个位置。

Status  ListDelete_Sq ( Sqlist  &L ，int  i ，ElemType  &e ) {
	if  ( i < 1 || i > L.length )  return  ERROR ;
	p = & ( L.elem[i-1]) ；
	e = * p ；   // 取第 i 个元素的值
	q =& L.elem[ L.length–1] ；
	for  ( ++p；p <= q；++p )
		* (p - 1) = * p ； // 前移
	-- L.length；
	return  OK ；
}

3. 已知顺序表A，写一算法将其倒置

void reverse(SqList &A)    //顺序表的就地逆置{
     for(i=0, j=A.length-1;  iA.elem[j];
}

4. 取线性单链表第 i 个元素。
   时间复杂度O(n)

Status  GetElem_L ( LinkList  L，int  i，ElemType  &e )  {
	p = L->next ;
	j = 1 ;
	while ( p &&  j < i )  {
		p = p->next ;
		++j ;
	}
	if ( !p || j >i )   return  ERROR ;
	e = p->data ;
	return  OK ;
}

5. 在第 i 个数据元素之前插入一个新的元素

Status  ListInsert_L ( LinkList  &L ，int  i ，ElemType  e ) {
	p = L ；j =0 ； 
while   ( p  &&  j < i - 1 )  { p = p->next ；++j ；}//找到第 i 个结点的前驱结点
	if  ( ! p || j > i - 1 )  return  ERROR ；
	s = ( LinkList ) malloc ( sizeof (LNode) ) ；
	s->data = e ；//建立新结点
	s->next = p->next ;
	p->next = s ； //插入新结点
	return  OK ;
}

6. 删除第 i 个数据元素

Status  ListDelete_L ( LinkList  &L，int i，ElemType  &e ) {
	p = L；
	j = 0； 
	while   ( p->next &&  j < i - 1 )  {  p = p->next ；++j ；} //找到第 i 个结点的前驱结点
	if  ( ! p->next || j > i - 1 )  return  ERROR ；
	q = p->next ；
	p->next = q->next ；//删除第 i 个结点
	e = q->data ；
	free(q) ；
	return  OK ；
}

7. 从表头到表尾逆向构造一条完整的单链表。（头插法）

void    CreateList_L ( LinkList  &L，int  n )  {
	L = ( LinkList ) malloc ( sizeof (LNode) ) ;
	L->next = NULL ;//建立头结点
	for  ( i = n ； i > 0 ；--i )  {
	p = ( LinkList ) malloc ( sizeof (LNode) ) ;
	Scanf ( &p->data ) ;
	p->next = L->next ;
	L->next = p ;//在表头插入新结点
	}
}

8. 在单链表的尾部插入结点建立单链表（尾插法）

LinkList  Creat_LinkList(LinkList  &L, int n) {
	p =L = ( LinkList ) malloc( sizeof( LNode ));
	for  ( i = n;  i > 1; --i ) {      
        s= ( LinkList ) malloc( sizeof( LNode));   
        scanf( &s->data);
        p->next=s; 
        p=s; 
 	 }
	p->next=NULL;      //最后结点的指针域放空指针
	return L;
} 

9. 将两个有序单链表合并为一个有序单链表

void   MergeList_L (LinkList &La，LinkList &Lb，LinkList &Lc) {
	pa = La->next ;
	pb = Lb->next ; //分别指向第一个结点
 	Lc = pc = La ;
	while  ( pa && pb )  {
		if  ( pa->data <= pb->data )   {
			pc->next = pa ;
			pc = pa;
			pa = pa->next ;
			}else  {
			  pc->next = pb ;
			  pc = pb ;
			  pb = pb->next ;
			  } 
	}
	pc->next = pa ? pa : pb ;//处理剩余部分
	free (Lb) ;
}

10. 设计一个算法，通过一趟遍历在单链表中确定值最大的结点。

ElemType Max (LinkList &L ){
	if(L->next==NULL) return NULL;
	pmax=L->next; //假定第一个结点中数据具有最大值
	p=L->next->next;
	while(p != NULL ){//如果下一个结点存在
		if(p->data > pmax->data) pmax=p;
		p=p->next;
	}
	return pmax->data;
}

11. 已知 L 是带有头结点的单链表，写一算法将其倒置
    算法思路：
    依次取原链表中的每个结点，将其作为首元结点插入到头结点后，指针p用来指向当前结点。

void  reverse (Linklist L)
{ 
     LNode  *p, *q;
     p=L->next;                /*p 指向第一个数据结点*/
     L->next=NULL;       /*将原链表置为空表 H */  
    while (p)
    {  
           q=p->next;
            p->next=L->next;   
                                   /*将当前结点插到头结点的后面*/
            L->next=p;
            p=q;
   }
}

12. 已知 L 是不带有头结点的单链表，写一算法将其倒置。
    算法思路：
    依次取原链表中的每个结点，将其作为第一个结点插入到新链表中去，指针 p 用来指向当前结点。

void  invert(Linklist &L){
   Linklist  p ,q ,  r ;
   /* r: 已经处理（过去时）
	  p: 正在处理（现在时）
	  q: 将要处理（将来时）
   */
      r=L; 
      p=r->next ;
      while( p != NULL){
            q=p->next;
            p->next=r;
            r=p;
            p=q; 
     }
      L->next=NULL;
      L=r;
}

13. 例 取单链表第 i 个元素。

Status  GetElem_L ( LinkList  L，int  i，ElemType  &e )  {
   p = L->next ;
   j = 1 ;
   while   ( p &&  j < i )  {
       p = p->next ;
       ++j ;
   }
  if  ( !p || j >i )   return  ERROR ;
  e = p->data ;
  return  OK ;
}

14. 双向链表
    

//源代码见课本（数据结构_c语言版——严蔚敏）P36

//源代码见课本（数据结构_c语言版——严蔚敏）P37