线性表 -c语言

最新推荐文章于 2024-09-25 13:49:47 发布

GODDOG_wyc

最新推荐文章于 2024-09-25 13:49:47 发布

阅读量199

点赞数 1

文章标签：数据结构 c语言

本文链接：https://blog.youkuaiyun.com/GOLDGOU/article/details/110631312

版权

线性表 -c语言

顺序表
- 顺序表的实现-静态分配
- 顺序表的实现-动态分配
链表
顺序表VS链表
栈
队列

顺序表

顺序表的实现-静态分配

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//定义结构体内data数组的初始最大长度
#define MaxSize 10


//定义结构体
typedef struct{
    int data[MaxSize];
    int length;

}SeqList;


//初始化结构体
void InitList(SeqList *L){
    L->length = 0;
    printf("初始化结构体成功!!\n");
}


//插入元素
bool ListInsert(SeqList *L, int i, int e){
    //健壮性
    if(i<1||i>L->length+1){
        return false;
    }
    if(L->length >= MaxSize){
        return false;
    }

    for(int j= L->length; j>=i; j--){
        L->data[j] = L->data[j-1];
    }
    L->data[i-1] = e;
    L->length++;
    return true;

}

//删除元素
bool ListDelete(SeqList *L,int i,int *e){
    if(i<1||i>L->length){
        return false;
    }

    *e = L->data[i-1];
    for(int j=i+1; j<= L->length; j++){
        L->data[j-2]=L->data[j-1];
    }
    L->length--;
    return true;
}

//按位查找元素
int GetElem(SeqList L, int i ){
    return L.data[i-1];
}

//按值查找,并返回位序
int LocateElem(SeqList L, int e){
    for(int i=0; i< L.length; i++){
        if(L.data[i]==e){
            return i+1; //数组下标为i的元素值为e，其位序为i+1
        }
    }
    return -1; //查找不成功，返回-1
}




int main()
{
    SeqList L;
    //初始化顺序表
    InitList(&L);
    //插入样例数据
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=4;
    L.data[3]=5;
    L.data[4]=6;
    L.length=5;
    printf("%d\n",L.data[2]);

    //测试在第三个位置插入3
//    if(ListInsert(&L, 3, 3)){
//        printf("插入成功\n");
//    }
//    else{
//        printf("插入失败\n");
//    }
    //printf("1");


    //测试删除第三个元素
//    int e=-1;//用变量e把删除元素带回来
//    if(ListDelete(&L, 3, &e)){
//        printf("已经成功删除第3个元素，元素值为%d\n",e);
//    }
//    else{
//        printf("删除失败\n");
//    }


  //测试查找位序为3的元素的值
//    int i=GetElem(L, 3);
//    printf("第三个元素为%d",i);


    //测试查找值为8的元素的位序
//    int i = LocateElem(L,8);
//    if(i== -1){
//        printf("该元素不存在\n");
//    }
//    else{
//        printf("查找成功，元素的位序为%d\n",i);
//    }
    return 0;
}

顺序表的实现-动态分配

#include <stdio.h>
#include <stdlib.h>

//定义结构体内data数组的初始最大长度
#define initSize 10


//定义结构体
typedef struct{
    int *data;
    int MaxSize;
    int length;

}SeqList;


//初始化结构体
void InitList(SeqList *L){
    L->length = 0;
    L->data = (int *)malloc(sizeof(int)* initSize);
    L->MaxSize = initSize;
    printf("初始化结构体成功!\n");
}

//动态增加动态数组的最大长度
void IncreaseSize(SeqList *L, int len){
    int *p = L->data;
    L->data = (int *)malloc(sizeof(int)*(L->MaxSize+len));
    L->MaxSize = L->MaxSize + len ;
    for(int i=0;i < L->length; i++){
        L->data[i] = p[i];
    }
    free(p);//释放原来的内存空间
}

//按位查找元素
int GetElem(SeqList L, int i ){
    return L.data[i-1];
}

//按值查找,并返回位序
int LocateElem(SeqList L, int e){
    for(int i=0; i< L.length; i++){
        if(L.data[i]==e){
            return i+1; //数组下标为i的元素值为e，其位序为i+1
        }
    }
    return -1; //查找不成功，返回-1
}

int main()
{
    SeqList L;
    InitList(&L);

    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=4;
    L.data[3]=5;
    L.data[4]=6;
    L.length=5;

    //测试查找位序为3的元素的值
//    int i=GetElem(L, 3);
//    printf("第三个元素为%d",i);


    //测试查找值为8的元素的位序
//    int i = LocateElem(L,8);
//    if(i== -1){
//        printf("该元素不存在\n");
//    }
//    else{
//        printf("查找成功，元素的位序为%d\n",i);
//    }

    return 0;
}

链表

单链表(带头结点)

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode, *LinkList;

//初始化一个空的单链表
bool InitList(LinkList *L) {
    (*L) = (LNode *)malloc(sizeof(LNode)); //分配一个头结点
    if(*L == NULL){
        return false;
    }
    (*L)->next =NULL;
    return true;
}


