数据结构 day04 基础知识学习 (接着昨天的讲)

已于 2022-07-26 19:03:36 修改
阅读量299 收藏
点赞数
分类专栏： 数据结构与算法
于 2022-07-26 18:46:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/she666666/article/details/126000877
版权

学习 数据结构

一.知识点主要是在代码里，知识点有：循环链表，函数的接口调用， viod* 类型的函数的运用

和循环列表的增删改查  （这里有点难，主要是老师让我们假装不知链表的存储的数据类型，还有就是要我们使用函数指针来 调用函数，，一言难尽 （bug 太多了，还好在老师的帮助下修好了））

二.有6个文件 

1.student.h

2.student.c

3.day03.h

4.day03.c

5.main.c

6.makefile

三.代码：

1.student.h

#ifndef __STUDENT_H__
#define __STUDENT_H__
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>
#include"day03.h"

typedef struct student
{
    char name[100];
    int m_id;
    int m_age;
    char sex;
}stu,*pstu;

int pcmp_name(const void *x,const void *y);
int pcmp_id(const void *x,const void* y);
void student_show(const void *ptr);
void student_updata_sex1(void *data1,const void* data2);
#endif

2.student.c

/************************************************************************************************************************************************************************************************************************
 *文件名:student.c
 *作  者:She001
 *时  间:
 *版  本:
 *作  用:学生的函数
****************************************************************************************************************************************************************************************************************************/
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>
#include "student.h"
#include "day03.h"


void student_updata_sex1(void* data1,const void * data2)  //修改学生信息中的性别 （函数指针调用）
{
    pstu ptem1= (pstu)data1;
    const pstu ptem2 = (const pstu) data2;
    ptem1->sex=ptem2->sex;                  //函数的直接赋值
}
int pcmp_name(const void *x,const void *y)          //比较学生的姓名是否相同（函数指针调用）
{
    if((x==NULL) || (y==NULL))
    {
        return -1;
    }
    //printf("1:%s \t  2:%s \n",((stu*)(x))->name,((stu*)(y))->name);
    pstu name1 =(pstu)x;
    pstu name2 =(pstu)y;
    //printf("1:%s \t  2:%s \n",name1->name,name2->name);
    return strcmp(name1->name,name2->name);
}

int pcmp_id(const void *x,const void* y)         //比较学生的id 是否相同（函数指针调用）
{
    if((x=NULL) || (y=NULL))
    {
        return -1;
    }
    pstu name1 =(pstu)x;
    pstu name2 =(pstu)y;
    return name1->m_id - name2->m_id;

}

void student_show(const void *ptr)           //显示函数（函数指针调用）
{
    if(ptr==NULL)
    {
        return;
    }
    pstu student1 =(pstu) ptr;
    printf("姓名：%s\t  id:%d\t 年龄：%d\t 性别：%c\n",student1->name,student1->m_id,student1->m_age,student1->sex);
    
}

day03.h

#ifndef __DAY03_H__
#define __DAY03_H__
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct node
{
	void * data; //数据域
	struct node* next; //指针域 ，指向下一个节点
	struct node* prev; //指针域 ，指向上一个节点
}node_t,*pnode_t;

enum node_insert_error                           //共用体 为了模仿报错返回的值
{
	node_insert_error0 = 0,  //没错误
	node_insert_error1 = 1,  //链表的首地址传入错误
	node_insert_error2 = 2,   //链表的数据节点指针错误
	node_insert_error3 = 3,   //传入的位置错误
	node_insert_error4 = 4,   //节点申请失败
};




