从顺序表到串的线性表知识体系【数据结构】

最新推荐文章于 2021-12-20 19:39:21 发布
最新推荐文章于 2021-12-20 19:39:21 发布
阅读量273 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 队列 算法 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liudachu/article/details/105712352
版权

线性表


线性表主要由顺序表示或链式表示。在实际应用中，常以栈、队列、字符串等特殊形式使用

定义

线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。

存储结构

顺序表(顺序表示)

1.定义顺序表

typedef struct Sqlist{
   Elemtype *elem;
   int length;
   int listsize;
}Sqlist; //定义顺序表

2.初始化顺序表

Status InitSqlist(Sqlist &L){
     //初始化顺序表 
    L.elem=(Elemtype *)malloc(List_init_size*sizeof(Elemtype));
    if(!L.elem)exit(OVERFLOW);//exit  退出系统 
    L.length=0;//清空顺序表长度 
    L.listsize=List_init_size;//初始存储容量 
    return OK;
}

3.插入操作

Status SqlistInsert(Sqlist &L){
       //插入运算 
    printf("请输入插入数据的位置\n");
    int i; 
    scanf("%d",&i);
    while(i<1||i>L.length+1){
    	if(i<1||i>L.length+1==0)break;
        int i2;
		printf("error:插入位置错误\n请重新输入插入的位置：\n");	 
	    scanf("%d",&i2);
	    i=i2;
	}
    if(L.length>=L.listsize)
    {
      Elemtype *newbase;
      newbase=(Elemtype *)realloc(L.elem,LISTNCREMENT*sizeof(Elemtype));
      if(!newbase)return ERROR;
      L.elem=newbase;
      L.listsize+=LISTNCREMENT;
    }
       printf("请输入该学生数据\n");
   Elemtype e;
   scanf("%s%s%d",e.no,e.name,&e.score);
    Elemtype *p,*q;
    q=&(L.elem[i-1]);//指向插入位置i 
    for(p=&(L.elem[L.length-1]);p>=q;--p)
    *(p+1)=*p;//从最后一个元素开始往后移，移至第i个位置 
    *q=e;
    ++L.length;
    return OK;
}

4.删除操作


Status DeleteSqlist(Sqlist &L){
      //删除运算 
       printf("请输入要删除数据的位置\n");
   int i; 
   scanf("%d",&i);
   Elemtype e; 
   while(i<1||i>L.length){
    	if(i<1||i>L.length==0)break;
        int i2;
		printf("error:删除位置错误\n请重新输入删除的位置：\n");	 
	    scanf("%d",&i2);
	    i=i2;
	}  
   e=L.elem[i-1];
   Elemtype *p,*q;
   q=&L.elem[i];
   for(p=q;p<=&L.elem[L.length-1];p++){*(p-1)=*p;}
   L.length--;
   return OK;
}

5.查找操作

Status SearchSqlist(Sqlist &L){
	//查找运算 
   char g[12];
   printf("请输入要查询的学生的学号\n");
   scanf("%s",g);
   int i=0,j;
  for(j=0;j<=L.length-1;j++){
  	if(strcmp(g,L.elem[j].no)==0)printf("该学生信息为：\n%s\t%s\t%d\n",L.elem[j].no,L.elem[j].name,L.elem[j].score);
  	else 	 i++;
  }	
  if(i==L.length){
  printf("error:该学生不存在\n请重新输入要查询的学生：\n");
  SearchSqlist(L);
  }
  return OK;
}

链表(链式表示)

单链表

1.定义结点类型

typedef struct LNode{
	//定义结点类型
	ElemType data;//数据域 
	struct LNode* next;//指针域 (递归定义数据类型)
}LNode;

2.定义链表

typedef LNode* LinkList; //定义链表类型,节点类型的指针类型就是链表

3.初始化链表

Status InitLNode(LinkList &L){
	//初始化空链表 
	L=new LNode;//相等于L=(LNode *)malloc(sizeof(LNode));
	L->next=NULL;
	if(!L)return 0;
	return OK;
}

4.插入操作

