1. Toy模板网首页
  2. > Toy博客

数据结构day5（2023.7.19）

7月前 作者：小徐今天认真学习了嘛 分类：Toy博客 阅读(23) 违法举报

这篇具有很好参考价值的文章主要介绍了数据结构day5（2023.7.19）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、Xmind整理：

数据结构day5（2023.7.19）,数据结构 

双向链表的插入与删除：

数据结构day5（2023.7.19）,数据结构 

二、课上练习：

 练习1：单链表任意元素删除

/*
 * function:    按元素删除
 * @param [ in] 
 * @param [out] 
 * @return      返回堆区首地址
 */
Linklist delete_by_data(datatype key,Linklist L)
{
    
    //1,先根据key查找位置
    int delete_pos=search_by_data(key,L);
    if(delete_pos==-1)
        return L;
    //2,元素存储
    L=delete_by_pos(delete_pos,L);
    return L;
 
/*
    int pos=0;
    Linklist p=L;
    while(L!=NULL)
    {
        pos++;
        if(L->data==key)
        {    
            p=delete_by_pos(pos,p);
            pos--;
        }
        else
        {
            L=L->next;
        }
    }
    return p;*/

}

练习2： 单链表任意元素查找

/*
 * function:    元素查找
 * @param [ in] 
 * @param [out] 
 * @return      返回位置，失败-1
 */
int search_by_data(datatype key,Linklist L)
{
    //1,判断是否为空
    if(NULL==L)
    {
        return -1;
    }
    //2,查找元素key
    int pos=0;
    while(L!=NULL)
    {
        pos++;
        if(L->data==key)
        {
            return pos;
        }
        L=L->next;
    }
    return -1;
}

练习3： 单链表逆置

数据结构day5（2023.7.19）,数据结构

/*
 * function:    逆置
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
Linklist rev_lInklist(Linklist L)
{
    //判断链表是否为空
    //判断链表甚至有一个节点
    if(NULL == L || L->next==NULL)
    {
        return L;
    }
    //链表有多个节点
    Linklist p=L->next;
    int len=Len_linklist(L)-1;
    L->next=NULL;
    for(int i=0;i<len;i++)
    {
        Linklist t=p;
        p=p->next;
        t->next=L;
        L=t;
    }
    return L;
}

练习4：单链表排序（冒泡排序）

数据结构day5（2023.7.19）,数据结构

/*
 * function:    冒泡排序
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void Bubble(Linklist L)
{
    //1,判断是否为空
    //2，判断如果链表只有一个节点
    if(NULL==L || L->next==NULL)
    {
        return ;
    }
    //冒泡排序
    int len=Len_linklist(L);
    Linklist p;
    int i,j;
    for( i=1;i<len;i++)
    {
        for( j=0,p=L;j<len-i;j++,p=p->next)
        {
            if(p->data>p->next->data)
            {
                datatype t=p->data;
                p->data=p->next->data;
                p->next->data=t;
            }
        }
    }
}

练习5： 单链表释放

/*
 * function:    释放
 * @param [ in] 
 * @param [out] 
 * @return      返回堆去首地址
 */
Linklist free_space(Linklist L)
{
    if(NULL==L)
    {
        return NULL;
    }
    int len=Len_linklist(L);
    for(int i=0;i<len;i++)
    {
        L=delete_head(L);
    }
    return L;
}

练习6：单向循环链表节点创建 

/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist create_node()
{
Linklist node=(Linklist)malloc(sizeof(struct Node));
    if(NULL==node)
    return NULL;
node->data=0;
node->next=node;//循环链表的每个节点指针域指向自己
    return node;//0x10
}

练习7：单向循环链表头插 

数据结构day5（2023.7.19）,数据结构

/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0　失败返回-1
 */
