数据结构day4（2023.7.18）

已于 2023-07-19 11:47:02 修改
阅读量202 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2023-07-18 21:40:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68542867/article/details/131793967
版权

一、Xmind整理：

链表的插入和删除：

二、课上练习：

练习1：顺序表去重

33  22  22  11   11 
        i    
            j
    for(int i=0;i<list->len-1;i++)
    {
         for(int j=i+1;j<len;j++)
         {
              if(list->data[i]==list->data[j])
              {
                   delete_by_sub(j,list);   
                   j--;  //防止漏删        
              }        
         }   
    }

练习2： 顺序表合并

/*
 * function:    顺序表有序合并
 * @param [ in] 
 * @param [out] 
 * @return      无
 */
void combine(Seqlist *la,Seqlist *lb,Seqlist *lc)
{
    int p=0;//la的下表
    int q=0;//lb的下表

    while(p<la->len && q<lb->len)
    {
    if(la->data[p] <=lb->data[q])
    {
        lc->data[lc->len++]=la->data[p++];
    }
    else
    {
        lc->data[lc->len++]=lb->data[q++];
    }
    }
    //吧la剩余元素存到lc
    while(p<la->len)
    {
        
    lc->data[lc->len++]=la->data[p++];
    }
    //吧lb剩余元素存到lc
    while(q<lb->len)
    {
    lc->data[lc->len++]=lb->data[q++];
    }

}

练习3： 单链表创建

/*
 * 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=NULL;
    return node;//0x10
}

练习4：单链表头插 

/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
Linklist insert_head(datatype e,Linklist L)
{
    //在堆区创建一个节点
Linklist node=create_node();
node->data=e;
node->next=L;
    L=node;
    return L;
}

练习5：单链表尾插 

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_rear(datatype e,Linklist L)
{
    //创建一个新节点
Linklist s=create_node();
s->data=e;
    if(L==NULL)
    {
    L=s;
    }
    else
    {
    //rear指向最后一个节点的地址
    Linklist rear=L;
    while(rear->next!=NULL)
    {
        rear=rear->next;
    }
    rear->next=s;
    }
    return L;
}

练习6： 单链表头删

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

练习7： 单链表尾删

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

 练习8：单链表遍历

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

 练习9：单链表任意位置插入

int Len_linklist(Linklist L)
{
    int count=0;
    while(L!=NULL)
    {
    count++;
    L=L->next;
    }
    return count;
}
/*
 * function:    按位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_by_pos(int pos,datatype e,Linklist L)
{
    //1,判断链表是否为空
    //2，判断位置是否合法
    int len;
    if(NULL==L || pos<1 || pos>(len=Len_linklist(L))+1)
    {
    puts("insert arror");
    return L;
    }
    
    //3,插入
Linklist p=L;
    if(pos==len+1)
    {
    insert_rear(e,L);
    return L;
    }
    
    for(int i=1;i<pos;i++)
    {
    p=p->next;
    }
    
    
    //在p节点后面插入新节点s
Linklist s=create_node();
s->next=p->next;
p->next=s;
s->data=p->data;
p->data=e;
    
    
    return L;
}

 三、课后作业：

1.顺序表排序

test.c核心代码：
/*
 * function:    排序
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int SeqlistSort(Seqlist *list)
{
	int i,j,count;
	datatype t;
	if(NULL==list||empty(list))
		return -1;
	for(i=1;i<list->len;i++)
	{
		count=0;
		for(j=0;j<list->len-i;j++)
		{
			if(list->data[j]>list->data[j+1])
			{
				t=list->data[j];list->data[j]=list->data[j+1];list->data[j+1]=t;
				count++;
			}
		}
		if(count==0)
			break;
	}
	return 0;
}

2.单链表任意位置删除 

/*
 * function:    按链表位置删除
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0　失败返回-1
 */
Linklist delete_by_pos(int pos,Linklist L)
{
	//1,判断链表是否为空
	//2.判断位置是是否合法
	int len;
	if(NULL==L||pos<1||pos>(len=Len_linklist(L))+1)
	{
		puts("delete error\n");
		return L;
	}
	if(pos==1)
	{
		delete_head(L);
	}
	else
	{
		//3.找到pos-1位置起名p
		Linklist p=L;
		for(int i=1;i<pos-1;i++)
		{
			p=p->next;
		}
		//4.删除p->next
		Linklist q=p->next;
		p->next=q->next;
		free(q);
		q=NULL;
	}
	return L;
}

3.单链表任意位置查找

