数据结构day2

最新推荐文章于 2024-06-14 21:55:04 发布
最新推荐文章于 2024-06-14 21:55:04 发布
阅读量40 收藏
点赞数
文章标签： 数据结构 链表 c语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dshycorz/article/details/129499389
版权

链表的基础操作

相关操作

定义一个结点结构体

创建一个空的单链表（空的头结点）

头插法插入数据

遍历链表，打印数据

尾插法插入数据

判断链表是否为空

头删法删除数据，并返回数据

根据数据修改数据

根据位置修改数据

根据数据查找位置

根据位置查找数据

根据位置插入数据

释放链表

一、本程序的各种函数操作

1.定义一个结点结构体

//定义结点结构体
typedef struct node
{
    datatype data;
    struct node *next; 
}linklist;

2.创建一个空的单链表（空的头结点）

//创建空的有头的单链表
linklist* linklistCreate()
{
    linklist *head = (linklist*)malloc(sizeof(linklist));
    head->next = NULL;
    return head;
}

3.头插法插入数据

//头插法插入数据
void linklistHeadInsert(linklist *head,datatype value)
{
//创建一个temp结点，用于存储数据
    linklist*b temp = (linklist*)malloc(sizeof(linklist));
//存储value到temp结点的数据域
    temp->data = value;
//初始化temp结点的指针域
    temp->next = NULL;
    
//********************************************************//
//头插法两步走
//1.先用temp结点保存head指向的结点
    temp->next = head->next;
//2.将head指向temp结点
    head->next = temp;
    return ;
}

4.遍历链表，打印数据

//遍历链表，打印数据
void linklistPrint(linklist *head)
{
    while(head->next != NULL)
    {
        head = head->next;
        printf("%d ",head->data);        
    }
    putchar(10);
}

5.尾插法插入数据

//尾插法插入数据
void linklistTailInsert(linklist *head,datatype value)
{
    linklist *temp = (linklist *)malloc(sizeof(linklist));
    temp->data = value;
    temp->next = NULL;

    //尾插法两步走
    //1.遍历到链表最末端
    while(head->next != NULL)
    {
        head = head->next;
    }
    //2.将temp结点直接接入到head之后
    head->next = temp;
    temp->next = NULL;
}

6.判断链表是否为空

//判断链表是否为空
bool linklistIsEmpty(linklist *head)
{
    return head->next == NULL ? true : false;
}

7.头删法删除数据，并返回数据

//头删法删除数据，并返回数据
datatype linklistDelete(linklist *head)
{
//判断链表是否为空，若是则退出函数
    if(linklistIsEmpty(head))
    {
        printf("这个链表是空的\n");
        return (datatype)-1;
    }
}

//先存储数据，用于返回数据
datatype value = head->next->data;

//用于临时保存head的下一个结点（将要被删除），用于内存的释放
linklist *temp = head->next->next;
free(temp)
return value;
//删除结点

8.根据数据修改数据

//根据数据修改数据
void linklistModifyDataByData(linklist *head,datatype oldValue,datatype newvalue){
    if(linklistIsEmpty(head))
    {
        printf("这个链表是空的\n");
    return ;
    }

    while(haed->next != NULL)
    {
        head = head->next;
        if(head->data == oldvalue)
        {
            head->data = newvalue;
            return ;
        }
    }
    printf("没有找到所输入的数据\n");
    return ;
}

9.根据位置修改数据

void linklistModifyDataByPos(linklist *head,int pos,data value)
{
//保存位置信息
int i = 0;
    if(linklistIsEmpty(head))
    {
        printf("这个链表是空的\n");
    return ;
    }

if(pos < 1)
    {
        printf("所输入的位置不合法\n");
    }
while(head->next != NULL && i < pos)
    {
        head = head->next;
        i++;
    }
if(i == pos)
    {
        head->data = value;
    }
else
    {
        printf("没有找到所输入的位置\n");
        return ;
    }
    return ;
}