Linklist loop_insert_head(datatype e,Linklist L)
{
	//在堆区创建一个节点
	Linklist node=create_node();//在堆区申请一个节点
	if(node==NULL)
		return L;
	if(NULL==L)
	{
		L=node;
		node->data=e;
	}
	else
	{
		node->next=L->next;
		L->next=node;
		node->data=L->data;
		L->data=e;
	}
	return L;//因为自定义的函数指针的改变不影响实参，需要返回
}

练习8：单向循环链表的尾插

数据结构day5（2023.7.19）,数据结构

/*
 * function:    尾部插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist loop_insert_rear(datatype e,Linklist L)
{
	Linklist s=create_node();
	s->data=e;
	if(L==NULL)
	{
		L=s;
	}
	else
	{
		Linklist rear=L;
		while(rear->next!=L)
		{
			rear=rear->next;
		}
		rear->next=s;
		s->next=L;
	}
	return L;
}

练习9：单向循环链表的头删

数据结构day5（2023.7.19）,数据结构

/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist loop_delete_head(Linklist L)
{
	//判断链表是否为空
	if(NULL==L)
	{
		return L;
	}
	if(L->next==L)
	{
		free(L);
		L=NULL;
	}
	else
	{
		Linklist q=L->next;
		L->data=q->data;
		L->next=q->next;
		free(q);
		q=NULL;
	}
	return L;
}

 练习10：单向循环链表的尾删

数据结构day5（2023.7.19）,数据结构

/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist delete_rear(Linklist L)
{
	//1.判断链表是否为空
	if(NULL==L)
	{
		return NULL;
	}
	//2.判断如果链表只有一个节点
	else if(L->next==L)
	{
		free(L);
		L=NULL;
	}
	else
	{
		//3.有多个节点
		//循环倒数第二个节点
		Linklist second=L;
		while(second->next->next!=L)
		{
			second=second->next;
		}
		free(second->next);
		second->next=L;
	}
	return L;
}

练习11：单向循环链表的遍历

数据结构day5（2023.7.19）,数据结构 

/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int loop_output(Linklist L)
{
	//判断是否创建
	//判断是否为空
	if(NULL==L)
	{
		return -1;
	}
	Linklist p=L;
	do{
		printf("%d\t",p->data);
		p=p->next;
	}while(p!=L);
	puts("");
}

练习12：约瑟夫环

约瑟夫环：用循环链表编程实现约瑟夫问题
n个人围成一圈，从某人开始报数1, 2, …, m，数到m的人出圈，然后从出圈的下一个人(m+1)开始重复此过程，直到全部人出圈，于是得到一个出圈人员的新序列
如当n=8，m=4时，若从第一个位置数起，则所得到的新的序列 为4, 8, 5, 2, 1, 3, 7, 6。

数据结构day5（2023.7.19）,数据结构 

/*
 * function:    约瑟夫环
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void Joseph(Linklist L,int n,int m)
{
	Linklist p=L;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m-2;j++)
		{
			p=p->next;
		}
		Linklist q=p->next;
		p->next=q->next;
		printf("%d\t",q->data);
		free(q);
		q=NULL;
		p=p->next;
	}
	printf("\n");
}

单向循环链表目前整体代码：

head.h：

#ifndef __HEAD_H__
#define __HEAD_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef int datatype;
//定义单链表节点结构体
typedef struct Node
{
	//数据域：数据元素
	datatype data;
	//指针域：存储下一个节点的地址
	struct Node *next;	
}*Linklist;
Linklist create_node();
Linklist loop_insert_head(datatype e,Linklist L);
int loop_output(Linklist L);
Linklist loop_insert_rear(datatype e,Linklist L);
Linklist loop_delete_head(Linklist L);
Linklist delete_rear(Linklist L);
void Joseph(Linklist L,int n,int m);

#endif

test.c：

#include "head.h"
/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist create_node()
{
	Linklist node=(Linklist)malloc(sizeof(struct Node));
	if(NULL==node)
		return NULL;
	node->data=0;
	node->next=node;//循环链表的每个节点指针域指向自己
	return node;
}
/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0　失败返回-1
 */