/*
 * function:    按链表位置查找
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int search_by_pos(int pos,Linklist L)
{
	//1.判空
    int len=Len_linklist(L);
	if(NULL==L||pos<1||pos>(len=Len_linklist(L))+1)
	{
		puts("search error\n");
		return -1;
	}
	Linklist p=L;
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	printf("%d\n",p->data);
}

 4.单链表任意位置修改

/*
 * function:    按链表位置修改
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int update_by_pos(int pos,datatype e,Linklist L)
{
	int len=Len_linklist(L);
	if(NULL==L||pos<1||pos>(len=Len_linklist(L))+1)
	{
		puts("update error\n");
		return -1;
	}
	Linklist p=L;
	for(int i=1;i<pos;i++)
		p=p->next;
	p->data=e;
	return 0;
}

整体代码如下： 

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 insert_head(datatype e,Linklist L);
int output(Linklist L);
Linklist insert_rear(datatype e,Linklist L);
Linklist delete_head(Linklist L);
Linklist delete_rear(Linklist L);
int Len_linklist(Linklist L);
Linklist insert_by_pos(int pos,datatype e,Linklist L);
Linklist delete_by_pos(int pos,Linklist L);
int search_by_pos(int pos,Linklist L);
int update_by_pos(int pos,datatype e,Linklist L);

#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=NULL;
	return node;
}
/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0　失败返回-1
 */
Linklist insert_head(datatype e,Linklist L)
{
	//在堆区创建一个节点
	Linklist node=create_node();//在堆区申请一个节点
	node->data=e;//数据域赋值为e
	//node节点链接到链表中
	node->next=L;
	L=node;
	return L;//因为自定义函数指针的改变不影响实参，需要返回
}
/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int output(Linklist L)
{
	//判断是否创建
	//判断是否为空
	if(NULL==L)
	{
		return -1;
	}
	while(L!=NULL)
	{
		printf("%d\t",L->data);
		L=L->next;
	}
	printf("\n");
}
/*
 * function:    尾部插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist 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!=NULL)
		{
			rear=rear->next;
		}
		rear->next=s;
	}
	return L;
}
/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist delete_head(Linklist L)
{
	//判断链表是否为空
	if(NULL==L)
	{
		return L;
	}
	if(L->next==NULL)
	{
		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==NULL)
	{
		free(L);
		L=NULL;
	}
	else
	{
		//3.有多个节点
		//循环倒数第二个节点
		Linklist second=L;
		while(second->next->next!=NULL)
		{
			second=second->next;
		}
		free(second->next);
		second->next=NULL;
	}
	return L;
}
/*
 * function:    计算长度
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Len_linklist(Linklist L)
{
	int count=0;
	while(L!=NULL)
	{
		count++;
		L=L->next;
	}
	return count;
}
/*
 * function:    按链表位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_by_pos(int pos,datatype e,Linklist L)
{
	//1.判断链表是否为空
	//2.判断位置是否合法
	int len;
	if(NULL==L||pos<1||pos>(len=Len_linklist(L))+1)
	{
		puts("insert error\n");
		return L;
	}
	//3.插入
	Linklist p=L;
	if(pos==len+1)
	{
		insert_rear(e,L);
		return L;
	}
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	//在p节点后面插入新节点s
Linklist s=create_node();
s->next=p->next;
p->next=s;
s->data=p->data;
p->data=e;
return L;
}
/*
 * function:    按链表位置删除
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0　失败返回-1
 */