10.根据位置查找数据

//按照数据查找位置
int linklistSearchPosByData(linklist *head,datatype value)
{
    int pos = 0;
    if(linklistIsEmpty(head))
    {
        printf("这个链表是空的\n");
        return -1;
    }

    while(head->next != NULL)
    {
        head = head->next;
        pos ++;
        if(head->data == value)
        {
            return pos;
        }
    }
        printf("没有找到所输入的位置\n");
        return -1;
}

11.根据位置查找数据

//根据位置查找数据
datatype linklistSearchDataByPos(linklist *head,int pos)
 //保存位置信息
{
    int i = 0;
    if(linklistIsEmpty(head))
    {
        printf("这个链表是空的\n");
        return (datatype)-1;
    }
    
    if(pos < 1)
    {
        printf("所输入的位置不合法\n");
    }
    while(head->next != NULL && i < pos)
    {
        head = head->next;
        i++;
    }
    if(i == pos)
    {
        return head->data;
    }
    else
    {
        printf("没有找到所输入的位置\n");
        return (datatype)-1;
    }
 return (datatype)-1;   
}

12.根据位置插入数据

//根据位置插入数据
void linklistInsertDataByPos(linklist *head,int pos,datatype value)
{
    int i =  1;
    linklist *temp = (linklist *)malloc(sizeof(linklist));
    temp->data = value;
    temp->next = NULL;

        if(pos < 1)
    {
        printf("所输入的位置不合法\n");
        free(temp);
        return ;
    }
    while(head->next != NULL && i < pos)
    {
        head = head->next;
        i++;
    }
    if(i == pos)
    {
    temp->next = head->next;
    head->next = temp;
    }
    else
    {
        printf("没有找到所输入的位置\n");
        return (datatype)-1;   
    }
    return ;
}

13.释放链表

//释放链表
void linklistFree(linklist *head)
{
    linklist *temp = head->next;
    while(temp != NULL)
    {
        free(head);
        head = temp;
        temp = temp->next;
    }
    free(head);
    return ;
}

14.直接插入排序

//直接插入排序
void linklistSortInsert(linklist *head, datatype value)
{
    linklist *temp = (linklist *)malloc(sizeof(linklist));
    temp->data = value;
    temp->next = NULL;

    while(head->next != NULL && head->next->data < value)
    {
        head = head->next;
    }
//头插法
    temp->next = head->next;
    head->next = temp;
}

15.链表的翻转

//链表的翻转
void linklistReverse(linklist *head)
{
    linklist *p,*q;
    p = head->next;
    head = NULL;
    while(p != NULL)
    {
        q = p;
        p = p->next;

        q->next = head->next;
        head->next = q;
    }
    return ;
}

16.按照链表数据大小排序

//按照数据大小排序
void linklistOrder(linklist *head)
{
    linklist *p,*q;
    p = head->next;
    head->next = NULL;
    while(p != NULL)
    {
        q = p;
        p = p->next;

    while(head->next != NULL && head->next->data < q->data)
    {
        head = head->next;
    }
//头插法
    q->next = head->next;
    head->next = q;
    }
}

二、分文件编译

1.linklist.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

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

typedef int datatype;

//定义结点结构体
typedef struct node
{
    datatype data;
    struct node *next; 
}linklist;

linklist* linklistCreate();
void linklistHeadInsert(linklist *head, datatype value);
void linklistPrint(linklist *head);
void linklistTailInsert(linklist *head, datatype value);
bool linklistIsEmpty(linklist *head);
datatype linklistDelete(linklist *head);
void linklistModifyDataByData(linklist *head, datatype oldValue, datatype newValue);
void linklistModifyDataByPos(linklist *head, int pos, datatype value);
int linklistSearchPosByData(linklist *head, datatype value);
datatype linklistSearchDataByPos(linklist *head, int pos);
void linklistInsertDataByPos(linklist *head, int pos, datatype value);
void linklistFree(linklist *head);
void linklistSortInsert(linklist *head, datatype value);
void linklistReverse(linklist *head);