Linklist loop_insert_head(datatype e,Linklist L)
{
	//在堆区创建一个节点
	Linklist node=create_node();//在堆区申请一个节点
	if(node==NULL)
		return L;
	if(NULL==L)
	{
		L=node;
		node->data=e;
	}
	else
	{
		node->next=L->next;
		L->next=node;
		node->data=L->data;
		L->data=e;
	}
	return L;//因为自定义的函数指针的改变不影响实参，需要返回
}
/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int loop_output(Linklist L)
{
	//判断是否创建
	//判断是否为空
	if(NULL==L)
	{
		return -1;
	}
	Linklist p=L;
	do{
		printf("%d\t",p->data);
		p=p->next;
	}while(p!=L);
	puts("");
}
/*
 * function:    尾部插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist loop_insert_rear(datatype e,Linklist L)
{
	Linklist s=create_node();
	s->data=e;
	if(L==NULL)
	{
		L=s;
	}
	else
	{
		Linklist rear=L;
		while(rear->next!=L)
		{
			rear=rear->next;
		}
		rear->next=s;
		s->next=L;
	}
	return L;
}
/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist loop_delete_head(Linklist L)
{
	//判断链表是否为空
	if(NULL==L)
	{
		return L;
	}
	if(L->next==L)
	{
		free(L);
		L=NULL;
	}
	else
	{
		Linklist q=L->next;
		L->data=q->data;
		L->next=q->next;
		free(q);
		q=NULL;
	}
	return L;
}
/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist delete_rear(Linklist L)
{
	//1.判断链表是否为空
	if(NULL==L)
	{
		return NULL;
	}
	//2.判断如果链表只有一个节点
	else if(L->next==L)
	{
		free(L);
		L=NULL;
	}
	else
	{
		//3.有多个节点
		//循环倒数第二个节点
		Linklist second=L;
		while(second->next->next!=L)
		{
			second=second->next;
		}
		free(second->next);
		second->next=L;
	}
	return L;
}
/*
 * function:    约瑟夫环
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void Joseph(Linklist L,int n,int m)
{
	Linklist p=L;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m-2;j++)
		{
			p=p->next;
		}
		Linklist q=p->next;
		p->next=q->next;
		printf("%d\t",q->data);
		free(q);
		q=NULL;
		p=p->next;
	}
	printf("\n");
}

main.c：

#include "head.h"
int main(int argc, const char *argv[])
{
	Linklist L=NULL;
	/*
	int n;
	datatype e;
	printf("please enter n:");
	scanf("%d",&n);

	for(int i=0;i<n;i++)
	{
		printf("please enter element:");
		scanf("%d",&e);
		//头插：在头指针当前节点插入
		L=loop_insert_head(e,L);
	}
	loop_output(L);

	//尾部插入
	for(int i=0;i<n;i++)
	{
		printf("please enter element:");
		scanf("%d",&e);
	    L=loop_insert_rear(e,L);
	}
    loop_output(L);
	
	//循环链表
	//loop_output(L);
	//头删
	//L=loop_delete_head(L);
	//loop_output(L);

	//尾删
	//L=delete_rear(L);
	//loop_output(L);
	*/

	int n,m;//n表示节点的总个数，m表示几个一出圈
	printf("输入一共有多个人：");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		L=loop_insert_rear(i+1,L);
	}

	//约瑟夫环
	printf("输入几个一出圈：");
	scanf("%d",&m);
	Joseph(L,n,m);
	return 0;
}

数据结构day5（2023.7.19）,数据结构  

练习13：双向链表节点创建

/*
 * function:    创建节点
 * @param [ in] 
 * @param [out] 
 * @return      返回节点的地址
 */
DoubleLink create_node()
{
DoubleLink node=(DoubleLink)malloc(sizeof(struct Node));
    if(NULL==node)
    return NULL;
    //对新节点的数据域初始化
    strcpy(node->data,"");
    //对指针域赋值
node->next=node->prev=NULL;
    return node;
}

练习14：双向链表头插

数据结构day5（2023.7.19）,数据结构

