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

动态顺序表的增删

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

链表

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

typedef struct node{    ElemType data ;  //数据域    struct node * next ;//指向下一个节点}LNode ,*LinkList ; //LNode 是别名, linkList是指向结构体地址的指针类型定义

1. 编写程序,从终端输入一组整数(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  10typedef struct node{    dataType data;    struct node *child[MaxChild];}

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

结构定义typeder srtuct BitNode{    ElemType data;  //数据域     struct BiTree lchild,rchild; //左子树 右子树}BitNode ,*BiTree;先序遍历:访问根节点,访问左子树,访问右子树//传入根节点的地址 &tpreTree(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 =20tyepdef 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);          }    }}