node_t*  create_head_node(); //创建头节点的空间节点
node_t* create_node();  //创建空间节点
int node_insert_end(node_t *head ,void *data ,int size);//尾部添加节点
int node_insert_head(node_t *head ,void *data ,int size);//头部添加节点
void delete_node_head(node_t * head);  //删除头部节点
void delete_node_end(node_t * head);  //删除尾部节点
int  insert_pos_node(node_t *head,int pos,void *data,int size);//在固定的位置增加节点
void node_update(node_t * ptr,const void *data_updata,void (*pUpdate)(void *a,const void *b ));  //函数接口 
void delete_pos_node(node_t* head,int pos);//在固定的位置删除节点
void delete_some_node(node_t *head);删除除了头节点之外的所有节点
bool isEmpty(node_t *head);          ///判断指针是否为空
void node_show(node_t* head,void(*pshow)(const void* ptr ));  //输出函数 （函数接口）
node_t* node_find(node_t *head ,void * data_par , int (*pcmp)(const void * x,const void *y));   //判断查询函数  （函数接口）
void  node_delete(node_t *head ,void * data_par , int (*pcmp)(const void * x,const void *y));   //删除函数 （函数接口）

#endif

day03.c

/************************************************************************************************************************************************************************************************************************
 *文件名:day03.c
 *作  者:She001
 *时  间:
 *版  本:
 *作  用:双向链表的建立
****************************************************************************************************************************************************************************************************************************/
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>
#include "day03.h"
#include "student.h"



/***************************
 * 函数名：create_head_node
 * 参数：无
 * 
 * 
 * 返回值： node_t *s
 * 作用：创建头节点的空间节点(x循环列表)
 * *************************/
node_t*  create_head_node()//创建头节点的空间节点
{      
       node_t* head = (node_t *)malloc(sizeof(node_t));
       if(NULL==head)
       {
              printf("头节点申请错误！\n");
              return NULL;
       }
       head->data =NULL;
       head->next=head;
       head->prev=head;
       return head;
}



/***************************
 * 函数名：create_node
 * 参数：无
 * 
 * 
 * 返回值： node_t *s
 * 作用：创建的空间节点
 * *************************/
node_t* create_node()  //创建空间节点
{
        node_t* gw = (node_t *)malloc(sizeof(node_t));
       if(NULL==gw)
       {
              printf("空间申请错误！\n");
              return NULL;
       }
       gw->data=NULL;
       gw->next=NULL;
       gw->prev=NULL;
       return gw;   
}




/***************************
 * 函数名：node_insert_end
 * 参数：node_t *head  //头节点
 *      void *data    //数据
 *      int size      //数据大小
 * 
 * 
 * 返回值： int 类型
 * 作用：尾部加入节点(x循环列表)
 * *************************/
int node_insert_end(node_t *head ,void *data ,int size)//尾部添加节点
{
       if(NULL ==head)
       {
              printf("首地址错误\n");
              return node_insert_error0; //首地址错误
       }
       if(NULL==data)
       {
              printf("数据指针错误！\n");
              return node_insert_error2; //数据指针错误
       }
       //申请一个新的节点
       node_t* gg=create_node();
       if(NULL==gg)
       {
              printf("申请空间的节点失败！\n");
              return node_insert_error4;
       }
       gg->data=malloc(size);
       if(NULL==gg->data)
       {
              printf("申请空间的节点失败！\n");
              return node_insert_error4;
       }
       memcpy(gg->data,data,size);
       head->prev->next=gg;
       gg->prev=head->prev;
       head->prev=gg;
       gg->next=head;
       return node_insert_error0;

}


/***************************
 * 函数名：node_insert_end
 * 参数：node_t *head  //头节点
 *      void *data    //数据
 *      int size      //数据大小
 * 
 * 
 * 返回值： int 类型
 * 作用：头部插入空间节点(x循环列表)
 * *************************/


int node_insert_head(node_t *head ,void *data ,int size)//头部添加节点
{
      if(NULL ==head)
       {
              printf("首地址错误\n");
              return node_insert_error0; //首地址错误
       }
       if(NULL==data)
       {
              printf("数据指针错误！\n");
              return node_insert_error2; //数据指针错误
       }
       //申请一个新的节点
       node_t* gg=create_node();
       if(NULL==gg)
       {
              printf("申请空间的节点失败！\n");
              return node_insert_error4;
       }
       gg->data=malloc(size);
       if(NULL==gg->data)
       {
              printf("申请空间的节点失败！\n");
              return node_insert_error4;
       }
       memcpy(gg->data,data,size); 
       gg->next=head->next;
       head->next->prev=gg;
       head->next=gg;
       gg->prev=head;
}