#endif

2.linklist.c

#include"linklist.h"

//创建空的有头的单链表
linklist* linklistCreate()
{
    linklist *head = (linklist *)malloc(sizeof(linklist));
    head->next = NULL;
    return head;
}

//头插法插入数据
void linklistHeadInsert(linklist *head, datatype value)
{
    //创建一个temp结点，用于存储数据
    linklist* temp = (linklist *)malloc(sizeof(linklist));
    //存储alue到temp结点的数据域
    temp->data = value;
    //初始化temp结点的指针域
    temp->next = NULL;

    //头插法两步走
    //1.先用temp结点保存head指向的结点
    temp->next = head->next;
    //2.将head指向temp结点
    head->next = temp;
    return ;
}

//打印链表数据
void linklistPrint(linklist *head)
{
    while(head->next != NULL)
    {
        head = head->next;
        printf("%d ", head->data);
    }
    putchar(10);
}

//尾插法插入数据
void linklistTailInsert(linklist *head, datatype value)
{
    linklist *temp = (linklist *)malloc(sizeof(linklist));
    temp->data = value;
    temp->next = NULL;


    //尾插法两步走
    //1.遍历到链表最末端
    while(head->next != NULL)
    {
        head = head->next;
    }

    //2.将temp结点直接接入到head之后
    head->next = temp;
    temp->next = NULL;
    return ;
}

//判断链表是否为空
bool linklistIsEmpty(linklist *head)
{
    return head->next == NULL ? true : false;
}

//头删法删除数据，并返回数据
datatype linklistDelete(linklist *head)
{
    //判断链表是否为空，若是则退出函数
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return (datatype)-1;
    }
    //先存储数据，用于返回数据
    datatype value = head->next->data;

    //用于临时保存head的下一个结点（将要被删除），用于内存的释放
    linklist *temp = head->next;

    //删除结点
    head->next = head->next->next;
    free(temp);
    return value;
}

//根据数据修改数据
void linklistModifyDataByData(linklist *head, datatype oldValue, datatype newValue)
{
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return ;
    }

    while(head->next != NULL)
    {
        head = head->next;
        if(head->data == oldValue)
        {
            head->data = newValue;
            return ;
        }
    }
    printf("the data you choosed is not exit\n");
    return ;
}

//根据位置修改数据
void linklistModifyDataByPos(linklist *head, int pos, datatype value)
{
    //保存位置信息
    int i = 0;
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return ;
    }

    if(pos < 1)
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
    }
    while(head->next != NULL && i < pos)
    {
        head = head->next;
        i++;
    }
    if(i == pos)
    {
        head->data = value;
    }
    else
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
        return ;
    }
    return ;
}

//按照数据查找位置
int linklistSearchPosByData(linklist *head, datatype value)
    {
    int pos = 0;
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return -1;
    }
    while(head->next != NULL)
    {
        head = head->next;
        pos ++;
        if(head->data == value)
        {
            return pos;
        }
    }
    printf("the value you choosed(%d) is not exist\n",value);
    return -1;
}

//根据位置查找数据
datatype linklistSearchDataByPos(linklist *head, int pos)
    {
    //保存位置信息
    int i = 0;
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return (datatype)-1;
    }

    if(pos < 1)
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
    }
    while(head->next != NULL && i < pos)
    {
        head = head->next;
        i++;
    }
    if(i == pos)
    {
        return head->data;
    }
    else
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
        return (datatype)-1;
    }
    return (datatype)-1;
}

//根据位置插入数据
void linklistInsertDataByPos(linklist *head, int pos, datatype value)
{
    int i = 1;
    linklist *temp = (linklist *)malloc(sizeof(linklist));
    temp->data = value;
    temp->next = NULL;

    if(pos < 1)
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
        free(temp);
        return ;
    }
    while(head->next != NULL && i < pos)
    {
        head = head->next;
        i++;
    }
    if(i == pos)
    {
        temp->next = head->next;
        head->next = temp;
    }
    else
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
        return ;
    }
    return ;
}

