线性表——链表的定义和基本操作

带头结点的单链表实现代码

#include<stdio.h>
#include<cstdlib>
#include<iostream>
#define Maxsize 20
using namespace std;
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;
bool InitList(LinkList &L)
{
	L=(LNode*)malloc(sizeof(LNode)); //分配一个头结点 ，并将malloc 返回的地址赋给L，即L是指向头结点 
	if(L==NULL)
	   return false;
	L->next=NULL;
	return true; 
}
 bool Empty(LinkList L){
 	if(L->next==NULL)
 	  return true;
 	else
 	   return  false;
} 
//按位查找，返回第i个元素                平均时间复杂度 O(n) 
LNode * GetElem(LinkList L,int i) {
	if(i<0)            //边界情况处理 
		return NULL;
	LNode *p;  //指针p指向当前扫描到的结点 
	int j=0;    //将头结点看成第0个结点  
	p=L;   // L指向头结点，p指针当前指向头结点 
	while(p!=NULL&&j<i)  
	{                   //循环找到第i个结点 
		p=p->next;
		j++;
	 } 
	if(p==NULL)
		return false;
	return p;
} 
//按值查找，找到数据值等于e的结点       平均时间复杂度 O(n) 
LNode * LocateElem(LinkList L ,int e)
{
	LNode *p=L->next;  //指向第一个含数据的结点
	while(p!=NULL&&p->data!=e)
	{
		p=p->next;
	 } 
	return p;	
}
//求表长       平均时间复杂度 O(n) 
int Length(LinkList L)
{
	int len=0;
	LNode *p=L;
	while(p->next!=NULL)
	{
		p=p->next;
		len++;
	}
	return len;
}
/*
  后插操作 
在第 i个位置插入元素e（带头结点）
步骤1： 循环找到第 i-1个结点
步骤2： 在p结点之后插入元素e 
*/ 
bool InserNextNode(LNode *p,int e)
{
	if(p==NULL)
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));//申请一个新的结点空间 
	if(s==NULL) //内存分配失败
		return false;
	s->data=e;  //用结点s保存数据元素e 
	s->next=p->next;
	p->next=s;      //将结点s连到p之后 
	return true; 
 } 
bool ListInsert(LinkList &L,int i,int e)  //平均时间复杂度 O(n) 
{
	if(i<1)       //边界情况处理 
		return false;
	
	 LNode *p=GetElem(L,i-1);  //调用查找函数找到第i-1个结点 
	 	
	/*  循环找到第 i-1个结点  上面为直接调用，下面是直接实现代码
	int j=0;   //将头结点看成第0个结点 
	LNode *p; //定义指针p指向当前扫描到的结点 
	p=L;
	if(p!=NULL&&j<i-1)   
	{
		p=p->next;
		j++;
	}*/
		
	return InserNextNode(p,e);  //调用后插函数在p后插入新元素e 
	
	/*  将结点s连到 p之后, 上面为直接调用，下面是直接实现代码
	if(p==NULL)   //i值不合法 ,没有找到第i-1个结点，后插操作失败 
	   return false; 
	LNode *s=(LNode*)malloc(sizeof(LNode));  //申请一个新的结点空间 
	s->data=e;
	s->next=p->next;    // 将结点s连到 p之后
	p->next=s;	
	return true; */
	
}
/*
删除表 L 中第i个位置的元素，并用e返回删除元素的值
找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点 

*/ 
bool ListDelete(LinkList &L,int i,int &e)
{
	if(i<1)
		return false;
	LNode *p=GetElem(L,i-1);  //调用查找函数找到第i-1个结点 
    /*  循环找到第 i-1个结点  上面为直接调用，下面是直接实现代码
	LNode *p;
	int j=0;
	p=L;
	while(p!=NULL&&j<i-1){
		p=p->next;
		j++;
	}*/ 	
		
	if(p==NULL)
		return false;
	LNode *q=p->next;
	e=q->data;
	p->next=q->next;
	free(q);
	return true;	
}
/*
删除指定结点p   这里需思考一下，将后面的值覆盖到p结点，虽然释放了q的空间，但实际相当删除了p结点 
覆盖值，将指针指向下一个结点，释放空间 
*/
bool DeleteNode(LNode *p)
{
	if(p==NULL)
		return false;
	LNode *q=p->next;  //令q指向*p的后继结点
	p->data=p->next->data;   //将q结点的值覆盖在p结点上
	p->next=q->next;   //将*q结点从链中断开 
	free(q);         //释放q结点的存储空间 
	return true; 
 } 
void Show(LinkList L)
{
	LNode *p=L->next;
	while(p!=NULL)
	{
		printf("%d ",p->data); 
		p=p->next;
	} 
	printf("\nLength: %d\n",Length(L)); 
}
int main()
{
	LinkList L; //声明一个指向单链表的指针 
	InitList(L);  //初始化单链表 
	ListInsert(L,1,1);   //插入时i的值很可能不合法 
	ListInsert(L,2,2);
	ListInsert(L,3,3);
	ListInsert(L,4,4);
	ListInsert(L,1,5);
	Show(L);
	int e=-1;
	if(ListDelete(L,1,e))
	   printf("已删除第1个元素，删除元素值为 %d，删除后链表为：\n",e);
	else
	  printf("删除位序不合法，删除失败\n"); 
	Show(L);
	
	DeleteNode(GetElem(L,1));//在现有链表上继续删除第一个元素
	printf("已删除第1个元素,删除后链表为：\n");
	Show(L); 
	LNode *p1=GetElem(L,2);
	printf("顺序表L中位置为2的元素为 %d\n",p1->data);
	return 0;
}
 

代码运行结果