Linklist delete_by_pos(int pos,Linklist L)
{
	//1,判断链表是否为空
	//2.判断位置是是否合法
	int len;
	if(NULL==L||pos<1||pos>(len=Len_linklist(L))+1)
	{
		puts("delete error\n");
		return L;
	}
	if(pos==1)
	{
		delete_head(L);
	}
	else
	{
		//3.找到pos-1位置起名p
		Linklist p=L;
		for(int i=1;i<pos-1;i++)
		{
			p=p->next;
		}
		//4.删除p->next
		Linklist q=p->next;
		p->next=q->next;
		free(q);
		q=NULL;
	}
	return L;
}
/*
 * function:    按链表位置查找
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int search_by_pos(int pos,Linklist L)
{
	//1.判空
    int len=Len_linklist(L);
	if(NULL==L||pos<1||pos>(len=Len_linklist(L))+1)
	{
		puts("search error\n");
		return -1;
	}
	Linklist p=L;
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	printf("%d\n",p->data);
}
/*
 * function:    按链表位置修改
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int update_by_pos(int pos,datatype e,Linklist L)
{
	int len=Len_linklist(L);
	if(NULL==L||pos<1||pos>(len=Len_linklist(L))+1)
	{
		puts("update error\n");
		return -1;
	}
	Linklist p=L;
	for(int i=1;i<pos;i++)
		p=p->next;
	p->data=e;
	return 0;
}

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=insert_head(e,L);
	}
	*/

	//在主函数找到尾部节点
	Linklist rear=L;
	if(rear!=NULL)
	{
		while(rear->next!=NULL)
		{
			rear=rear->next;
		}
	}
	//尾部插入
	for(int i=0;i<n;i++)
	{
		printf("please enter element:");
		scanf("%d",&e);
	    L=insert_rear(e,L);
	}
	//循环链表
	output(L);
	//头删
	//L=delete_head(L);
	//output(L);
	//尾删
	//L=delete_rear(L);
	//output(L);

	//按链表位置插入
	int pos;
	printf("please enter insert pos:");
	scanf("%d",&pos);
	printf("please enter insert element:");
	scanf("%d",&e);
	L=insert_by_pos(pos,e,L);
	output(L);

	//按链表位置删除
	printf("please enter delete pos:");
	scanf("%d",&pos);
	L=delete_by_pos(pos,L);
	output(L);
	
	//按链表位置查找
	printf("please enter search pos:");
	scanf("%d",&pos);
	search_by_pos(pos,L);
	
	//按链表位置修改
	printf("please enter update pos:");
	scanf("%d",&pos);
	printf("please enter update element:");
	scanf("%d",&e);
	update_by_pos(pos,e,L);
	output(L);

	return 0;
}
小徐今天认真学习了嘛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark大数据处理讲课笔记1.6 掌握Scala数据结构
howard2005的专栏
03-01 1381
1. 掌握数组的使用； 2. 掌握列表的使用； 3. 掌握映射的使用； 4. 掌握集合的使用； 5. 掌握元组的使用
Day 16 数据结构.md
08-09
数据结构，1.定时器 1.1 定时器重复执行任务 ①定时炸弹 ②闹钟 ③定时邮件发送 Java中实现 void schedule(TimerTask task, long delay) 安排在指定延迟后执行指定的任务等
自动化测试(一)：网页结构分析与Google翻译2023.7.18爬虫实例
a_beatiful_knife的博客
07-18 2688
day7.18了解爬虫
2023.8.8巨人网络数据开发工程师面试复盘
My Struggle
08-17 828
未被external修饰的是内部表，被external修饰的为外部表。内部表数据由Hive自身管理，外部表数据由HDFS管理；内部表数据存储的位置是hive.metastore.warehouse.dir（默认：/user/hive/warehouse）， 外部表数据的存储位置由自己设置；删除内部表会直接删除元数据（metadata）及存储数据；删除外部表仅仅会删除元数据，HDFS上的文件并不会被删除。
2023/1/7 直面数据结构:Day_04
m0_56593481的博客
01-08 170
原出处:https://space.bilibili.com/19658621/dynamic 该视频知识产权由Micro_Frank所有(B站可以搜到)，感谢您支持正版维护中国人版权权益。 淘宝店铺名：MicroFrank 1. 非传统数据结构教学 2. 非传统数据结构思想 3. 非传统数据结构方法 4. 非传统训练方法 5. 非传统价格
2023/1/3 ~ 2023/1/4 直面数据结构:Day_01
m0_56593481的博客
01-08 206
原出处:https://space.bilibili.com/19658621/dynamic 该视频知识产权由Micro_Frank所有(B站可以搜到)，感谢您支持正版维护中国人版权权益。 淘宝店铺名：MicroFrank https://www.bilibili.com/video/BV1t14y1G7wn 1. 非传统数据结构教学 2. 非传统数据结构思想 3. 非传统数据结构方法 4. 非传统训练方法 5. 非传统价格
2023/1/6 直面数据结构:Day_03
m0_56593481的博客
01-08 388
原出处:https://space.bilibili.com/19658621/dynamic 该视频知识产权由Micro_Frank所有(B站可以搜到)，感谢您支持正版维护中国人版权权益。 淘宝店铺名：MicroFrank https://www.bilibili.com/video/BV1t14y1G7wn 1. 非传统数据结构教学 2. 非传统数据结构思想 3. 非传统数据结构方法 4. 非传统训练方法 5. 非传统价格
机器学习周记（第二十周：文献阅读-TCN and LSTM）2023.12.4~2023.12.10
DominaterWE的博客
12-10 1111
本周阅读了一篇关于TCN和LSTM进行光伏功率预测的文章，光伏功率数据是非线性不平稳的数据，在一定程度上也能反应论文模型在水质预测方面的效果。论文模型可以通过单步或者多步对光伏功率进行预测，实验结果表明，其具有非常优异的表现。本周也针对论文模型进行了简单的复现，预测结果并不非常准确，仍需进一步优化和调参。
2023/1/12 直面数据结构:Day_08
m0_56593481的博客
01-12 304
原出处:https://space.bilibili.com/19658621/dynamic 该视频知识产权由Micro_Frank所有(B站可以搜到)，感谢您支持正版维护中国人版权权益。 淘宝店铺名：MicroFrank https://www.bilibili.com/video/BV1t14y1G7wn/ 1. 非传统数据结构教学 2. 非传统数据结构思想 3. 非传统数据结构方法 4. 非传统训练方法 5. 非传统价格
2023/1/10 直面数据结构:Day_07
m0_56593481的博客
01-10 184
原出处:https://space.bilibili.com/19658621/dynamic 该视频知识产权由Micro_Frank所有(B站可以搜到)，感谢您支持正版维护中国人版权权益。 淘宝店铺名：MicroFrank https://www.bilibili.com/video/BV1t14y1G7wn/ 1. 非传统数据结构教学 2. 非传统数据结构思想 3. 非传统数据结构方法 4. 非传统训练方法 5. 非传统价格
React【Day4下+5】
weixin_63681863的博客
04-21 982
路由的 记账本案例
数据结构笔记源代码.zip
03-29
郝老师数据结构的笔记源代码.
华清创客数据结构课件与代码.rar
12-01
Day1-数据结构概述及顺序表、 Day2-单链表上 。。 Day8，9-二叉树 Day10，11-查找 Day12 排序
spring4_day01.7z
08-03
自己学习使用，spring框架的一个小案例，从网上看到的教程
day8035.rar_数据结构_Visual_C++_
08-12
这是用C++写的关于链表的创建
短期总结（数据结构学完有感）
chan1ee的博客
05-29 293
从刚开始废寝忘食地学习，到中途自己过度关注题目的AC而忽略自己对知识的掌握，再到后面的沉下心去好好钻研，这段时间的收获确实很大，不光是知识层面，还有自己对学习的认识和态度。我的OS学习计划参考了其他博主的心得，打算先看哈工大的网课，并且完成课后Lab，最后参考《操作系统真想还原》动手实现一个小型操作系统。这18天我几乎没有休息过，每天早上7:30起床，晚上9点多才回宿舍，太久没有这么高强度学习过，确实让我的身心都有点疲劳了。接下来的打算就是，和女朋友一起玩几天，然后就开始投身于操作系统的学习。
树--搜索二叉树
Beau Wang
05-29 771
线索二叉树充分利用了指针空间，同时又便于寻找结点的前驱结点和后继结点。线索二叉树适用于经常需要遍历寻找结点前驱或者后继结点的二叉树。
排序进阶----插入排序，希尔排序
2302_80318761的博客
05-29 991
大家可以想一下，我们如果以扑克牌为例，我们利用冒泡排序的话，每一个位置就要对比一下，这很麻烦，很耗时间的。但是如果我用插入排序的话，我们以第一个数为例，一次向后对比，如果他比接下来对比的数都大的话，那么我就先把战船一直比较比他更大的数，那么我就把它插入在前面。我们先从第一趟开始，比如说我们就先走第一趟，以下标为零开始的与下标为一对比，如果他比第一个大的话，那么这一趟就结束，我们就只循环一次。当然希尔排序其实是有一点困难的，大家需要多理解一点多看一下，其实相对还是比较简单的，只需要理解之后大家都能写出来的。
JavaDS-学习数据结构之如果从零开始手搓顺序表,顺带学习自定义异常怎么用!
最新发布
cjejwe的博客
05-29 1214
笔者开始学习数据结构了,虽然笔者已经会用了,不管是C++ 中的stl亦或是Java 中的集合,为了算法比赛多少都突击过,但只知其然而不知其所以然,还是会限制发展的,因此,笔者写下这篇博客.内容是手搓一个顺序表.顺带加一点异常的使用,大伙看个乐子就好了.有错误直接私信喷我就好了,不用和我客气!说的简短一些,数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
2023.03.01-2023.03.03 2023.03.04-2023.03.10 2023.03.11-2023.03.17 2023.03.18-2023.03.24 2023.03.25-2023.03.31 按月划分周数，怎么用Java代码实现
05-26
第4周：2023.3.18-2023.3.24 第5周：2023.3.25-2023.3.31 ``` 该代码首先定义了要查询的年份和月份，然后使用 `Calendar` 类将日期设置为该月份的第一天。接着，根据这个日期计算出该月份共有几周，然后循环遍历...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值