Status InsertLinkList(LinkList &L,int i,ElemType e){
	//向第i个位置之前插入一个结点
	int length=GetLength(L); 
	if(i<1||i>length+1)exit(ERROR);	
	LinkList p,q;
	p=L;//p指向头节点 
	int j=1;
	while(p && j<i){//p指向第i个元素前驱的时候停止 
		p=p->next;
		++j;
	}
	//InitLNode(q);
	q=new LNode;
	q->data=e;
	q->next=p->next;//新插入的元素的指针指向原来第i个元素 
	p->next=q;//第i-1个元素的指针指向新插入的元素 
    printf("插入成功！\n");
    return OK;

5.删除操作

Status Delete(LinkList &L,int i,ElemType &e){
	//删除第i个元素 
	int length=GetLength(L); 
	if(i<1||i>length)exit(ERROR);	
	LinkList p,q;
	p=L;
	int j=1;
	while(p && j<i){//p指向第i个元素前驱的时候停止 
		p=p->next;
		++j;
	}
	q=p->next;
    e=q->data;//保存要删除的元素 
    p->next=q->next;//第i-1个元素指向第i+1个元素 
    printf("删除成功！\n");
    return OK;
}

6.查找操作

Status GetElem(LinkList L,int i,ElemType &e){
	//读取第i个元素的值
	int length=GetLength(L); 
	if(i<1||i>length)exit(ERROR);	
	LinkList p;
	p=L->next;
	int j=1;
	while(p && j<i){//p指向第i个元素前驱的时候停止 
		p=p->next;
		++j;
	}
    e=p->data;
    return OK;
}

7.创建含有n个结点的链表 (头插法)

Status CreatList_T(LinkList &L,int n){//创建含有n个结点的单链表 (头插法)    
	for(int i=0;i<n;i++){
		LinkList p; 
		p=new LNode;//创建一个新的结点类型，p指向该空间，p就是该结点 
		printf("请输入数据\n");
		scanf("%d",&p->data);
		p->next=L->next;//新节点的后驱为上一个节点 
		L->next=p;//记录新结点的位置 
	}
}

8.创建含有n个结点的单链表 (尾插法)

Status CreatList_W(LinkList &L,int n){//创建含有n个结点的单链表 (尾插法)
    LinkList r;
    r=L;//尾指针指向头结点 
    for(int i=0;i<n;i++){
		LinkList p; 
		p=new LNode;//创建一个新的结点类型，p指向该空间，p就是该结点 
		printf("请输入数据\n");
		scanf("%d",&p->data);
		p->next=NULL;//新结点的指针指向为空 
		r->next=p; //尾结点指向新的结点 
		r=p;//记录新结点的位置，新节点就成为尾结点 
	}
}

实际应用

栈、

栈

顺序栈
1.定义顺序栈

 typedef struct SqStack{
        ElemType *base;    //栈底指针
        ElemType *top;     //栈顶指针
        int stacksize;     //栈可用的最大容量
    }SqStack;
  1. 初始化顺序栈
Status InitStack(SqStack &S)
    {
        S.base=new ElemType[NUM]//为顺序栈分配一个最大容量为NUM的数组空间
        if(!S.base)return 0;    //存储分配失败
        S.top=S.base;           //top初始为base  ,空栈
        S.stacksize=NUM;         //stacksize设置为栈的最大容量NUM
        return 1;
     }
  1. 顺序栈的入栈
 Status Push(SqStack &S,ElemType e){
       if(S.top-S.size==S.stacksize){//栈满
       S.base=(ElemType*)realloc(S.base,sizeof(ElemType)*S.stackszie*2)
       if(!S.base)return 0;
       S.top=S.base;
       S.stacksize*=2;
       }
     *S.top=e;
     S.top++;
     return 1;
    }
  1. 顺序栈的出栈
 Status Pop(Sqstack &S,ElemType &e){
        if(S.top==S.base)return 0;//栈空
        S.top--;     //因为top指针一般指向下一个空间
        e=*S.top;
        return 1；
    }

5 取顺序栈的栈顶元素

  Staus    GetTop(SqStack &S){
       //返回S的栈顶元素，不修改栈顶指针
       if(S.top!=S.base)return *(S.top-1);//栈非空时执行
    }
  1. 求顺序栈的长度 S.top-S.base;
  2. 清空顺序栈 S.top=S.base;
  3. 销毁顺序栈
 Status DestroyStack(SqStack &S){
    if(S.base){
       free(S.base);
       S.stacksize=0;
       S.base=S.top=NULL;
    }
    return 1;
    }

链栈
1.定义链栈的结点和链表

typedef struct StackNode{
       ElemType data;
       struct StackNode *next;
    }StackNode;
    typedef StackNode* LinkStack;//定义链栈链表
  1. 链栈的初始化
 void InitStack(LinkStack &S)
    {
        S=NULL;
    }

3.判断链栈是否为空

Status StackEmpty(LinkStack &S)
    {
      if(!S)return 0;
      return 1;
    }
  1. 链栈进栈
 Status Push(LinkStack &S,ElemType e)
    {
        p=(LinkStack)malloc(sizeof(StackNode))
        if(!p)return 0;
        p->data=e;
        p->next=S;
        S=p;
        return 1;
    }
  1. 链栈出栈
  Status Pop(LinkStack &S,ElemType e)
    {
       if(!S)return 0;//栈空
       e=S->data;
       LinkStack p;
       p=S;
       S=S->next;
       delete p;//p=S指向栈顶，delete p,删除该栈顶空间 
       return 1;
    }
  1. 取栈顶元素
   Status GetTop(StackList &S){
       if(!S)return 0;//栈空
       return S->data;
    }

队列、

队列是一种先进先出的线性表，它只允许在表的一端进行插入，而在另一端删除元素。
队列

循环队列-------队列的顺序表示
1.定义顺序队列

  typedef struct
        {
           QElemType *base;//存储空间的首地址
           int front;//头指针
            int rear;//尾指针
        }SqQueue;
  1. 初始化顺序队列
  Status InitQueue(SqQueue &Q)
       {
           Q.base=new QElemType[MAXSIZE];//为队列分配一个最大容量为MAXSIZE的数组空间
           if(!Q.base)exit(OVERFLOW);//分配空间失败
           Q.front=Q.rear=0;//头指针和尾指针置为零，队列为空
           return OK;
       }

3.求队列长度

 int QueueLength(SqQueue Q)
       {
          return(Q.rear-Q,front+MAXQSIZE)%MAXQSIZE; //少用一个存储空间
       }
  1. 入队
   Status EnQueue(SqQueue &Q,QElemType e)
       {
            if((Q.rear+1)%MAXQSIZE==Q.front)//少用一个存储空间,表明队满
            return ERROR;
            Q.base[Q.rear]=e;  //新元素插入队尾
            Q,rear=(Q.rear+1)%MAXSIZE;//队尾指针加1
            return OK;
       }
  1. 出队
  Status DeQueue(SqQueue &Q,QElemType &e)
      {
         if(Q.front==Q.rear)return ERROR;//队空
         e=Q.base[Q.front];//保存队头元素
         Q.front=(Q.front+1)%MAXSIZE//队头指针加1
         return OK; 
       }

6.取循环队列的队头元素

SElemType GetHead(SqQueue Q)
{//返回Q的队头元素，不修改队头指针
    if(Q.front!=Q.rear)//队列非空
         return Q.base[Q.front];//返回队头元素的值，队头指针不变
}

链队–队列的链式表现
1. 定义结点类型,结点指针类型

 typedef struct QNode{
        QElemType data;
        struct QNode *next;
      }QNode,*QueuePtr;

2.定义链队

  typedef struct{
            QueuePtr front；
            QueuePtr rear；
         }LinkQueue;

3.初始化链队

Status InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=new QNode;//生成新结点作为头结点，队头和队尾指针都指向此结点
    Q.front->next=NULL;//头指针的指针域置空
    return OK;
}

