顺序表、单链表、顺序栈，链栈的基本运算

最新推荐文章于 2024-08-08 15:12:59 发布

hi！AaA

最新推荐文章于 2024-08-08 15:12:59 发布

阅读量222

点赞数 3

文章标签：算法数据结构

本文链接：https://blog.csdn.net/2202_75519246/article/details/140858298

版权

线性表的9个基本运算：

栈的6个基本运算：

顺序表的基本运算

//顺序表的基本运算**************************************************************
#include<stdio.h>
#include<malloc.h>
#define MaxSize 100
typedef int ElemType;	 
typedef struct 
{
    ElemType data[MaxSize];  //存放数据表元素
    int length;             //存放顺序表的长度
    /* data */
}SqList;

//创建顺序表**********************************************************************
void CreateList(SqList *& L,ElemType a[],int n)
{  	
    L =(SqList *)malloc(sizeof(SqList));
    for(int i=0;i<n;i++){
        L->data[i]=a[i];		//将数组a中的每个元素依次放入顺序表 
    }
    L ->length =n;
}

 //初始化顺序表**********************************************************************
void InitList(SqList *& L){   
    L =(SqList *)malloc(sizeof(SqList));		//分配顺序表空间 
    L ->length =0;
}

 //释放顺序表**********************************************************************
void DestoryList(SqList *&L){  
    free(L);
}

//判断顺序表是否为空，返回值bool类型 **********************************************
bool ListEmpty(SqList *& L){ 
   return (L->length ==0);
}

 //求顺序表的长度**********************************************************************
int ListLength(SqList *L){  
    return  L->length;
}

 //输出顺序表***************************************************************************
void DisList(SqList *L){   
    //printf("调用输出\n");
    for(int i=0;i<L->length;i++){
        printf("%d",L ->data[i]);		//for循环依次输出 
    }
    printf("\n");
}

 //获得线性表第i个元素********************************************************************
bool GetElem(SqList *L,int i,ElemType &e){  
    if(i<1||i>L->length){
        return false;       //判断i是否合理
    }
    e =L->data[i-1];		//数组从0开始，故i-1 
    return true;
}

 //求e的位置**********************************************************************
int LocateElem(SqList *L,ElemType e) { 
    int i=0;
    while (i<L->length &&L->data[i]!=e)
    {
        i++;
    }
    if(i>=L->length){			//若超出范围，返回0 
        return 0;
    }else {
        return i+1;
    }
    
}

 //插入e，在顺序表第i个位置插入元素e ***************************************************************
bool ListInsert(SqList *&L,int i,ElemType e){ 
    int j;
    if(i<1||i>L->length+1||L->length ==MaxSize){ //参数i不合理以及顺序表（静态）已满 时返回false 
        return false;
    }
    i--;
    for(j =L->length;j>i;j--){		//将第i个位置及之后的元素都向后移一个位置 
        L->data[j]=L->data[j-1];
    }
    L->data[i]=e;
    L->length++;			//数组长度加1 
    return true;
}

  //删除第I个值*****************************************************************************
bool ListDelete(SqList *&L,int i,ElemType e){
    int j;
    if(i<1||i>L->length){		//参数不合理时返回false 
        return false;
    }
    i--;					
    e=L->data[i];				//用e接受被删除的值 
    for(j=i;j<L->length;j++){		//将i之后的元素前移一个位置 
        L->data[j]=L->data[j+1];
    }
    L ->length--;				//长度减1 
    return true;
}

