常用的数据结构的增删代码-c语言

最新推荐文章于 2022-12-15 17:38:41 发布

sgafdsg

最新推荐文章于 2022-12-15 17:38:41 发布

阅读量770

点赞数 1

分类专栏： java 基础技术文章标签：数据结构

本文链接：https://blog.csdn.net/sgafdsg/article/details/73456648

版权

java 基础技术专栏收录该内容

4 篇文章 0 订阅

订阅专栏

动态顺序表的增删

顺序表: 1.有唯一的表名 2.内存单元连续 3.数据顺序存放

链表

逻辑上连续,物理上不一定连续.
每个节点包括数据域和指针域
只要通过链表的头结点可以通过指针遍历整条链表

typedef struct node{
    ElemType data ;  //数据域
    struct node * next ;//指向下一个节点

}LNode ,*LinkList ; //LNode 是别名, linkList是指向结构体地址的指针类型定义

编写程序,从终端输入一组整数(10个以上),以0作为结束标志,将这一组整数存放在一个链表中(结束标志0不包括在内),打印出该链表的值,然后删除该链表中第5个元素,打印出删除后的结果,最后在内存中释放掉该链表
代码

typedef int ElemType; //定义一个数据结构

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

//创建链表 n-节点个数
LinkList createLingList (int n){
LinkList p,r,list=NULL;
ElemType e;
int i;
for(int i =0;i<=n ; i++){
scanf(“%d”,&e); //输入节点内容
p=(LinkList)malloc(sizeof(LNode)); //为节点分配空间
p->data=e; // 数据域赋值
p->next=NULL;
if(!list){ //链表不存在
list =p;
}else{
r->next =p; //r代表链表的最后一个节点
}
r =p;
}
return list;
}
//插入节点,q为插入节点的前一个节点 e为节点的值,
void insertList(LinkList *list ,LinkList q;ElemType e){
LinkList p;
p =(LinkList)malloc(sizeof(e)); //p节点开辟空间
p->data=e;
if(! *list){ //list指向的节点为空,即头结点为空,则插入的节点为头结点
*list =p;
p->list =NULL;
}else{
p->next = q->next; //把 p插在 q后边
q->next = p;
}
}
//删除元素 q
void delList(LinkList *list ,linkList q){
if(q ==*list){
// 这里的 *list 表示 list 地址对应的值
*list =q->next;
}else{
//遍历 list
for( LinkList r =*list ; r->next !=q;r=r->next){
}
if(r->next !=null){
r->next =q->next;
free(q); //释放掉这个元素
}
}
}
//销毁数据结果,做法是从头结点开始删除
void destoryLinkList(LinkList *list){
LinkList p,q;
p=*list;
while(p){
q= p->next;
free(p);
p=q;
}
}

栈

1.是一种先进后出的线性表,
2.只能从表尾进行入栈和出栈操作
3.表尾称为栈顶(top) ,表头称为栈底(base)

一般栈采用顺序表存储,顺序栈结构如下

tepedef sruct{
    Elemtype *top;
    Elemtype *base;
    int stacksize;  //栈的容量
}sqStack ;

//创建一个栈
initStack(sqStack *s ){
//开辟一段内存空间,首地址赋值给 s->base
    s->base =(Elemtype *)mallor( 10 * sizeof(ElemType));
    s->top=s->base;  //开始的时候,栈顶就是栈底
    s-stacksize =10;
}