/***************************
 * 函数名：isEmpty
 * 参数：node_t *head  //头节点
 * 
 * 返回值： 无
 * 作用：判断链表是否为空
 * *************************/
bool isEmpty(node_t *head)
{
       if(head==NULL)
       {
              return true;
       }
       else if(head->next==head)
       {
              return true;
       }
       else
       {
              return false;
       }
} 




/***************************
 * 函数名：delete_node_end
 * 参数：node_t *head  //头节点
 * 
 * 返回值： 无
 * 作用：删除尾部的空间节点(x循环列表)
 * *************************/
void delete_node_end(node_t * head)  //删除尾部节点
{
       if(isEmpty(head))
       {
              printf("数据为空！\n");
              return;
       }
      if(NULL ==head)
       {
              printf("首地址错误\n");
              printf("已经是空的！");
              //return node_insert_error1; //首地址错误
              return;
       }
       if((head->prev)==NULL)
       {
              printf("链表已经为空！\n");
              //return node_insert_error1;
              return;
       } 
       node_t *p = head->prev;
       head->prev=head->prev->prev;
       head->prev->next=head;
       if(p->data!=NULL)
       {
          free(p->data);
       }
       printf("删除成功！\n");
       free(p);
       p=NULL;
}

/***************************
 * 函数名：node_insert_head
 * 参数：node_t *head  //头节点
 * 
 * 返回值： void
 * 作用：删除头部的空间节点(x循环列表)
 * *************************/
void delete_node_head(node_t * head)  //删除头部节点
{
       if(isEmpty)
       {
              return;
       }
       if(NULL ==head)
       {
              printf("首地址错误\n");
              printf("已经是空的！");
              //return node_insert_error1; //首地址错误
              return ;
       }
       if((head->next)==NULL)
       {
              printf("链表已经为空！\n");
              //return node_insert_error1;
              return;
       } 
       node_t *p = head->next;
       head->next=p->next;
       p->next->prev=head;
       if(p->data!=NULL)
       {
          free(p->data);
       }
       free(p);
       p=NULL;
}

/***************************
 * 函数名：delete_some_node
 * 参数：node_t *head  //头节点
 * 
 * 返回值： void
 * 作用：删除除了头部的所有空间节点(x循环列表)
 * *************************/
void delete_some_node(node_t *head)
{
       if(isEmpty)
       {
              return;
       }
       while(head->next!=head)
       {
             delete_node_head(head); 
       }
}

/***************************
 * 函数名：delete_pos_node
 * 参数：node_t *head  //头节点
 * 
 * 返回值： void
 * 作用：删除固定位置的空间节点(x循环列表)
 * *************************/
void delete_pos_node(node_t* head,int pos)
{      
       if(isEmpty)
       {
              return;
       }
       node_t* temp= head;
       int i=0;
       for(i=0;i<pos&& temp->next !=head;++i)
       {      
              temp=temp->next;
       }
       if(i==pos)
       {
              temp->prev->next=temp->next;
              temp->next->prev=temp->prev;
              if(temp->data!=NULL)
              {
                      free(temp->data);
              }
              free(temp);
              temp=NULL;
       }
}
/**********************
 * 作用： 对某个数据更新
 * 参数： ptr 需要修改数据的首地址
 *       data_updata 需要更新数据的指针
 *       pUpdate 函数指针
 * 
 * *******************/
void node_update(node_t * ptr,const void *data_updata,void (*pUpdate)(void *a,const void *b ))
{
       if(ptr==NULL || data_updata ==NULL || pUpdate==NULL)
       {
              return ;              
       }
       pUpdate(ptr->data,data_updata);
}