4.入队

    Status EnQueue(LinkQueue &Q,QElemType e)
	{
	      p=new QNode;//为入队元素分配结点空间
	      if(!p)exit(OVERFLOW);
	      p->data=e;
	      p->next=NULL;
	      Q.rear->next=p;//将新结点插入到队尾
	      Q.rear=p;//修改队尾指针
	      return OK;
	   }

5.出队

   Status DeQueue(LinkQueue &Q,QELemType &e)
   {
        if(Q.front==Q.rear)reurn ERROR;//队列为空
        p=Q.front->next;//p指向队头元素
        e=p->data;//保存队头元素的值
        Q.front->next=p->next;//修改头指针
        if(Q.rear==p)Q.rear=Q.front;//最后一个元素被删，队尾指针指向头结点
        delete p;//释放空间
        return OK;
    }

6.取队头元素
与循环队列一样，当队列非空时，此操作返回当前队头元素的值，队头指针保持不变

	SElemType GetHead(LinkQueue Q)
	{
		 if(Q.front!=Q.rear)//队列非空
		      return Q.front->next->data;//返回队头元素的值        
	}

7.销毁链队列

  Status DestroyQueue(LinkQueue &Q)
　　　　 {
            while(Q.front){
               Q.rear=Q.front->next;
               free(Q.front);
               Q.front=Q.rear;
            }
            return OK;
        }
  1. 判断链队是否为空
 Status QueueEmpty(LinkQueue Q)
  {
              return(Q.front==Q.rear);
  }

字符串、