//释放链表
void linklistFree(linklist *head)
{
    linklist *temp = head->next;
    while(temp != NULL)
    {
        free(head);
        head = temp;
        temp = temp->next;
    }
    free(head);
    return ;
}

//直接插入排序
void linklistSortInsert(linklist *head, datatype value)
{
    linklist *temp = (linklist *)malloc(sizeof(linklist));
    temp->data = value;
    temp->next = NULL;

    while(head->next != NULL && head->next->data < value)
    {
        head = head->next;
    }
    //头插法
    temp->next = head->next;
    head->next = temp;
}

//链表的翻转
void linklistReverse(linklist *head)
{
    linklist *p, *q;

    p = head->next;

    head->next = NULL;

    while(p != NULL)
    {
        q = p;
        p = p->next;

        q->next = head->next;
        head->next = q;
    }
    return ;
}

3.main.c

#include"linklist.h"
int main(int argc, char const *argv[])
{
    linklist *head = linklistCreate();
    linklistHeadInsert(head, 100);
    linklistHeadInsert(head, 200);
    linklistHeadInsert(head, 300);
    linklistHeadInsert(head, 400);
    linklistHeadInsert(head, 500);
    linklistPrint(head);
    linklistTailInsert(head, 600);
    linklistPrint(head);
    printf("value deleted : %d\n", linklistDelete(head));
    linklistPrint(head);
    linklistModifyDataByData(head, 100, 777);
    linklistPrint(head);
    linklistModifyDataByPos(head, 5, 999);
    linklistPrint(head);
    linklistFree(head);
    linklist *head1 = linklistCreate();
    linklistSortInsert(head1, 200);
    linklistSortInsert(head1, 700);
    linklistSortInsert(head1, 100);
    linklistSortInsert(head1, 500);
    linklistSortInsert(head1, 300);
    linklistPrint(head1);
    linklistReverse(head1);
    linklistPrint(head1);
    linklistFree(head1);
    return 0;
}

4.Makefile

OBJ=linklist

${OBJ}:${OBJ}.o main.o

%*.o:%*.c

.PHONY:clean
clean:
    ${RM} *.o ${OBJ} core

三、使用一个文件编译

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

typedef int datatype;

//定义结点结构体
typedef struct node
{
    datatype data;
    struct node *next; 
}linklist;

linklist* linklistCreate();
void linklistHeadInsert(linklist *head, datatype value);
void linklistPrint(linklist *head);
void linklistTailInsert(linklist *head, datatype value);
bool linklistIsEmpty(linklist *head);
datatype linklistDelete(linklist *head);
void linklistModifyDataByData(linklist *head, datatype oldValue, datatype newValue);
void linklistModifyDataByPos(linklist *head, int pos, datatype value);
int linklistSearchPosByData(linklist *head, datatype value);
datatype linklistSearchDataByPos(linklist *head, int pos);
void linklistInsertDataByPos(linklist *head, int pos, datatype value);
void linklistFree(linklist *head);
void linklistSortInsert(linklist *head, datatype value);
void linklistReverse(linklist *head);

#include"linklist.h"

//创建空的有头的单链表
linklist* linklistCreate()
{
    linklist *head = (linklist *)malloc(sizeof(linklist));
    head->next = NULL;
    return head;
}

//头插法插入数据
void linklistHeadInsert(linklist *head, datatype value)
{
    //创建一个temp结点，用于存储数据
    linklist* temp = (linklist *)malloc(sizeof(linklist));
    //存储alue到temp结点的数据域
    temp->data = value;
    //初始化temp结点的指针域
    temp->next = NULL;

    //头插法两步走
    //1.先用temp结点保存head指向的结点
    temp->next = head->next;
    //2.将head指向temp结点
    head->next = temp;
    return ;
}