/***************************
 * 函数名：node_insert_end
 * 参数：node_t *head  //头节点
 *      void *data    //数据
 *      int size      //数据大小
 *      int pos       //数据的位置
 * 
 * 返回值： int 类型
 * 作用：插入固定的空间节点(x循环列表)
 * *************************/

int  insert_pos_node(node_t *head,int pos,void *data,int size)
{
       if(NULL ==head)
       {
              printf("首地址错误\n");
              return node_insert_error0; //首地址错误
       }
       if(NULL==data)
       {
              printf("数据指针错误！\n");
              return node_insert_error2; //数据指针错误
       }
       //申请一个新的节点
       node_t* gg=create_node();
       if(NULL==gg)
       {
              printf("申请空间的节点失败！\n");
              return node_insert_error4;
       }
       gg->data=malloc(size);
       if(NULL==gg->data)
       {
              printf("申请空间的节点失败！\n");
              return node_insert_error4;
       }
       memcpy(gg->data,data,size);
       int i=0; 
       node_t *temp =head; 
       for(i=0;i<pos&&temp->next!=head;i++)
       {
              temp=temp->next;
       }
       if(i==pos)
       {
              gg->prev=temp->prev;
              temp->prev->next=gg;
              gg->next=temp;
              temp->prev=gg;
       }      
}


/***************************
 * 函数名：node_show
 * 参数：node_t *head  //头节点
 *      pshow 函数指针
 *    
 * 返回值： 无
 * 作用： 打印链表所有的内容
 * *************************/
void node_show(node_t* head,void(*pshow)(const void* ptr ))
{
       if(head ==NULL || pshow ==NULL)
       {
              printf("参数错误，传入的指针为空！\n");
              return;
       }
       node_t * temp = head->next;
       while(temp->data!=NULL)
       {
              pshow(temp->data);
              temp=temp->next;
       }
}

/***************************
 * 函数名：node_find
 * 参数：node_t *head  //头节点
 *      data_par  需要查找的指针数据
 *      pcmp  函数指针
 * 返回值： int
 * 作用： 在循环列表找data_par 的数据
 * *************************/
node_t* node_find(node_t *head ,void * data_par , int (*pcmp)(const void * x,const void *y))
{
       if(head==NULL || data_par==NULL || pcmp ==NULL)
       {
              printf("指针错误！\n");
              return NULL;
       }
       node_t* temp =head->next;
       printf("0000000000000000000000000000000000000000\n");
       while(temp->data!=NULL)
       {
              printf("h1:%s\n",((stu*)(temp->data))->name);
              printf("h2:%s\n",((stu*)(data_par))->name);
              if(pcmp(temp->data,data_par)==0)
              {
                     return temp; 
              }
              temp=temp->next;
              printf("-=-=-=-=-=-=-=\n");
       }
       printf("1111111111111111111111111111111111111111111\n");
       return NULL;
}


/***************************
 * 函数名：node_delete
 * 参数：node_t *head  //头节点
 *      data_par  需要查找的指针数据
 *      pcmp  函数指针
 * 返回值： void
 * 作用： 在循环列表找data_par 并且删除他的数据
 * *************************/
void  node_delete(node_t *head ,void * data_par , int (*pcmp)(const void * x,const void *y))
{
     if(head==NULL || data_par==NULL || pcmp ==NULL)
       {
              printf("指针错误！\n");
              return ;
       }
       node_t* temp =head ->next;
       while(temp->data!=NULL)
       {
              if(pcmp(data_par,temp->data)==0)
              {
                     temp->prev->next=temp->next;
                     temp->next->prev=temp->prev;
                     return ; 
              }
              temp=temp->next;
       }
}

main.c

/************************************************************************************************************************************************************************************************************************
 *文件名:main.c
 *作  者:She001
 *时  间:
 *版  本:
 *作  用:程序接口
****************************************************************************************************************************************************************************************************************************/
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>
#include "student.h"
#include "day03.h"