int main(){
    SqList *L;
    ElemType e;
    printf ("\n");
    printf("顺序表的基本运算如下\n");
    printf("    (1)初始化顺序表\n");
    InitList(L);
    printf("    ((2)依次插入a,b,c,d,e\n");
    ListInsert(L,1,'a');
    ListInsert(L,2 ,'b');
    ListInsert(L,3,'c');
    ListInsert(L,4,'d');
    ListInsert(L,5,'e');
    printf("    (3)输出顺序表L：\n");
    DisList(L);
    printf("    (4)顺序表L的长度：%d\n ",ListLength(L));
    printf("    (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));
    GetElem(L,3,e);
    printf("    (6)顺序表的第3个元素的：%c\n",e);
    printf("    (7)元素a的位置：%d\n",LocateElem(L,'a'));
    printf("    (8)在第4个元素位置上插入f元素\n");
    ListInsert(L,4,'F');
    printf("    (9)输出顺序表L:");
    DisList(L);
    printf("    (10）删除顺序表第3个元素\n");
    ListDelete(L,3,e);
    printf("    (11)输出顺序表：\n");
    DisList(L);
    printf("    (11)释放顺序表\n");
    DestoryList(L);
    return 1;
}

单链表的基本运算

//单链表的基本运算
#include<stdio.h>
#include<stdlib.h>
typedef char ElemType;	 
typedef struct LNode		//结构体，LinkNode类型声明 
{
    ElemType data;
    struct LNode *next;
} LinkList,LinkNode;
//建立单链表有两种方法，1.头插法 2.尾插法 **********************************************************************
//使用头插法
void CreateListF(LinkList *&L,ElemType a[],int n)	//将数组a的元素依次放入链表中 
{
    LinkList *s;
    L=(LinkList *)malloc(sizeof(LinkList));	//L头结点（作用：使链表中首节点的插入，删除操作与其他节点一致） 
    L->next=NULL;
    for(int i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        s->next=L->next;
        L->next=s;
    }
}
//使用尾插法(将新插入的尾节点设为r)
void CreateListR(LinkList *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    L=(LinkList *)malloc(sizeof(LinkList));
    r=L;
    for(int i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        r->next=s;
        r=s;				 
    }
    r->next=NULL;
}
//初始化线性表**********************************************************************
void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;			//创建头结点，next指向null（顺序表初始化是让length为0） 
}
//销毁线性表（逐一销毁，从头销到尾）********************************************************* 
void DestroyList(LinkList *&L)
{
    LinkNode *pre=L,*p=L->next;
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
}
//判断线性表是否为空表**********************************************************************
bool ListEmpty(LinkList *L)
{
    return (L->next==NULL);
}
//求线性表的长度**********************************************************************
int ListLength(LinkList *L)
{
    int n=0;
    LinkList *p=L;
    while(p->next!=NULL)	//结束标志 
    {
        n++;
        p=p->next;
    }
    return (n);
}
//输出线性表**********************************************************************
void DispList(LinkList *L)
{
    LinkList *p=L->next;
    while(p!=NULL)
    {
        printf("%c",p->data);
        p=p->next;
    }
    printf("\n");
}
//求线性表中某个数据元素值**********************************************************************
bool GetElem(LinkList *L,int i,ElemType &e)		//从单链表L中找到第i个结点，将其data值赋给e 
{
    int j=0;
    LinkNode *p=L;
    while(j<i&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        e=p->data;
        return true;
    }
}
//按元素值查找**********************************************************************
int LocateElem(LinkList *L,ElemType e)
{
    int i=1;
    LinkList *p=L->next;
    while(p!=NULL&&p->data!=e)
    {
        p=p->next;
        i++;
    }
    if(p==NULL)
        return (0);
    else
        return(i);
}
//插入数据元素**********************************************************************
bool ListInsert(LinkList *&L,int i,ElemType e)	//在第i个位置插入元素e 
{
    int j=0;
    LinkList *p=L,*s;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }
 
}
//删除数据元素**********************************************************************
bool ListDelete(LinkList *&L,int i,ElemType &e)		//删除第i个位置，并将其值赋给e 
{
    int j=0;
    LinkList *p=L,*q;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        q=p->next;
        if(q==NULL)
            return false;
        e=q->data;
        p->next=q->next;
        free(q);
        return true;
    }
}
 
int main()
{
    LinkList *L;
    char s[5]= {'a','b','c','d','e'};
    char e;
    int i,j;
    InitList(L);//初始化单链表
    CreateListR(L,s,5);//使用尾插法建立单链表
    DispList(L);//输出单链表
    ListLength(L);//求单链表的长度
    i=ListEmpty(L);
    if(i==0)
    {
        printf("该单链表不为空\n");
    }
    else
    {
        printf("该单链表为空\n");
    }
    ListInsert(L,4,'f');//插入元素f到第四个元素
 
    DispList(L);//输出线性表L
    ListDelete(L,3,e);//删除第三个元素
    DispList(L);//输出单链表L
    DestroyList(L);//销毁释放单链表
}

顺序栈的基本运算

//顺序栈基本运算算法
#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct 				
{	
	ElemType data[MaxSize];
	int top;				//栈指针
} SqStack;					//顺序栈类型
 
 //(1)初始化栈********************************************************** 
void InitStack(SqStack *&s)
{
	s=(SqStack *)malloc(sizeof(SqStack));		//分配一个顺序栈空间 
	s->top=-1;
} 
 
 //(2)销毁栈*********************************************************** 