/*
 * function:    双向链表头插
 * @param [ in] 
 * @param [out] 
 * @return      返回链表
 */
DoubleLink insert_head(datatype e,DoubleLink L)
{
    //1,创建新节点s
DoubleLink s=create_node();
    if(NULL==s)
    return L;
    
    strcpy(s->data,e);
    if(NULL !=L)
    {
    s->next=L;
    L->prev=s;
    }
    L=s;
    return L;
}

练习15：双向链表尾插

数据结构day5（2023.7.19）,数据结构

/*
 * function:    尾部插入
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink insert_rear(datatype e,DoubleLink L)
{
    //1,创建新节点s
DoubleLink s=create_node();
    if(NULL==s)
    return L;
    strcpy(s->data,e);
    //链表为空
    if(NULL==L)
    {
    L=s;
    return L;
    }
    
    //表示存在多个节点
    //找到尾部节点
DoubleLink rear=L;
    while(rear->next!=NULL)
    {
    rear=rear->next;
    }
rear->next=s;
s->prev=rear;
    return L;
}

练习16：双向链表头删

数据结构day5（2023.7.19）,数据结构

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink delete_head(DoubleLink L)
{
    //1,如果链表为空，
    if(NULL==L)
    return L;
    //2,判断链表只有一个节点
    if(NULL==L->next)
    {
    free(L);
    L=NULL;
    return L;
    }
    //3,有多个节点
DoubleLink q=L->next;
    strcpy(L->data,q->data);
L->next=q->next;
    if(q->next!=NULL)
    q->next->prev=L;
    free(q);
q=NULL;
    return L;
}

练习17：双向链表尾删

数据结构day5（2023.7.19）,数据结构

 

/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink delete_rear(DoubleLink L)
{
    //1,如果链表为空，
    if(NULL==L)
    return L;
    //2,判断链表只有一个节点
    if(NULL==L->next)
    {
    free(L);
    L=NULL;
    return L;
    }
    //3,存在多个节点
    //找到倒数第一个节点
DoubleLink rear=L;
    while(rear->next!=NULL)
    rear=rear->next;

rear->prev->next=NULL;
    free(rear);
rear=NULL;
    return L;
}

练习18：双向链表遍历

数据结构day5（2023.7.19）,数据结构

/*
 * function:    循环输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(DoubleLink L)
{
    //1,判断链表是否为空
    if(NULL==L)
    {
    return;
    }
    //正向遍历
    puts("正向遍历");
    while(L->next!=NULL)
    {
    printf("%s\t",L->data);
    L=L->next;
    }
    printf("%s\t",L->data);
    puts("\n逆向遍历");
    while(L!=NULL)
    {
        
    printf("%s\t",L->data);
    L=L->prev;
    }
    puts("");
    
}

双向链表目前整体代码：

head.h：

#ifndef __HEAD_H
#define __HEAD_H

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char datatype[20];//datatype-->char [20]

//定义双向链表节点的结构体
typedef struct Node
{
	//数据域：数据元素
	datatype data;
	//指针域：下一个节点的地址
	struct Node *next;
	//指针域：上一个节点的地址
	struct Node *prev;
}*DoubleLink;

DoubleLink create_node();
DoubleLink insert_head(datatype e,DoubleLink L);
void output(DoubleLink L);
DoubleLink insert_rear(datatype e,DoubleLink L);
DoubleLink delete_head(DoubleLink L);
DoubleLink delete_rear(DoubleLink L);

#endif

test.c：

#include "double_head.h"
/*
 * function:    创建节点
 * @param [ in] 
 * @param [out] 
 * @return      返回节点位置
 */
DoubleLink create_node()
{
	DoubleLink node=(DoubleLink)malloc(sizeof(struct Node));
	if(NULL==node)
		return NULL;
	//对新节点的数据域初始化
	strcpy(node->data,"");
	//对指针域赋值
	node->next=node->prev=NULL;
	return node;
}
/*
 * function:    双向链表头插
 * @param [ in] 
 * @param [out] 
 * @return      返回链表
 */