一、存储结构
1.串的顺序存储：用一组地址连续的存储单元存储串值得序列。
typedef unsigned char SString[Maxsize];
SString S;
2.串的堆顺序存储结构：
typedef struct{
char *ch;//若是非空串，按串长分配空间；否则ch=NULL
int length;//串长度
}HString;
3.串的链式存储结构
#define CHUNSIZE 80//自定义块的大小
typedef struct Chunk{//定义块类型
char ch[CHUNSIZE];
struct Chunk *next;
}Chunk;
typedef struct{//定义串类型
Chunk *head,*tail;//串的头指针和尾指针
int length; //串的当前长度
}LString
二、串的模式匹配算法
BF算法

Status BF(Sstring S,SsTring T,int pos){
    int i,j=1;
    i=pos;
    while(i<S[0] && j<=T[0]){
       if(i<=S[0] && j<=T[0]){++i;++j;}
       else{i=i-j+2;j=1;}//回溯操作
    }
    if(j>T[0])return i-T[0];
    else return 0;
}

KMP算法

Status Index_KMP(SString S,SString T,int pos){
     i=pos;j=1;
     while(i<=s[0] && j<=T[0]){
      if(j==0 || s[i]==s[j]){++i;++j;}//不失配则继续比较后续字
      else{j=next[j];}//S的i指针不回溯，从T的k位置开始匹配  
     } 
     if(j>T[0])return i-T[0];//子串结束，说明匹配成功
     else return 0;     
}
void GetNext(String T,int next[]){
     int j,k;
     j=1;k=0;
     next[j]=k;
     while(j<T[0]){//T[0]表示字符串长度
       //当k=0时，j+1的next是k+1，即1；
       //当T[k]=T[j]   j+1的next是k+1
       if(k==0 || T[k]==T[j]){
           ++j;
           ++k;
           next[j]=k;
       }
       else
           k=next[k];
     } 
}
void GetNextVal(Sstring T,int nextval[]){
     int j=1,k=0;
     nextval[j]=k;
     while(j<T[0]){
        if(k==0 || T[j]==T[k]){
           j++;k++;
           if(T[j]!=T[k])
              nextval[j]=k;
           else
              nextval[j]=nextval[k];
        }
        else k=nextval[k];
     }
}
nextval[j]计算步骤  （1）计算出next[j] = k值，
                    （1.1）如果Tj = Tk ，nextval[j] = nextval[k]
                     (1.2) 如果Tj ！= Tk，nextval[j] = next[j] = k.