int main()
{
    int i;
    /*typedef struct student
    {
     char name[100];
     int  m_id;
     int m_age;
     char sex;
    }stu,*pstu;*/

    stu w={"123",1,1,'0'};
    stu w1={"1234",12,12,'1'};
    stu w2={"12345",13,13,'2'};
    stu w3={"123456",14,14,'3'};
    stu w4={"1234567",15,15,'4'};
    stu w5={"12345678",16,16,'5'};
    node_t* head=create_head_node(); 
 
    node_insert_head(head ,&w ,sizeof(stu));
    node_insert_head(head ,&w1 ,sizeof(stu));
    node_insert_head(head ,&w2 ,sizeof(stu));
    node_insert_head(head ,&w3 ,sizeof(stu));
    node_insert_head(head ,&w4 ,sizeof(stu));
    node_insert_head(head ,&w5 ,sizeof(stu));
    
    node_show(head,student_show);
    printf("-----------------------------------\n");
    delete_node_end(head);
    node_show(head,student_show);   
    printf("++++++++++++++++++++++++++++++++++++\n"); 
    node_t* temp=head;
    for(i=0;temp->next!=head;i++)
    {
        temp=temp->next;
        printf("第%d个学生：\n",i+1);
        printf("name:%s \n",((stu*)(temp->data))->name);
        printf("id:%d\n",((stu*)(temp->data))->m_id);                      //temp->data  是一个 void *   因为id 是stu 类型的 所以我们需要一个 stu* 类型的指针来指向
        printf("age: %d\n",((stu*)(temp->data))->m_age);
        printf("sex: %c\n\n",((stu*)(temp->data))->sex);
    }
    printf("55555555555555555555555555555555555555555555\n");
    node_t * pt =node_find(head,&w3,pcmp_name);
    if(pt==NULL)
    {
        printf("没有找到！\n");
    }
    node_update(pt,&w2,student_updata_sex1);
    printf("===============================\n");
    node_show(head,student_show);


    /*
    node_t* temp=head;
    for(i=0;temp->next!=head;i++)
    {
        temp=temp->next;
        printf("第%d个学生：\n",i+1);
        printf("name:%s \n",((stu*)(temp->data))->name);
        printf("id:%d\n",((stu*)(temp->data))->m_id);                      //temp->data  是一个 void *   因为id 是stu 类型的 所以我们需要一个 stu* 类型的指针来指向
        printf("age: %d\n",((stu*)(temp->data))->m_age);
        printf("sex: %c\n\n",((stu*)(temp->data))->sex);
    }
    temp=head->next->next;
    node_update(temp,&w,student_updata_sex1);
    printf("==========================================================================\n");
    temp=head;
    for(i=0;temp->next!=head;i++)
    {
        temp=temp->next;
        printf("第%d个学生：\n",i+1);
        printf("name:%s \n",((stu*)(temp->data))->name);
        printf("id:%d\n",((stu*)(temp->data))->m_id);                      //temp->data  是一个 void *   因为id 是stu 类型的 所以我们需要一个 stu* 类型的指针来指向
        printf("age: %d\n",((stu*)(temp->data))->m_age);
        printf("sex: %c\n\n",((stu*)(temp->data))->sex);
    }
*/
}

makefile

node : main.o  day03.o student.o
	gcc -g -o node main.o day03.o student.o
main.o:main.c
	gcc -g -c  main.c -o main.o
day03.o:day03.c
	gcc -g -c day03.c -o day03.o
student.o:student.c
	gcc -g -c student.c -o student.o

4.多加  复习（读懂 函数指针）