DoubleLink insert_head(datatype e,DoubleLink L)
{
	//1.创建新节点s
	DoubleLink s=create_node();
	if(NULL==s)
		return L;
	strcpy(s->data,e);
	if(NULL!=L)
	{
		s->next=L;
		L->prev=s;
	}
	L=s;
	return L;
}
/*
 * function:    循环输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(DoubleLink L)
{
	//1.判断链表是否为空
	if(NULL==L)
	{
		return;
	}
	//正向遍历
	puts("正向遍历：");
	while(L->next!=NULL)
	{
		printf("%s\t",L->data);
		L=L->next;
	}
	printf("%s\t",L->data);
	puts("");
	//逆向遍历
	puts("逆向遍历");
	while(L!=NULL)
	{
		printf("%s\t",L->data);
		L=L->prev;
	}
	puts("");
}
/*
 * function:    双向链表尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DoubleLink insert_rear(datatype e,DoubleLink L)
{
	//1.创建新节点s
	DoubleLink s=create_node();
	if(NULL==s)
		return L;
	strcpy(s->data,e);
	//链表为空
	if(NULL==L)
	{
		L=s;
		return L;
	}
	//表示存在多个节点
	//找到尾部节点
	DoubleLink rear=L;
	while(rear->next!=NULL)
	{
		rear=rear->next;
	}
	rear->next=s;
	s->prev=rear;
	return L;
}
/*
 * function:    双向链表头删
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink delete_head(DoubleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.存在多个节点
	DoubleLink q=L->next;
	strcpy(L->data,q->data);
	L->next=q->next;
	if(q->next!=NULL)
		q->next->prev=L;
	free(q);
	q=NULL;
	return L;
}
/*
 * function:    双向链表尾删
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
DoubleLink delete_rear(DoubleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.存在多个节点
	//找到倒数第一个节点
	DoubleLink rear=L;
	while(rear->next!=NULL)
		rear=rear->next;
	rear->prev->next=NULL;
	free(rear);
	rear=NULL;
	return L;
}

main.c：

#include "double_head.h"
int main(int argc, const char *argv[])
{
	DoubleLink L=NULL;
	int n;
	datatype e;
	printf("please enter n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("please enter element:");
		scanf("%s",e);
	  //L=insert_head(e,L);
        L=insert_rear(e,L);
	}
	//循环输出
	output(L);
	
	//头删
	//L=delete_head(L);
	//尾删
	L=delete_rear(L);
	output(L);
	
	return 0;
}

数据结构day5（2023.7.19）,数据结构 

三、课后作业：

1.单向链表简单选择排序

void Sort(Linklist L)
{	
	//1.判断是否为空
	//2.判断如果链表只有一个节点
	if(NULL==L||L->next==NULL)
	{
		return;
	}
	//简单选择
	int len=Len_linklist(L);
	Linklist p;
	Linklist q;
	int i,j;
	for(i=0,p=L;i<len-1;i++,p=p->next)
	{
		Linklist min=p;
		for(j=i+1,q=p->next;j<len;j++,q=q->next)
		{
			if(min->data>q->data)
			{
				min=q;
			}

		}
		if(min!=p)
		{
			datatype t=p->data;
			p->data=min->data;
			min->data=t;
		}
	}
}

数据结构day5（2023.7.19）,数据结构

2.单向链表任意元素插入

/*
 * function:    按元素插入
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int insert_by_data(datatype key,datatype e,Linklist L)
{
	//1.判断元素是否为空
	if(NULL==L)
	{
		return -1;
	}
	//2.查找元素key
	Linklist p = L;
	while(p!=NULL&&p->data!=key)
	{
		p = p->next;
	}
	//若key不存在，则返回错误码-1
	if(p==NULL)
	{
		return -1;
	}
	//3.创建新节点并插入链表
	Linklist q=create_node();
	q->data=e;
	q->next=p->next;
	p->next=q;
	return 0;
}

数据结构day5（2023.7.19）,数据结构

3.单向链表任意元素修改

/*
 * function:    按元素修改
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int update_by_data(datatype key,datatype e,Linklist L)
{
	//1.判断元素是否为空
	if(NULL==L)
	{
		return -1;
	}
	//2.查找元素key
	Linklist p = L;
	while(p!=NULL&&p->data!=key)
	{
		p = p->next;
	}
	//若key不存在，则返回错误码-1
	if(p==NULL)
	{
		return -1;
	}
	p->data=e;
	return 0;
}

数据结构day5（2023.7.19）,数据结构文章来源地址https://www.toymoban.com/news/detail-597910.html

到了这里，关于数据结构day5（2023.7.19）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 6-19 数据结构考题 - 链队列

    用链队列作存储结构，实现队列（元素为整型）的基本运算。 链队列的类型定义： typedef int ElemType; typedef struct QNode {     ElemType data;                         struct QNode *next; }QNode; typedef struct {     QNode *front;     QNode *rear; }LinkQueue; 下面给出了  链队列操作  函数的大部分

    2024年04月28日
    浏览(24)
  • 数据结构 day6

    数据结构 day6

    1-xmind 2-递归实现程序：输入一个数，输出该数的每一位

    2024年02月10日
    浏览(30)
  • 数据结构 day1

    数据结构 day1

    1x.mind  2间接定义结构体数组，进行4种方式的定义和初始化  3定义结构体存储10辆车（车的信息：品牌、单价、颜色）         1.定义函数，实现循环输入         2.定义函数，实现排序         3.定义函数，计算红色车的个数  

    2024年02月11日
    浏览(31)
  • 数据结构day1

    数据结构day1

    1.思维导图 2.定义一个简单宏或宏函数，实现两个数交换。 3.定义字符类型指针，指针指向n个连续堆区内存，输入，计算字符串长度 定义函数，实现内存申请 定义函数，解释字符串长度 定义函数，释放内存

    2024年01月20日
    浏览(25)
  • 数据结构day05（单链表）

    数据结构day05（单链表）

    今日任务：  思维导图： 实现 代码：（多文件） head.h fun.c main.c 不好，眼花了，没看到实现单项循环链表，ji

    2024年02月11日
    浏览(22)
  • 数据结构基础day9

    数据结构基础day9

    解法1：哈希表 解法2：哈希表+滑动窗口+位运算 好长，不想看 解法1：暴力解法 遍历每一个子串，当其是回文子串且长度最大，存储初始位置和长度。 时间复杂度O(n^3)，空间复杂度O(1) 解法2：动态规划 相当于在暴力解法的基础上空间换时间，时间复杂度O(n^2)，空间复杂度O

    2024年02月11日
    浏览(29)
  • 数据结构day08（树、算法）

    数据结构day08（树、算法）

    今日任务： 二叉树： 今日思维导图 链接： 快排：快速排序法（详解）_李小白~的博客-CSDN博客图画挺好啊 常见款：https://www.runoob.com/w3cnote/quick-sort.html  

    2024年02月10日
    浏览(27)
  • 数据结构day07（栈和队列）

    数据结构day07（栈和队列）

    今日任务 head.h fun.c main.c 运行效果： 今日思维导图

    2024年02月10日
    浏览(29)
  • 数据结构的练习day1

    数据结构的练习day1

    链表只能一个一个的遍历，不能通过随机访问来获取节点 链表的地址是并要求连续的，是通过内部的指针来进行联系的

    2024年04月22日
    浏览(22)

  • day32 泛型 数据结构 List

     概述         JDK1.5同时推出了两个和集合相关的特性：增强for循环，泛型         泛型可以修饰泛型类中的属性，方法返回值，方法参数， 构造函数的参数 Java提供的泛型类/接口 Collection, List, Set，Iterator 等 自定义的泛型 public class Student H,W {} 自定义的泛型方法 public

    2024年02月09日
    浏览(27)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包