void DestroyStack(SqStack *&s)
{
	free(s);
}
 
 //(3)判断栈是否为空 *********************************************************** 
bool StackEmpty(SqStack *s)
{
	return(s->top==-1);
}
 
 //(4)进栈***********************************************************  
bool Push(SqStack *&s,ElemType e)
{
	if (s->top==MaxSize-1)    //栈满的情况，即栈上溢出
		return false;
	s->top++;
	s->data[s->top]=e;
	return true;
}
 
 //(5)出栈***********************************************************  
bool Pop(SqStack *&s,ElemType &e)
{
	if (s->top==-1)		//栈为空的情况，即栈下溢出
		return false;
	e=s->data[s->top];
	s->top--;
	return true;
} 
 
 //(6)获取栈顶元素***********************************************************  
bool GetTop(SqStack *s,ElemType &e)
{
	if (s->top==-1) 		//栈为空的情况，即栈下溢出
		return false;
	e=s->data[s->top];
	return true;
}
 
int main()
{	
	ElemType e;
	SqStack *s;
	char ch[5]={'a','b', 'c','d','e'};
	int i=0;
	int length =5;
	printf("\n");
	printf(" (1)初始化栈\n");
	InitStack(s);
	printf(" (2)栈为%s\n",(StackEmpty(s)?"空":"非空"));
	printf(" (3)依次进栈元素a,b,c,d,e\n");
	while(i<length)
	{	Push(s,ch[i]);
		i++;
		}	
		
	printf(" (4)栈为%s\n",(StackEmpty(s)?"空":"非空"));
	printf(" (5)出栈序列：");
	while(!(StackEmpty(s)))
	{
		Pop(s,e);
		printf(" %c ",e);
	}
	printf("\n");
	printf(" (6)栈为%s\n",(StackEmpty(s)?"空":"非空"));
	printf(" (7)销毁栈\n");
	DestroyStack(s);
	
}

链栈的基本运算

#include<stdio.h>
#include<malloc.h>
typedef char ElemType;
typedef struct linknode
{
 	ElemType data;			
 	struct linknode *next;
}LiStack;				//链栈节点类型 

//初始化栈（创建头节点，将其next值赋null） **********************************
void InitStack(LiStack *&s)
{
 s=(LiStack*)malloc(sizeof(LiStack));
 s->next=NULL;
} 

//销毁栈（与单链表销毁算法完全一致，逐一销毁） *********************************
void DestroyStack(LiStack *&s)
{
 LiStack *p=s,*q=s->next;
 while(q!=NULL)
 {
  free(p);
  p=q;
  q=p->next;
 }
 free(p);
}

//判断栈是否为空********************************************************* 
bool StackEmpty(LiStack *s)
{
 return (s->next==NULL);
}

//进栈***************************************************************** 
//新建一个节点，将其插入到头节点之后作为新的首节点 
void Puch(LiStack *&s,ElemType e)
{
 LiStack *p;
 p=(LiStack*)malloc(sizeof(LiStack));
 p->data=e;
 p->next=s->next;
 s->next=p;
}

//出栈*******************************************************************
//在栈不为空的前提下提取首节点的值给e，然后将其删除 
bool Pop(LiStack *&s,ElemType &e)
{
 LiStack *p;
 if(s->next==NULL)
  return false;
 p=s->next;
 e=p->data;
 s->next=p->next;
 free(p);
 return true;
}

//获取栈顶元素 
bool GetTop(LiStack *s,ElemType &e)
{
 if(s->next==NULL)
  return false;
 e=s->next->data;
 return true; 
}

int main()
{
 ElemType e;
 LiStack *s;
 printf("栈的基本运算如下：\n");
 printf("(1)初始化栈s\n");
 InitStack(s);
 printf("(2)栈为%s\n",(StackEmpty(s)?"空":"非空"));
 printf("(3)依次进栈的元素为a,b,c,d,e\n");
 Puch(s,'a');
 Puch(s,'b');
 Puch(s,'c');
 Puch(s,'d');
 Puch(s,'e');
 printf("(4)栈为%s\n",StackEmpty(s)?"空":"非空");
 printf("(5)出栈序列:");
 while(!StackEmpty(s))
 {
  Pop(s,e);
  printf("%c",e);
 }
 printf("\n");
 printf("(6)栈为%s\n",(StackEmpty(s)?"空":"非空"));
 printf("(7)释放栈\n");
 DestroyStack(s);
 return 0; 
}