//打印链表数据
void linklistPrint(linklist *head)
{
    while(head->next != NULL)
    {
        head = head->next;
        printf("%d ", head->data);
    }
    putchar(10);
}

//尾插法插入数据
void linklistTailInsert(linklist *head, datatype value)
{
    linklist *temp = (linklist *)malloc(sizeof(linklist));
    temp->data = value;
    temp->next = NULL;


    //尾插法两步走
    //1.遍历到链表最末端
    while(head->next != NULL)
    {
        head = head->next;
    }

    //2.将temp结点直接接入到head之后
    head->next = temp;
    temp->next = NULL;
    return ;
}

//判断链表是否为空
bool linklistIsEmpty(linklist *head)
{
    return head->next == NULL ? true : false;
}

//头删法删除数据，并返回数据
datatype linklistDelete(linklist *head)
{
    //判断链表是否为空，若是则退出函数
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return (datatype)-1;
    }
    //先存储数据，用于返回数据
    datatype value = head->next->data;

    //用于临时保存head的下一个结点（将要被删除），用于内存的释放
    linklist *temp = head->next;

    //删除结点
    head->next = head->next->next;
    free(temp);
    return value;
}

//根据数据修改数据
void linklistModifyDataByData(linklist *head, datatype oldValue, datatype newValue)
{
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return ;
    }

    while(head->next != NULL)
    {
        head = head->next;
        if(head->data == oldValue)
        {
            head->data = newValue;
            return ;
        }
    }
    printf("the data you choosed is not exit\n");
    return ;
}

//根据位置修改数据
void linklistModifyDataByPos(linklist *head, int pos, datatype value)
{
    //保存位置信息
    int i = 0;
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return ;
    }

    if(pos < 1)
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
    }
    while(head->next != NULL && i < pos)
    {
        head = head->next;
        i++;
    }
    if(i == pos)
    {
        head->data = value;
    }
    else
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
        return ;
    }
    return ;
}

//按照数据查找位置
int linklistSearchPosByData(linklist *head, datatype value)
    {
    int pos = 0;
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return -1;
    }
    while(head->next != NULL)
    {
        head = head->next;
        pos ++;
        if(head->data == value)
        {
            return pos;
        }
    }
    printf("the value you choosed(%d) is not exist\n",value);
    return -1;
}

//根据位置查找数据
datatype linklistSearchDataByPos(linklist *head, int pos)
    {
    //保存位置信息
    int i = 0;
    if(linklistIsEmpty(head))
    {
        printf("the linklist is empty\n");
        return (datatype)-1;
    }

    if(pos < 1)
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
    }
    while(head->next != NULL && i < pos)
    {
        head = head->next;
        i++;
    }
    if(i == pos)
    {
        return head->data;
    }
    else
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
        return (datatype)-1;
    }
    return (datatype)-1;
}

//根据位置插入数据
void linklistInsertDataByPos(linklist *head, int pos, datatype value)
{
    int i = 1;
    linklist *temp = (linklist *)malloc(sizeof(linklist));
    temp->data = value;
    temp->next = NULL;

    if(pos < 1)
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
        free(temp);
        return ;
    }
    while(head->next != NULL && i < pos)
    {
        head = head->next;
        i++;
    }
    if(i == pos)
    {
        temp->next = head->next;
        head->next = temp;
    }
    else
    {
        printf("the pos you choosed(%d) is invalid\n", pos);
        return ;
    }
    return ;
}

//释放链表
void linklistFree(linklist *head)
{
    linklist *temp = head->next;
    while(temp != NULL)
    {
        free(head);
        head = temp;
        temp = temp->next;
    }
    free(head);
    return ;
}

//直接插入排序
void linklistSortInsert(linklist *head, datatype value)
{
    linklist *temp = (linklist *)malloc(sizeof(linklist));
    temp->data = value;
    temp->next = NULL;

    while(head->next != NULL && head->next->data < value)
    {
        head = head->next;
    }
    //头插法
    temp->next = head->next;
    head->next = temp;
}

