就是那个数据结构

原创已于 2022-12-10 16:17:46 修改 · 209 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #链表

于 2020-11-29 21:34:52 首次发布

少年的肩应担负起草长莺飞和清风明月，女孩的眼应藏下星辰大海和万丈光芒

晚安之后，有时候想你想得睡不着，有时候不想你睡不着

数据结构的基本概念

待写。。。

线性表

顺序表

有n个元素的顺序表，第i个位置上插入一个元素需要移动表中n-i+1个数据元素，删除第i个文字上的数据元素需要移动表中n-i个元素

1.数据集合的描述

typedef struct
{
    DataType list[Maxsize];
    int size;
}SeqList;

2.初始化

void ListInitate(SeqList *L)
{
    L->size=0;
}

3.求当前数据元素个数

int ListLength(SeqList *L)
{
    return L->size;
}

4.插入数据元素

int ListInsert(SeqList *L,int i,Datatype x)
{
    int j;
    if(L->size==Maxsize)
        return 0;
    else if(i<0 || i>Maxsize)
        return 0;
    else{
        for(j=L->size-1;j>=i;j--)
            L->list[j+1]=L->list[j];
        L->list[i]=x;
        L->size+=1;      //元素个数加一不要忘记
        return 1;
    }
}

5.删除数据元素

int ListDelete(Sqlist *L,int i,DataType *x)
{
    int j;
    if(L->size==0)
        return 0;
    else if(i<0||i>Maxsize)
        return 0;
    else{
        *x=L->lisst[i]   //将被删除的元素保存到x中
        for(j=i;j<L->size;j++)
            L->list[j]=L->list[j+1];
        L->list[j]=NULL;
        L->size--;
        return 1;
    }
}

6.取出数据元素

int ListGet(SeqList L,int i,DataType *x)
{
    //此处省略对i不合法的判断
    *x=L->list[i];
    return 1;
}

向数据表中插入数据是，平均移动次数为n/2

删除一个元素平均移动次数为n-1/2

插入与删除操作时间复杂度均为O（n），其余均为O（1）

单链表

1.单链表结点

typedef struct Node
{
    DataType data;
    struct Node *next;
}SLNode;

2.初始化

void ListInitiate(SLNode **head)
{
    *head=(SLNode *)malloc(sizeof(SLNode));
    (*head)->next=NULL;
}

3.求当前数据元素的个数

int ListLength(SLNode *head)
{
    int size=0;
    SLNode *p=head;
    while(p)
    {
        size++;
        p=p->next;
    }
    return size;
}

4.在第i个数据元素前插入数据元素x

int ListInsert(SLNode *head,int i,DataType x)
{
    SLNode *p=head,*q;
    int j;
    while(p && j<=i-1)//找到i所在元素的前一个元素
    {
        p=p->next;
        j++;
    }
    if(j+1 !=i) //判断i是否合法
        return 0;
    q=(SLNode *)malloc(sizeof(SLNode));
    q->data=x;
    q->next=p->next;
    p->next=q;
    return 0
}

5.删除i位置的元素

int ListDelete(SLNode *head,int i,DataType *x)
{
    SLNode *p=head,*q;
    int j;
    //此处省略查找i元素之前的结点并判断i是否合法的代码
    *q=p->next
    *x=q->data;
    p->next=p->next->next;
    free(q); //释放空间不要忘记
    return 1;
}

6.取数据元素，过程同5

7.销毁单链表，while循环，调用free()即可；

循环单链表

初始化时 *head->next=head

遍历时 *p->next=*head结束遍历

双向循环链表

结构体定义中除了DataType data;还有前后指针struct Node *next;struct Node *prior;

初始化时head=(Node *)malloc(sizeof(Node));head->next=head;head->prior=head;

插入和删除就直接画出图形照着写就是

栈

后进先出是LIFO，先进先出是FIFO

顺序栈

存储结构用数组

typedef struct
{
    DataType stack[MaxStackSize];
    int top;//栈顶位置
}SeqStack;

初始化就是将栈顶元素位置即s->top设置为0，注意此处为0，王道是-1

判断是否非空就是判断top是否小于等于0，是就是空，反之不空

入栈就是将数据元素存入数据顺序栈中，栈顶指针加一

s->stack[s->top]=x;
s->top++;
//或者合并写：
s->stack[s->top++]=x;

出栈就是将栈顶指针减一

取栈顶元素就是数组取值操作，这里需要注意，top代表的是数据元素的个数，取值时要记得减一

*x=s->stack[s->top-1];

链式堆栈

链式堆栈的插入和删除操作都在链表表头进行的，且是带有头结点的链表

栈顶元素就是head->next所指向的元素

算术表达式求值

后缀表达式的求法

x1表示当前栈顶元素，x2表示当前扫描到的元素

比较优先级：

x1>x2：x1出栈并加入后缀表达式，将x1变为新的栈顶元素，继续比较

x1<x2：x2进栈并读取下一个元素

x1=x2且x1=="(",x2==")"：将x1出栈继续读取下一个元素

x1=x2="#"：算法结束

优先级的规则：

不同级别："(" >乘除>加减> ")"

同一级别：栈顶>扫描到的元素

串

串的下标是从0开始的，比如插入或者删除等操作中从第i个字符开始，i字符数组的下标

字符串比较比的是ascii

BF算法

设主串长为n子串长为m，最好情况下时间复杂度为O(m)，最坏情况下时间复杂度为O(mn)

int BFIndex(DString S,int start,Dstring T)//查找成功则返回子串在主串中的位置
{
    int s=start;s,t=0,pos;
    while(s<S->length && t<T->length)
    {
        if(S->str[s]==T->str[t])
        {
            s++;
            t++;
        }else{
            s=s-t+1;
            t=0;
        }
    }
    if(t==T->length)
        pos=s=T->length;
    else
        pos=-1;
    return pos;
}

KMP算法

计算next[j]

void GetNext(DString T,int next[])
{
    int j=1,k=0;
    next[0]=-1;
    next[1]=0;
    while(j<T->length-1)
    {
        if(T->str[j]==T->str[k])
        {
            next[j+1]=k+1;
            j++;
            k++;
        }
        else if(k==0)
        {
            next[j+1]=0;
            j++;
        }
        else
            k=next[k];
    }
}