liudachu
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构_串_顺序结构(C语言)
小黯
07-22 1645
目录（一）串（二）串代码解析1、串的基本操作1.01 串的基本结构1.02 串的创建1.03 串的遍历1.04 串的匹配1.05 串的连接1.06 串的比较1.07 串的长度1.08 串的复制1.09 串的清空1.10 串的销毁2、串源代码及测试2.1 源代码：2.2 测试 （一）串 串的顺序结构和顺序表的结构一样， 串的区别仅仅是在顺序表数据类型的区别，串的数据类型是字符型， 接下来我将实现串的一些基本操作，其中一些基本操作类似于头文件< string >的内置函数 （二）串代码解析 1、
数据结构（顺序表，栈，队列，串，查找，排序）
最新发布
qq_43467170的博客
10-05 577
数据结构（顺序表，栈，队列，串，查找，排序）
动态存储分配（堆分配）的顺序串与顺序表在操作上的异同
qq_22583409的博客
10-14 3168
动态存储分配（堆分配）的顺序串与顺序表在操作上的异同串（string）（或字符串）是由零个或多个字符组成的有限序列，一般记为 s=‘a1a2...an’ (n>=0) 串的数据元素固定为字符型的线性表，因此串的逻辑结构和线性表极为相似，只不过对串的操作常常是以”串的整体”或“子串”作为操作对象，而线性表的操作大多以“单个数据元素”为操作对象。静态存储分配的
【数据结构基础】栈的链式存储结构
inf_lmg的专栏
01-08 316
链栈的结构代码： typedef struct StackNode { SElemType data; struct StackNode *next; }StackNode, *LinkStackPtr; typedef struct LinkStack { LinkStackPtr top; int count; }LinkStack;   链栈的进栈
链队列实现代码
玉面小fei龙的博客
07-24 830
#include &lt;stdio.h&gt; #define OK 1 #define ERROR 0 typedef struct QNode {     int data;     struct QNode *next; }QNode, *QueuePtr; typedef struct {     QueuePtr front;     QueuePtr rear; }LinkQu...
数据结构 第5章 数组和广义表.ppt
06-17
数据结构 第5章 数组和广义表 本章节主要讲述了数组和广义表的定义、顺序表示和...本章节对数组和广义表的定义、顺序表示和实现、矩阵的压缩存储等知识点进行了详细的讲解，为读者提供了一个系统的数据结构知识体系。
数据结构思维导图.pdf
10-09
数据结构是计算机科学中一个至关重要的基础概念，它涉及到如何有效地组织和管理数据，以便于高效地进行...在考研复习中，使用这样的思维导图可以帮助学生系统地梳理知识体系，加深对数据结构的理解，从而提高学习效果。
856数据结构与组成原理1
08-04
线性表是数据结构的基础，理解其逻辑结构，如顺序和链式存储是必要的。顺序存储结构是用数组实现线性表，便于连续访问，而链式存储结构使用指针链接元素，允许动态变化大小。栈是一种后进先出（LIFO）的数据结构，常...
856数据结构与组成原理2
08-04
数据结构是计算机科学中至关重要的一部分，它涉及到如何有效地组织和管理数据，以便于高效地进行存储和检索。在“856数据结构与组成原理2”这个课程中，重点涵盖了以下几个核心知识点： 1. **数据结构的基本概念和...
01-绪论和线性表1
08-04
线性表是数据结构中最基础且广泛使用的一种结构，它由若干个相同类型元素按照特定顺序排列组成。理解线性表有助于我们更好地设计和分析算法。 线性表的物理实现主要有以下几种： 1. C/C++ 数组：数组是最简单的...
考研408 数据结构 计算机组成原理 操作系统 计算机网络 考研思维导图
02-23
2. **线性表**：是最基础的数据结构，包括顺序表和链表，讨论它们的操作如插入、删除、查找等。 3. **栈和队列**：栈是后进先出（LIFO）结构，常用于表达式求值、递归等问题；队列是先进先出（FIFO）结构，常见于...
华科数据结构课件
02-01
这些课件为学生提供了全面的数据结构知识体系，涵盖了从基础到高级的各种数据结构及其操作方法，对于理解和掌握计算机科学的核心原理非常有帮助。通过学习，学生能够更好地设计和分析算法，解决实际问题。
数据结构讲稿(外)
10-15
这份“数据结构讲稿(外)”涵盖了多个关键主题，包括线性表、栈和队列、字符串、数组和稀疏矩阵、递归、树形结构、广义表、图、查找、内部排序、外部排序以及文件。以下是对这些主题的详细阐述： 1. **线性表**：...
数据结构 第二版 张世和 徐继廷
04-23
数据结构是计算机科学中一门重要的专业基础课，它主要研究非数值计算问题中数据之间的逻辑关系和存储方式。这门学科的诞生和发展源于程序设计的需求，...因此，数据结构是每一位程序员和计算机科学家必备的知识体系。
数据结构讲义 严蔚敏版 考研内部资料
02-27
3. **线性表**：包括顺序表和链表，它们是最基本的数据结构，用于存储线性序列的数据。 4. **栈和队列**：这两种特殊的线性结构，分别具有后进先出（LIFO）和先进先出（FIFO）的特性，广泛应用于各种计算问题。 5....
数据结构实验之队列一:排队买饭
weixin_34348805的博客
01-23 679
题目描述 中午买饭的人特多,食堂真是太拥挤了,买个饭费劲,理工大的小孩还是很聪明的,直接奔政通超市,哈哈,确实,政通超市里面也卖饭,有好几种菜,做的比食堂好吃多了,价格也不比食堂贵,并且买菜就送豆浆,吸引了不少童鞋。所以有时吧，人还是很多的，排队是免不了的，悲剧的是超市只有两个收银窗口。 问题是这样的：开始有两队人在排队，现在咱们只研究第一队，现在我们给每个人一个编号，保证编号各不相...
数据结构----线性表（基础使用）
Big_xbc的博客
03-23 109
算法基础 #线性表——顺序表的基础用法 #include<stdio.h> #include<malloc.h> #include<conio.h> #include<stdlib.h> #define LIST_INIT_SIZE 10 #define LISTNCREMENT 10 #define ERROR 0 #define OK 1 #define OVERFLOW -2 typedef struct{ int *elem; int len
学《数据结构》越学越聪明--第四章》》》串
qq_46163557的博客
12-20 1188
串 串的基本概念 串(或字符串)是由零个或多个字符组成的有限序列 串中所含字符的个数称为该串的长度（或串长），含零个字符的串称为空串。 相等串 当且仅当两个串的长度相等并且各个对应位置上的字符串都相同时，这两个串才是相等的 子串 一个串中任意个连续字符组成的子序列（含空串）称为该串的子串。 真子串是不包含自身的所以子串 串抽象数据类型=逻辑结构+基本运算 串的几种基本运算如下： StrAssign(&s,cstr):将字符串常量cstr赋给串s，即生成其值等于cstr的串s StrC..

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值