//链表的翻转
void linklistReverse(linklist *head)
{
    linklist *p, *q;

    p = head->next;

    head->next = NULL;

    while(p != NULL)
    {
        q = p;
        p = p->next;

        q->next = head->next;
        head->next = q;
    }
    return ;
}

int main(int argc, char const *argv[])
{
    linklist *head = linklistCreate();
    linklistHeadInsert(head, 100);
    linklistHeadInsert(head, 200);
    linklistHeadInsert(head, 300);
    linklistHeadInsert(head, 400);
    linklistHeadInsert(head, 500);
    linklistPrint(head);
    linklistTailInsert(head, 600);
    linklistPrint(head);
    printf("value deleted : %d\n", linklistDelete(head));
    linklistPrint(head);
    linklistModifyDataByData(head, 100, 777);
    linklistPrint(head);
    linklistModifyDataByPos(head, 5, 999);
    linklistPrint(head);
    linklistFree(head);
    linklist *head1 = linklistCreate();
    linklistSortInsert(head1, 200);
    linklistSortInsert(head1, 700);
    linklistSortInsert(head1, 100);
    linklistSortInsert(head1, 500);
    linklistSortInsert(head1, 300);
    linklistPrint(head1);
    linklistReverse(head1);
    linklistPrint(head1);
    linklistFree(head1);
    return 0;
}