//入栈操作
pushStack(sqStack *s ,Elemtype e){
    if( s->top- s->base >= s->stacksize){ //栈的元素超过容量,需要重新分配空间
    s->base =(Elemtype *)ralloc(s->base,(s->stacksize +10)sizeof(Elemtype)); 
    if(!s->base ){
        exit(0);  //分配空间失败,推出
    }
    s->top=s->base+ s->stacksize;  //这行我也不明白什么意思
    s->stacksize +=10;    //设置栈的最大容量
    s->top=e;
    s->top++;  //top 始终指向栈顶元素的上一个空间
}
//弹出一个元素, 传入e的地址用来获得出栈的值
popStack(sqStack *s ,Elemtype *e){
    if(s->top =s->base) return ;// 此时为空栈
    s-top --; // 栈顶回退,指向最上边的元素
    *e= *(s->top);
}

//清空栈,只需要把栈尾元素赋值给栈顶
clearStack(sqStack *s ){
    s->top =s->base;
}
//销毁一个栈 , 意味着释放栈的空间
destoryStack(sqStack *s){
    int size =s->stacksize;
    int i;
    for(i=0;i< size; i++ ){
        free(s->base);  //释放栈底,栈向上一位
        s->base ++;
    }

    s->base =s->top =NULL;
    s->stacksize =0;
}

队列

1.队列是一种先进先出的线性表;
2.数据要从一端进入(队尾 rear),另一端离开(队头 front)

用链表实现的队列

typedef struct QNode{  //队列中的元素
    QelemType data;    //存放数据的元素
    struct QNode *next;
}QNde, *QueuePtr;

tepedef struct{
    QueuePtr front;  //对头指针
    QueuePtr rear;   //队尾指针
 }LinkQueue ;

//创建队列

initQueue(LinkQueue *q){
    //初始化一个空队列 ,对头队尾指向该节点
   q->front=q->rear =(LinkQueue *)malloc(sizeof(QNode));
   if(!q->front) exit(0);
   q->front->next =NULL;  //头结点指针域置为NULL
}

//入队操作.从尾节点加入
enQueue(LinkQueue *q,ElemType e){
    QueuePtr p;
    p =(QueuePtr) mallor(sizeof(ElemType)); //创建节点,赋值
    p->data=e;
    p->next =NULL;
    q->rear->next =p;  //尾节点指向p
    q->rear =p;        //p称为新的尾节点
}

//出队操作,从对头出队,传入e的地址存放出队的数
deQueue(LinkQueue *q , ElemType *e){
    if(q->front =q->rear ) return ; //队列为空
    LinkQueuq p ;
    *e =q->front->data;
     p= q->front->next;
     q->front->next =p->next;
     //如果对头的下一个节点是队尾,修改队尾指针
     if(q->rear ==p){  
         q->rear =q->front;
     }
     free(p);
}

//销毁一个队列
destoryQueue(LinkQueue *q){
   while(q->front){  //q的队头不为空,
    //此时把 q->rear 当作临时变量使用,队头不断出栈,直到队头为空
       q->rear=q->front->next; 
       free(q->front){
           q->front =q-rear;
       }
   } 
}

循环队列

1.由顺序表实现,容量固定
2.空间可以循环使用,只要队列中还有空间未使用
3.约定,对头指针指向堆头元素,队尾指针指向队尾元素的下一个空间

#define MAXSIZE=10;
定义一个循环队列
typedef stuct {
    Elemtype *base;  队列的内存分配基地址
    int front; //队头
    int rear;  //队尾
}cycleQueue ;

初始化循环队列
initcycleQueue(cycleQueue *q){
//分配十个单元的空间给循环队列
    q->base =(cycleQueue *)mallor( MAXSIZE * siezeof(Elemtype);;//
    if(! 1->base) exit(0);//分配空间失败
    q->front =q->rear =0; //空队列,对头队尾指向0号单元
} 

入队操作
void enqueue(cycleQueue *q ,Elemtype e){
//q->rear  和q->front 是数组的下标,当队列满时不能添加
    if((q->rear +1)/MAXSIZE)=q->front; return ;
    q->base[q->rear] =e;
    q->rear=(q->rear +1)/MAXSIZE; //队尾指针加1
}
出队操作
void enqueue(cycleQueue * q,Enemtype *e){
    if(q->front =q->rear) return ;
    *e= q->base[q->front]; //取出对头元素,用e返回
    q->front=(q->front +1)/MAXSIZE; //对头指向下一元素的位置
}

树结构

1.树只有一个根节点,
2.根节点的子节点又是一棵树

树的定义
#define MaxChild  10
typedef struct node{
    dataType data;
    struct node *child[MaxChild];
}

二叉树它或者为空,或者由一个根节点加上两颗分别称为左子树,右子树的互不相交的二叉树组成.

结构定义
typeder srtuct BitNode{
    ElemType data;  //数据域 
    struct BiTree lchild,rchild; //左子树 右子树
}BitNode ,*BiTree;


先序遍历:访问根节点,访问左子树,访问右子树
//传入根节点的地址 &t
preTree(BiTree t){
    if(t){//遍历条件是节点不为空
        viset(t->data);
        preTree(t->lchild);
        preTree(t->rchild);
    }
}

中序遍历:先访问左子树,在访问根节点,在访问右子树
//此形参和上文的 BiTree t 意义相同,都代表接受一个 节点的地址
midTree(BitNode * t){
    if(t){
         preTree(t->lchild);
        viset(t->data);
        preTree(t->rchild);
    }
}


后序遍历:先访问左子树,在访问右子树,在访问根节点
midTree(BitNode * t){
    if(t){
         preTree(t->lchild);
        preTree(t->rchild);
        viset(t->data);
    }
}

图由若干个顶点和顶点之间的边构成,若每条边都无序,称为无向图,每条边都有序称为有向图

1.图的存储方法,邻接矩阵存储法,临街表存储法
2:邻接矩阵: 用一个一位数组存储数据,一个二维数组存储定点间的相互关系,称为邻接矩阵,A[i][j] 定义如下

A[i][j]= { 1 当定点i 与顶点 j之间有边
         { 0 当定点i 与顶点 j之间无边

有向图

 //数据域表示
int  vdata =[3,5,1,6];
//邻接矩阵表示如下
{0 1 0 1}
{0 0 1 0}
{0 0 0 1}
{0 0 0 0}

3.邻接矩阵:用一个链表存储顶点的数据信息,一个链表存储边的信息.
数组结构如下

顺序表结构
vertex 表示顶点的数据.
next指向顶点对应的链表.

 链表结构如下

链表结构

weight 域表示权重,
adjvex 表示该边的另一端顶点在顶点数组中的位置
next  表示指向链接到该顶点的下一条边,通过next就把一个顶点的所有边连在了一起

邻接表的定义
#define MAX_NUM =20
tyepdef stuct ArcNode{
    int adjvex  ; //该边的另一顶点在顺序表的位置
    struct ArcNode *next ;//下一条边
    infoType * weight ;//边的权重,可忽略
}ArcNode;

tyepdef stuct VNode{
    VertexType data; //定点的数据信息
    ArcNode * firstarc ;//指向第一条边
}VNode;
VNode G[MAX_NUM];  

图的遍历
1.深度优先搜索:从某个顶点出发,访问该节点,在访问他的未被放过获得邻接点,继续深度优先递归搜索这个邻接点,直到所有邻接点都被搜索到,然后换一个未被访问的没有邻接的点继续递归深度优先搜索;

//v 表示顶点在顺序表中的坐标
//G[] 表示顶点v的顺序表
void DFS(VNode G[],int v){
    int w;
    visti(v); //访问该顶点
    visited[v]=1;//将该顶点的访问状态值为已访问
    w=fistAdj(G[],v) //找到v顶点的第一个邻接点,没有返回-1
    while(w !=-1){
        if(visited[w] ==0) //改顶点没被访问
        DFS(G,w);
        w=NextAdj(G,v); //找到下一个邻接点,没有返回-1
    }
}
//visited 是标记数组, 标记每个顶点是否被访问 
//n 为数组长度
void tarvel_dfs (VNode G[],int visited[],int n){
    for( int  i=0;i< n;i++){
        visited[i]=0;  //初始化所有定点为未访问
    }
    for( int i =0 ;i< n;i++){
         if( visited[i]=0){  //找到没有访问的顶点,深度优先搜索
           DFS(G,i);
          }
    }
}

广度优先搜索
从指定顶点v出发,先访问该顶点v,在访问v的未被访问的邻接点,再从邻接点出发,按同样规则访问他们未被访问的邻接点.直到v的所有邻接点都被访问,在换一个不邻接的顶点重复上述过程.
//v 表示要访问第几个顶点
//G[] 表示顶点数据的集合
void BFS(VNode G[] ,int v){
    int w;
    visit(v);  //将v 置为已访问
    visited[v]=1;

    enqueue(q,v); //将v入队列q中
    while(!empty(q)){ //q不为空
        dequeue(&q,&v)  // 在队列出队一个元素,放入v中
        w=firstAdj(G,v);//得到v的第一个邻接点,没有返回-1
        while(w!=-1){
            if(visitde[w] ==0){ //w未被访问
                vist(w);
                enqueue(q,w); //w入栈
                visited[w]=1;
            }
            //注意,这里是获取v的下一个邻接点,他与w是平级关系而不是找w的邻接点
            w=nextAdj(G,v);
        }
    }
}
//g 顶点集合  visited 标记顶点是否被访问    n顶点个数
void travel_bfs(VNode G[],int visited[],int n){
    int i;
    for( i=0; i < n;i++){
        visited[i]=0;
    }
     for( int i =0 ;i< n;i++){
         if( visited[i]=0){  //找到没有访问的顶点,广度优先搜索
           BFS(G,i);
          }
    }
}