//在第i个结点插入元素e（带头结点）
bool ListInsert(LinkList *L, int i, int e){
    if(i<1){
        return false;
    }
    LNode *p; //指针p指向当前扫描到的结点
    int j=0;//当前p指向的是第几个结点
    p = *L;//*L为指向头结点的指针，头结点是第0个结点(不存数据)
    while(p!=NULL && (j < i-1)){//找到i-1个结点
        p = p->next;
        j++;
    }
    if (p== NULL){//i值不合法
        return false;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

//指定结点的后插操作
bool InsertNextNode(LNode *p, int e){
    if(p == NULL){
        return false;
    }
    LNode *s= (LNode *)malloc(sizeof(LNode));
    if(s==NULL){//内存不足
        return false;
    }
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

//指定结点的前插操作 在p结点前面插入e
bool InsertPrioNode(LNode *p, int e){
    if(p==NULL){
        return false;
    }
    LNode *s=(LNode *)malloc(sizeof(LNode));
    if(s==NULL){
        return false;
    }
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}



//按位序删除结点
bool ListDelete(LinkList *L, int i, int *e){
    if(i<1){
        return false;
    }
    LNode *p;
    int j=0;
    p = *L;
    while(p!=NULL && j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL){
        return false;
    }
    if(p->next==NULL){
        return false;
    }
    LNode *q = p->next;
    *e = q->data;
    p->next = q->next;
    free(q);
    return true;
}

//删除指定p
bool DeleteNode(LNode *p){
    if(p==NULL){
        return false;
    }
    LNode *q;
    q=p->next;
    p->data=q->data;
    p->next=q->next;
    free(q);
    return true;
}

//按位查找返回第i个元素
LNode * GetElem(LinkList L, int i){
    if(i<0){//第0个结点为头结点
        return NULL;
    }
    LNode *p=L;
    int j=0;
    while(p!=NULL && j<i){
        p=p->next;
        j++;
    }
    return p;
}

//按值查找，找到数据域==e 的结点
LNode * LocateElem(LinkList L, int e){
    LNode *p = L->next;
    while(p!=NULL && p->data!=e){
        p=p->next;
    }
    return p;
}

//尾插法建立单链表
LinkList List_TailInsert(LinkList *L){
    int x;
    (*L)= (LNode *)malloc(sizeof(LNode));//建立头结点
    LNode *s,*r=(*L);//s为建立的新结点 r指向最后一个结点
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        scanf("%d",&x);
    }
    r->next=NULL;
    return *L;
}

//头插法建立单链表
LinkList List_HeadInsert(LinkList *L){
    int x;
    (*L) = (LNode*)malloc(sizeof(LNode));
    (*L)->next=NULL;
    LNode *s;
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        s->next=(*L)->next;
        (*L)->next=s;
        scanf("%d",&x);
    }
    return *L;
}

int main()
{
    LinkList L; //声明指向单链表的指针
    InitList(&L);
    return 0;
}

双链表(带头结点)

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct DNode{
    int data;
    struct DNode *prior,*next;

}DNode, *DLinkList;

//初始化双链表
bool InitDLinkList(DLinkList *L){
    *L = (DNode *)malloc(sizeof(DNode));
    if(*L==NULL){
        return false;
    }
    (*L)->prior = NULL;
    (*L)->next = NULL;
    return true;
}


//判断链表是否为空
bool Empty(DLinkList L){
    if(L->next==NULL){
        return true;
    }
    else{
        return false;
    }
}

//在p结点之后插入s结点
bool InsertNextDNode(DNode *p,DNode *s){
    if(p==NULL || s==NULL){
        return false;
    }
    s->next=p->next;
    if(p->next != NULL){
        p->next->prior=s;//注意容易忘记
    }
    p->next=s;
    s->prior=p;
    return true;
}

//删除p结点的后继结点
bool DeleteNextDNode(DNode *p){
    if(p==NULL){
        return false;
    }
    DNode *q=p->next;
    if(q==NULL){
        return false;
    }
    p->next=q->next;
    if(q->next!=NULL){
        q->next->prior = p;
    }
    free(q);
    return true;
}

//销毁双链表
void DestoryList(DLinkList *L){
    //循环释放各个结点
    while((*L)->next !=NULL){
        DeleteNextDNode(*L);
    }
    free(*L);
    *L=NULL;
}

int main()
{
    DLinkList L;
    InitDLinkList(&L);
}

循环单链表

#include <stdio.h>
#include <stdlib.h>

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode,*LinkList;


//初始化一个循环单链表
bool InitList(LinkList *L){
    (*L) = (LNode *)malloc(sizeof(LNode));
    if((*L)==NULL){
        return false;
    }
    (*L)->next = (*L);
    return true;
}

//判断循环单链表是否为空
bool Empty(LinkList L){
    if(L->next=L){
        return true;
    }
    else{
        return false;
    }
}

//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L, LNode *p){
    if(p->next = L){
        return true;
    }
    else{
        return false;
    }
}