霜华初柒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构 Day 3 主函数
06-12
main.c
数据结构 Day 3 预处理
06-12
head.h
数据结构 day6
qq_51722235的博客
08-30 894
顺序栈/链栈、顺序队列
计算机考研数据结构代码题总结--Day01
brotherand的博客
10-05 1万+
计算机考研数据结构代码题总结 链表 题目1 在带头节点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的节点不唯一，试编写算法实现。 .算法思路 1、图解 . 2、图解含义描述 实现带头节点的单链表的删除指定值的操作。 首先需要定义三个指针，其中pre指向的是头节点，p初始化指向为L头节点的下一个节点，q作为操作指针。如图所示 算法的思想便是对单链表进行遍历 遍历过程中对p指针的数据域进行比对 相等的数据域与X相等，那么便要进行删除操作。 关键操作 1、. 删除操作首先需要将q操作指针指向p
数据结构与算法Day2
nendie1的博客
01-26 1174
顺序表的基本形式 1.顺序表结构 包含顺序表表头信息以及数据区两个部分组成 2.顺序表两种实现形式 顺序表组成部分：表头信息以及数据区 表头信息包括容量以及元素个数 数据区既包含数据 一体式结构：表头信息+数据区 两个区域连接在一起 分离式结构：表头信息一个顺序表 数据区一个顺序表 其中表头信息有一个存储数据区第一个元素的物理地址 两种结构相比之下，分离式结构更适合修改数据，进行操作时时间复杂度比一体式结构要少 3.元素存储区替换 一体式结构在元素要修改时，需要改变整个顺序表的信息，即.
数据结构--day2
热门推荐
不更了，主打一个陪伴
01-04 1万+
数据结构--day2
计算机数据结构代码题----Day02
brotherand的博客
10-06 5207
计算机数据结构代码题----Day02 顺序表代码题 题目01 从顺序表中删除其数值在给定数值为s与t之间，包含(s和t)，要求（s<t）的所有元素，如果s或t的顺序不合理或者顺序表为空，则显示出错误信息。 1、算法图解 如下图 思路： 扫描顺序表，将S->t的数进行搜索， 扫描到该范围内进行记录数K+1， 若不是在s到t之间范围的数，那么就要进行前移动k个单位长度，与上一篇的删除数据进行设计。 实现步骤 1、核心代码： int k = 0; while(i<L.length){
数据结构第一天
C/C++/Linux/MySQL
11-23 1231
研究数据结构第一天——Day 1 今天是我自学数据结构的第一天，学习了几个名词，说实话真心没看懂。 第一步，我先看了前言，据作者说c语言不是描述数据结构的好工具，所以虽然这本书是以c语言为工具讲述的数据结构但是，加入c++的工具比如引用调用&。 第二步，本书向我讲解了什么叫抽象数据类型，说实话真心没看懂，但是也有些理解，就是抽象数据结构大概就是，一个数学模型但是还有其对其操作。 解决问题...
LeetCode刷题笔记-数据结构-day16
小皮皮LL的博客
02-01 1915
文章目录LeetCode刷题笔记-数据结构-day16199. 二叉树的右视图1.题目描述2.解题思路3.代码113. 路径总和 II1.题目描述2.解题思路3.代码450. 删除二叉搜索树中的节点1.题目描述2.解题思路3.代码 LeetCode刷题笔记-数据结构-day16 199. 二叉树的右视图 1.题目描述 原题链接：199. 二叉树的右视图 2.解题思路 算法：bfs+queue 具体步骤： 用一个队列queue存储每层的节点 每次遍历每层节点，只将队列的第一个加入答案 然后将该层的所有
数据结构与算法之美
william_n的博客
08-31 4798
1.介绍 数据结构和算法解决的是如何更省、更快地存储和处理数据的问题. 数据结构和算法是相辅相成的。数据结构是为算法服务的，算法要作用在特定的数据结构之上。 因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构。比如，因为数组具有随机访问的特点，常用的二分查找算法需要用数组来存储数据。但如果我们选择链表这种数据结构，二分查找算法就无法工作了，因为链表并不支持随机访问。数...
考研数据结构算法题总结
热心上单小张的博客
10-18 4505
考研数据结构100天 Day1：在带头结点的单链表L中，删除所有值为X的节点，并释放其空间，假设值为的X节点不唯一，试编写算法以实现上述操作 void Del-X(LinkList &L,int x){ LNode *p=L->next; LNode *pre=L; LNode *q; while(p!=NULL){ if(p->data==x){ q=p; p=p->next; pre->next=p; free(q); }else{
LeetCode刷题笔记-数据结构-day21
小皮皮LL的博客
02-04 2204
文章目录LeetCode刷题笔记-数据结构-day21451. 根据字符出现频率排序1.题目2.解题思路3.代码973. 最接近原点的 K 个点1.题目2.解题思路3.代码 LeetCode刷题笔记-数据结构-day21 451. 根据字符出现频率排序 1.题目 原题链接：451. 根据字符出现频率排序 2.解题思路 算法：小根堆 具体步骤： 我们建立一个以pair<int,int>存储的小根堆，会以pair的第一个位置元素从小到大排序 pair的第一个位置存储所有点距离原点的距离（这里
12.20 day1 数据结构
12-20
12.20 day1 数据结构
数据结构 Day 3 功能函数
06-12
function.c
【数据结构】Day71
08-03
因此，我们将整棵树看作是四棵树由三个节点连接【数据结构】Day7如图所，恰好树B或树C中有棵D深两层（除它们都为空），但是我们不能确定是哪棵为了重新平衡，我们不
数据结构之链表的经典笔试题
我要学编程的博客
06-12 941
移除链表元素 反转链表 链表的中间节点 返回倒数第K个节点 快慢指针原理分析 合并两个有序链表 链表的回文 链表分割 相交链表 环形链表
ACM算法学习路线、清单
qq_45477639的博客
06-10 1898
算法与数据结构学习路线
C++:十大排序
2301_80418172的博客
06-12 969
十大排序CPP
数据结构02 队列及其应用【C++实现】
最新发布
bigbigli的博客
06-14 434
队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，前端一般叫做队头，后端叫队尾。队列就像学校做操站队一样，来的人一个一个往后站，走的时候从前往后一个一个走。
数据结构C语言day
08-27
- *1* *2* *3* [数据结构-C语言代码 day 5-多项式加法](https://blog.csdn.net/yydslty/article/details/124612624)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值