_She001
关注
专栏目录
达内java学习day2
qq_52483391的博客
07-05 197
今天是在达内学习的第二天，来的时候还没有上课，把昨天的知识回顾一遍。不知所措的一天又要开始啦！刚才翻笔记发现少写了一个东西，哈哈，哈。
黑马程序员-JAVA基础学习日志——通篇大总结及学习方法思想
无码骑兵的博客
09-07 5649
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------   Java基础知识总结          回首是为了更好向前，天空没有翅膀的痕迹，而我已飞过，人总是这样，害怕回首，又时常回首，看看走过的路是直是弯，踩下的脚印是深是浅，回首昨天的风雨，眺望远方的灿烂。几多感慨，几多愁，放下包袱，轻装前行... 写代码： 1，明确需求。我要做什么？
isempty()函数用法
热门推荐
Panpan Wei的博客
07-03 9万+
isempty(A)函数是一个判断数列A是否为空的一个函数。 对于这个函数的用法如下： C =isempty(A): 假如A为空的话，返回的值是1 假如A为非空的话，返回的值是0 D = ~isempty(A) 与上面相反，假如A为空的话，返回的值是0，假如A为非空的话，返回的值是1 在这里强调一下，空元素代表的是未赋值的元素，0并不是空元素。 ...
head-＞next = p；和p=head-＞next；之间的区别
qq_45885219的博客
07-21 6771
对于head->next = p;和p=head->next;之间的区别，可能对于刚接触链表的你有点难理解其实结合图片就很容易理解 其实在说这两个之前我们可以用一个简单的语句来铺垫一下，比如int a=5；我们知道a就是一个整形数值的变量，下面的数值只代表一部分，此时我们令a=5；我们就让a指向5，把5赋值给a. 然后我们再先来说一说head->next = p; 然后我们再来说一说p=head->next;如果理解了上面的那个语句，那这个就不难了 网上对与head->n
C语言的学习日志2.19
X2573671311的博客
02-20 1967
链表： 链表是一种基础数据结构，采用动态分配储存单元的方式进行储存分配。结构体指针在这上面得到了充分的运用。换句话说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。 创建链表: 首先，要先构造一个结构体，构造结构体一般都用typedef函数，这样方便结构体变量的命名。 typedef struct _node{ int value; struct _node *next; }Node; ...
链表力扣题解（上）
lihua777的博客
02-02 1546
单链无头无循环链表的基本： （1）链表的结构体： structListNode{ intval; structListNode*next; }; （2）定义指针指向： struct ListNode* n1=head 定义一个链表型的n1的指针指向头地址 （3）指向下一个地址 n1=n1->next; (4)指向该地址所存储的值 n1->val 1：反转链表 思路解析： 定义三个结构体型的指针，*n1，*n2，*...
数据结构day4 双链表形式的学生管理系统
ctf1991的博客
07-25 297
数据结构day4 双链表形式的学生管理系统
哈希基础例题
小e的博客
04-07 819
文章目录例题一：子串查找例题二：字符串的删除操作例题三：字符串合并操作的应用 哈希前置知识请戳这里->哈希绪论 昨天我们对哈希的基础知识有了一定的了解，并已经知道了如何求子串、拼接子串的哈希值，今天我们就这两个操作分析一些基础例题，加深理解和掌握。 例题一：子串查找 LOJ #103. 子串查找 显然这是一道kmp算法的模板题 朴素的做法是枚举文本串的每一个位置作为模式串开始比较的位置。设枚举到主串的位置是iii，NNN为主串（即输入的第一行）的长度，MMM为模式串（即输入的第二行）的长度，sasas
ZROI Day1 测试总结
weixin_55355427的博客
08-04 220
考试时 因为只有三道题，5个小时，省选的模式，整体上对于我这种菜鸡时间还是比较充裕的，所以采用的是看一道题就开始码的模式，并没有全看完再去搞 因为是直接下发的文件，文件是按照音序排序的，并不是按照难度，就只能按照音序的顺序去看，但其实这就是题目的真正顺序 T1的暴力分一看就很好搞嘛，直接n^4枚举两个点，求最短距离就行，很快给码掉了，确保十分到手，没有继续深思，想着先把每道题的最基础暴力都这样搞掉再上难度吧 于是去把T2第一档分数状压了一下，码量和常数有一点大吧，但问题不大，也许是有些地方写复杂了 接着看T
数据分析 -Hive学习 Day5
最新发布
weixin_43902376的博客
01-02 395
LAG()函数是一个窗口函数，允许您从当前行向前看多行数据。与LEAD()函数类似，LEAD()函数对于计算同一结果集中当前行和后续行之间的差异非常有用。LAG语法： LAG(列名,[offset], [default_value]) OVER ( PARTITION BY 列名,... ORDER BY 列名 [ASC|DESC],... )
双向链表的实现(头插尾插和删除、遍历)
august5291的博客
09-12 772
关于双向链表和循环链表，维基上的解释是： 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 循环链表是一种链式存储结构，它的最后一个结点指向头结点，形成一个环。因此，从循环链表中的任何一个结点出发都能找到任何其他结点。循环链表的操作和单链表的操作基本一致，差别仅仅在于算法中的循环条件有所不同。 #include <stdio.h&g
有关head->next = p;和p=head->next;之间的区别
skychaofan的博客
07-09 2万+
#include #include #include typedef struct list { char *name; struct list *next; }List; int main(int argc, char *argv[]) { List *p = (List *)malloc(sizeof(List)); List *head = (Lis
链表中p->next=head->next;语句解析
浅然的专栏
09-30 3万+
在看到一些书上或者网上写的不管是单链表还是双向循环链表等，都会有p->next=q->next;或者p-next=head->next; 这里q是尾指针，head是头指针，p是指向新建结点的指针 该语句作用 这条语句的作用其实就是给新建结点找到它该有的位置 该语句在单链表下的头插法是必须存在的，而在双向循环下可有可无1.单链表的头插法下p-next=head->next;LinkLis
s->next=head; head=s;如何理解
我的目标是CEO，最近小目标是项目架构师！
10-16 4613
s->next=head; head=s;这两句中你认为head是头结点还是头指针？ 书上说的是头指针，然后这两句怎么解释？ 5 LinkNode *CreateLinkList()//头插入法无头结点建立线性表 { LinkNode *head,*p,*s; int x; int z=1,n=0; head=NULL; printf("\n\t\t建立一个线性表"); printf
数据结构整理（1）——三个抽象数据类型
n830001064的博客
03-07 6066
三个【抽象数据类型抽象数据类型（ADT）一、列表 ADT1. 实现列表ADT的两种数据结构：数组（array-based）和链表（linked list）2. 链表的结构3. 操作：二、栈 ADT1. 插入和删除都在同一个地方（在top），First In Last Out2. 栈的应用：3. 实现栈ADT的两种数据结构：数组（array-based）和链表（linked list）4. 栈的结构5. 操作三、队列 ADT1. 在最后面（rear）插入，在最前面（front）删除都在同一个地方（在to
C++ 链表的基本操作：头插入、尾插入、遍历、判断链表是否为空、清空、求长度、插入、删除、逆置链表和排序
ChanJose的博客
12-31 1308
// // main.cpp // List: // 链表的操作： // 1.头插入 // 2.尾插入建立链表; // 3.遍历链表； // 4.链表是否为空 // 5.清空链表 // 6.求链表的长度 // 7.排序 // 8.插入结点 // 9.删除结点：记得要释放删除节点的存储空间，避免内存泄漏 // 1...
原创 数据结构习题解析与实验指导第三章(栈和队列)课后算法设计题
学者的博客
08-28 1705
1.将编号0和1两个栈存放于一个数组空间V[m]中，栈底分别位于数组的两端。当0号栈的栈顶指针top[0] = -1时该栈为空，当1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长（见图3.2）。试编写双线初始化、栈空、栈满、进栈、出栈等算法的函数。双栈数据结构的定义如下。 typedef struct { int top[2], bot[2]; SElemType* V; int m; } DblStack; #include <iostream> #incl
运行时间分析：数据结构基础
在【数据结构】Day21的内容中，主要探讨了程序运行时间的计算和分析方法。首先，作者强调了在分析运行时间时采用简化模型，即忽略低阶项，只关注大O运行时间，这是一种常用的方法来估计程序的性能上界。大O分析确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值