int main()
{
    printf("Hello world!\n");
    return 0;
}

循环双链表

#include <stdio.h>
#include <stdlib.h>

typedef struct DNode{
    int data;
    struct DNode *prior,*next;
}DNode,*DLinkList;

//初始化循环双链表
bool InitDLinkList(DLinkList *L){
    (*L) = (DNode *)malloc(sizeof(DNode));
    if((*L)==NULL){
        return false;
    }
    (*L)->prior = *L;
    (*L)->next = *L;
    return true;
}

//判断循环双链表是否为空
bool Empty(DLinkList L){
    if(L->next == L){
        return true;
    }
    else{
        return false;
    }
}

//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinkList L, DNode *p){
    if(p->next ==L){
        return true;
    }
    else{
        return false;
    }
}

int main()
{
    DLinkList L;
    InitDLinkList(&L);
}

顺序表VS链表

Round1：逻辑结构
- 共同点：都属于线性表，都是线性结构
Round2：存储结构
- 顺序表：
  - 优点：支持随机存取、存储密度高
  - 缺点：大片连续空间分配不方便，改变容量不方便
- 链表：
  - 优点：离散的小空间分配方便，改变容量方便
  - 缺点：不可随机存取，存取密度低

栈

栈的定义

栈(Stack)是只允许在一端进行插入或删除操作的线性表
重要术语：栈顶、栈底、空栈

顺序栈

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MaxSize 10 //定义栈中元素的最大个数


typedef struct{
    int data[MaxSize]; // 静态数组存放栈中元素
    int top; //栈顶指针
}SqStack;

//初始化栈
void InitStack(SqStack *S){
    S->top=-1;
}

//新元素进栈
bool Push(SqStack *S,int x){
    if(S->top == MaxSize-1 ){//栈满报错
        return false;
    }
    S->top = S->top+1;
    S->data[S->top]=x;
    return true;
}

//出栈操作
bool Pop(SqStack *S,int *x){
    if(S->top==-1){
        return false;
    }
    *x= S->data[S->top];
    S->top--;
    return true;
}

int main()
{
    SqStack S;
    InitStack(&S);
}

链栈

#include <stdio.h>
#include <stdlib.h>

typedef struct Linknode{
    int data;
    struct Linknode *next;
}*LiStack;


int main()
{
    printf("Hello world!\n");
    return 0;
}

队列

队列的定义

队列是只允许在一端进行插入，在另一端删除的线性表
队列的特点：先进先出

队列的顺序实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MaxSize 10

typedef struct{
    int data[MaxSize];
    int front,rear;
}SqQueue;

//初始化队列
void InitQueue(SqQueue *Q){
    Q->front = Q->rear = 0;
}

//判断队列是否为空
bool QueueEmpty(SqQueue *Q){
    if(Q->front==Q->rear){
        return true;
    }
    else{
        return false;
    }
}

//入队
bool EnQueue(SqQueue *Q, int x){
    if((Q->rear+1)%MaxSize == Q->front){
        return false;
    }
    Q->data[Q->rear] =x;
    Q->rear = (Q->rear +1)%MaxSize;
    return true;
}

//出队
bool DeQueue(SqQueue *Q, int *x){
    if(Q->front==Q->rear){
        return false;
    }
    *x = Q->data[Q->front];
    Q->front = (Q->front + 1)%MaxSize;
    return true;
}

//获得队头元素 ， 用x值返回
bool GetHead(SqQueue *Q, int *x){
    if(Q->front == Q->rear){
        return false;
    }
    *x= Q->data[Q->front];
    return true;
}




int main()
{
    SqQueue Q;

}

队列的链式实现（带头结点）

#include <stdio.h>
#include <stdlib.h>

typedef struct LinkNode{
    int data;
    struct LinkNode *next;
}LinkNode;

typedef struct{
    LinkNode *front,*rear;
}LinkQueue;

//初始化队列(带头结点)
void InitQueue(LinkQueue *Q){
    Q->front = Q->rear = (LinkNode *)malloc(sizeof(LinkNode));
    Q->front->next = NULL;
}

//判断队列是否为空
bool IsEmpty(LinkQueue *Q){
    if(Q->front == Q->rear){
        return true;
    }
    else{
        return false;
    }
}

//新元素入队(带头结点)
void EnQueue(LinkQueue *Q, int x){
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next =NULL;
    Q->rear->next = s;
    Q->rear = s; 
}

//出队（带头结点）
bool DeQueue(LinkQueue *Q , int *x){
    if(Q->front == Q->rear){
        return false;
    }
    LinkNode *p = Q->front->next;
    x=p->data;
    Q->front->next=p->next;
    if(Q->rear == p){
        Q->rear = Q->front;
    }
    free(p);
    return true;
}


int main()
{
    LinkQueue Q;
    InitQueue(*Q);
}