顺序表、链表

最新推荐文章于 2024-07-13 11:07:53 发布
最新推荐文章于 2024-07-13 11:07:53 发布
阅读量133 收藏
点赞数
分类专栏： 数据结构 文章标签： c语言 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52547536/article/details/125966017
版权

数据结构
线性：线性表、栈、队列等等
非线性：树（1：N）、图（N:M）等等
存储：顺序存储（arr）、链式存储（*）

线性表：
1、顺序存储的线性表----》arr
2、链式存储的线性表（有头还是无头？）
1、单链表（单向不循环、单向循环）
2、双链表（双向不循环，双向循环）

树（递归思想、非递归思想）
顺序存储线性表：
在这里插入图片描述

顺序存储线性表的实现：
sqlist.c文件

#include <stdio.h>
#include <stdlib.h>
#include "sqlist.h"
sqlist *sqlist_create()
{
	sqlist *me;
	me=malloc(sizeof(*me));
	if(me==NULL)
	{
		return NULL;
	}
	me->last=-1;
	return me;
}
void sqlist_create1(sqlist **ptr)
{
	*ptr=malloc(sizeof(**ptr));
	if(*ptr==NULL)
	{
		return ;
	}

	(*ptr)->last=-1;
	return ;
}

int sqlist_insert(sqlist *me,int i,datatype *data)
{
	if(me->last==DATASIZE-1)
		return -1;
	if(i<0 || i>me->last+1)
		return -2;

	int j;
	for(j=me->last;i<=j;j--)
		me->data[j+1]=me->data[j];

	me->data[i] = *data;
	me->last++;
	return 0;
}

int sqlist_delete(sqlist *me,int i)
{
	int j;
	if(i<0||i>me->last)
		return -1;
	for(j=i+1;j<=me->last;j++)
		me->data[j-1]=me->data[j];
	me->last--;
}

int sqlist_find(sqlist *me,datatype *data)
{
	int i;
	if(sqlist_isempty(me)==0)
		return -1;
	for(i=0;i<=me->last;i++)
	{
		if(me->data[i]==*data)
			return i;
	}
	return -2;
}

int sqlist_isempty(sqlist *me)
{
	if(me->last==-1)
		return 0;
	return -1;
}

int sqlist_setempty(sqlist *me)
{
	me->last=-1;
	return 0;
}

int sqlist_getnum(sqlist *me)
{
	return (me->last+1);
}

void sqlist_display(sqlist *me)
{
	int i;

	if(me->last==-1)
		return ;
	for(i=0;i<= me->last;i++)
	{
		printf("%d",me->data[i]);
	}
	printf("\n");
	return ;
}

int sqlist_destroy(sqlist *me)
{
	free(me);
	return 0;
}

int sqlist_union(sqlist *list1,sqlist *list2)
{
	int i;
	for(i=0;i<=list2->last;i++)
	{
		if(sqlist_find(list1,&list2->data[i]) < 0)
		{
		sqlist_insert(list1,0,&list2->data[i]);
		}
	}
}

sqlist.h文件内容：

#ifndef SQLIST_H__
#define SQLIST_H__
#define DATASIZE 1024
typedef int datatype;
typedef struct node_st
{
	datatype data[DATASIZE];
	int last;
}sqlist;

sqlist *sqlist_create();
void sqlist_create1(sqlist **);
int sqlist_insert(sqlist *,int i,datatype *);
int sqlist_delete(sqlist *,int i);
int sqlist_find(sqlist *,datatype *);
int sqlist_isempty(sqlist *);
int sqlist_setempty(sqlist *);
int sqlist_getnum(sqlist *);
void sqlist_display(sqlist *);
int sqlist_destroy(sqlist *);
int sqlist_union(sqlist *,sqlist *);
#endif

main.c文件内容：

#include <stdio.h>
#include <stdlib.h>
#include "sqlist.h"
int main()
{
	sqlist *list;
	datatype arr[]={12,23,34,45,56};
	int i,err;
	// list=sqlist_create();
	sqlist_create1(&list);
	if(list == NULL)
	{
	fprintf(stderr,"sqlist_create fail");
	exit(1);
	}
	for(i=0;i<sizeof(arr)/sizeof(*arr);i++)
		if((err=sqlist_insert(list,0,&arr[i]))!=0)
		{
			if(err==-1)
			{
				fprintf(stderr,"the arr is full .\n");
			}
			else if(err==-2)
			{
				fprintf(stderr,"the pos you want to insert is wrong");
			}
			else
			{
				fprintf(stderr,"ERROR");
			}
			exit(1);
		}

	sqlist_display(list);
	sqlist_delete(list,1);
	sqlist_destroy(list);
	exit(0);
}

makefile文件内容：

all:mainmain:main.o sqlist.o
$(CC) $^ -o $@
clean:
rm *.o main -rf

链表
在这里插入图片描述

有头（先有个头，再有第一个有效结点，第二个有效结点，第三个有效结点……）
在这里插入图片描述

无头（没有头，直接就是第一个有效结点，第二个有效结点，第三个有效结点.……）
在这里插入图片描述

有头结点的单链表的实现：
list.c文件内容：

#include <stdio.h>
#include <stdlib.h>
#include "list.h"
list * list_create()
{
	list *me;
	me=malloc(sizeof(*me));
	if(me==NULL)
	{
		return NULL;
	}

	me->next=NULL;
	return me;

}

int list_insert_at(list *me,int i,datatype *data)
{
	int j=0;

	list *node=me,*newnode;
	while(j<i && node!=NULL)
	{
		node =node->next;
		j++;
	}

	if(node)
	{
		newnode=malloc(sizeof(*newnode));
		if(newnode == NULL)
			return -2;
		newnode->data=*data;

		newnode->next=node->next;
		node->next=newnode;

	}
	else
	{
		return -3;
	}

}


int list_order_insert(list *me,datatype *data)
{
	list *p=me,*q;

	while(p->next && p->next->data<*data)
	{
		p=p->next;
	}
	q=malloc(sizeof(*q));
	if(q==NULL)
		return -1;
	q->data = *data;
	q->next=p->next;
	p->next=q;
	return 0;
}

int list_delete_at(list *me,int i,datatype *data)
{
	int j=0;
	list *p=me,*q;

	*data=-1;

	if(i<0)
	{
		return -1;
	}

	while(j<i && p)
	{
		p=p->next;
		j++;
	}
	if(p)
	{
		q=p->next;
		p->next=q->next;
		*data = q->data;
		free(q);
		q=NULL;
		return 0;
	}
	else
	{
		return -1;
	}
}

int list_delete(list *me,datatype *data)
{
	list *p=me,*q;
	while(p->next && p->next->data!=*data)
	{
		p=p->next;
	}
	if(p->next==NULL)
		return -1;
	else
	{
		q=p->next;
		p->next=q->next;
		free(q);
		q=NULL;
	}
}

int list_isempty(list *me)
{
	if(me->next==NULL)
		return 0;
	return 1;
}

void list_display(list *me)
{
	list *node=me->next;
	if(list_isempty(me)==0)
		return ;

	while(node != NULL)
	{
		printf("%d ",node->data);
		node=node->next;
	}
	printf("\n");

	return ;
}

void list_destroy(list *me)
{
	list *node,*next;
	for(node=me->next;node!=NULL;node=next)
	{
		next=node->next;
		free(node);
	}
	free(me);
	return ;
}

list.h文件内容：

#ifndef LIST_H__
#define LIST_H__
typedef int datatype;
typedef struct node_st
{
	datatype data;
	struct node_st *next;
}list;
list * list_create();
int list_insert_at(list *,int i,datatype *);
int list_order_insert(list *,datatype *);
int list_delete_at(list *,int i,datatype *);
int list_delete(list *,datatype *);
int list_isempty(list *);
void list_display(list *);
void list_destroy(list *);
#endif

main.c文件内容：

#include <stdio.h>
#include <stdlib.h>
#include "list.h"
int main()
{
	list *l;
	int i;
	datatype arr[]={12,23,45,66,2,9,30};
	l=list_create();
	if(l==NULL)
	{
		exit(1);
	}

	for(i=0;i<sizeof(arr)/sizeof(*arr);i++)
	{
		if(list_order_insert(l,&arr[i]))
		exit(1);
	}
	list_display(l);
	list_destroy(l);
}

makefile文件内容：

all:mainmain:main.o list.o
$(CC) $^ -o $@
clean:
rm *.o main -rf

特点：操作不方便，若是想要查找前面的内容，那么就必须重新开始。

无头结点单链表
这里的插入从头插入。
nohead.c文件内容

#include <stdio.h>
#include <stdlib.h>
#include "nohead.h"
struct node_st *list_insert(struct node_st *list,struct score_st *data)
{
	struct node_st *new;
	new=malloc(sizeof(*new));
	if(new==NULL)
	{
		return NULL;
	}

	new->data=*data;
	new->next=list;
	list=new;

	return list;

}

void list_show(struct node_st *list)
{
	struct node_st *cur;
	for(cur=list;cur!=NULL;cur=cur->next)
	{
		printf("%d %s %d %d\n",cur->data.id,cur->data.name,cur->data.math,cur-				>data.chinese);
	}
}

int list_delete(struct node_st **list)
{
        struct node_st *cur;
        if(*list==NULL)
        {
                return -1;
        }
        cur=*list;
        *list=(*list)->next;
        free(cur);
        return 0;
}
struct score_st * list_find(struct node_st *list,int id )
{
	struct node_st *cur;
	for(cur=list;cur!=NULL;cur=cur->next)
	{
		if(cur->data.id==id)
		{
//printf("%d %s %d %d\n",cur->data.id,cur->data.name,cur->data.math,cur->data.chinese);
		return &cur->data;
		}
	}
return NULL;
}

void list_destroy(struct node_st *list)
{
	struct node_st *cur;
	if(list == NULL)
	{
		return ;
	}
	for(cur=list;cur!=NULL;cur=list)
	{
		list =cur->next;
		free(cur);
	}
}

二级指针实现插入：

int list_insert(struct node_st **list,struct score_st *data){
        struct node_st *new;
        new=malloc(sizeof(*new));
        if(new==NULL)
        {
                return -1;
        }
        new->data=*data;
        new->next=*list;
        *list=new;
        return list;
}

nohead.h文件内容

#ifndef NOHEAD_H__
#define NOHEAD_H__
#define NAMESIZE 64
struct score_st
{
        int id;
        char name[NAMESIZE];
        int math;
        int chinese;
};
struct node_st
{
        struct score_st data;
        struct node_st *next;
};
struct node_st  *list_insert(struct node_st *,struct score_st *data);
void list_show(struct node_st *);
int list_delete(struct node_st **list);
struct score_st * list_find(struct node_st *,int id);
void list_destroy(struct node_st *);
#endif

main.c文件内容

#include <stdio.h>#include <stdlib.h>
#include "nohead.h"
int main()
{
    struct score_st *ptr;
	struct node_st *list=NULL;
	struct score_st tmp;
	int i;
	for(i=0;i<7;i++)
	{
		tmp.id=i;
		snprintf(tmp.name,NAMESIZE,"stu%d",i);
		tmp.math=rand() % 100;
		tmp.chinese=rand() % 100;

		list=list_insert(list,&tmp);
	}

	list_show(list);

	printf("\n \n");
	// list_delete(&list);
	// list_show(list);
	int id=3;

	ptr=list_find(list,id);
	if(ptr==NULL)
	{
		printf("Can not find the message");
	}
	else
	printf("%d %s %d %d \n",ptr->id,ptr->name,ptr->math,ptr->chinese);
	list_destroy(list);
	exit(0);
}

makefile文件内容

all:mainmain:main.o nohead.o
$(CC) $^ -o $@
clean:
rm *.o main -rf

在这里插入图片描述

多项式合并（单链表实现）

#include <stdio.h>#include <stdlib.h>
struct node_st
{
	int coef;
	int exp;
	struct node_st *next;
};
struct node_st *poly_create(int a[][2],int n)
{
	int i;
	struct node_st *me;
	struct node_st *newnode,*cur;
	me=malloc(sizeof(*me));
	if(me==NULL)
	{
		return NULL;
	}
	me->next=NULL;
	cur=me;
	for(i=0;i<n;i++)
	{
		newnode=malloc(sizeof(*newnode));
		if(newnode==NULL)
		return NULL;
		newnode->coef=a[i][0];
		newnode->exp=a[i][1];
		newnode->next=NULL;

		cur->next=newnode;
		cur=newnode;

	}
return me;
}

void poly_show(struct node_st *me)
{
	struct node_st *cur;
	for(cur=me->next; cur!=NULL; cur=cur->next)
	{
		printf("(%d %d)",cur->coef,cur->exp);
	}

	printf(" \n ");
}

void poly_union(struct node_st *p1,struct node_st *p2)
{
	struct node_st *p,*q,*r;

	p=p1->next;
	q=p2->next;
	r=p1;

	while(p&&q)
	{
		if(p->exp < q->exp)
		{
			r->next=p;
			r=p;
			p=p->next;
		}
		else if(p->exp > q->exp)
		{
			r->next=q;
			r=q;
			q=q->next;

		}
		else
		{
			p->coef+=q->coef;
			if(p->coef)
			{
				r->next=p;
				r=p;
			}
			p=p->next;
			q=q->next;
		}

	}

	if(p==NULL)
	{
		r->next=q;
	}
	else
	{
		r->next=p;
	}
}

int main()
{
	int a[][2]={{5,0},{2,1},{8,8},{3,16}};
	int b[][2]={{6,1},{16,6},{-8,8}};

	struct node_st *p1;
	struct node_st *p2;

	p1=poly_create(a,4);
	p2=poly_create(b,3);
	poly_show(p1);
	poly_show(p2);
	poly_union(p1,p2);
	poly_show(p1);

	exit(0);
}

在这里插入图片描述

约瑟夫算法:
假设要数的数是3，那么从1开始顺时钟，就可以得到顺序3615284（最后剩下7）
利用无头的单项循环链表实现：

创建思路一：
将所有结点都创建好，然后1指向2，2指向3，……最后7指向8；
创建思路二：
先创建好一个，然后指向自己，在创建一个后，上一个指向新创建的，而新创建的指向第一个创建好的。

使用思路二：在任何时刻都是循环的结构

#include <stdio.h>
#include <stdlib.h>
#define JOSE_NUM 8
struct node_st
{
	int data;
	struct node_st *next;
};
struct node_st *jose_create(int n)
{
	int i=1;
	struct node_st *me;
	struct node_st *newnode,*cur;
	me=malloc(sizeof(*me));
	if(me==NULL)
		return NULL;

	me->data=i;
	me->next=me;
	i++;
	cur=me;
	for(;i<=n;i++)
	{
		newnode=malloc(sizeof(*newnode));
		if(newnode==NULL)
			return NULL;
		newnode->data=i;
		newnode->next=me;

		cur->next=newnode;
		cur=newnode;
	}
	return me;
}

void jose_show(struct node_st *me)
{
	struct node_st *list;
	for(list=me;list->next!=me;list=list->next)
	{
		printf("%d ",list->data);
	}

	printf("%d \n",list->data);
}

void jose_kill(struct node_st **me,int n)
{
	struct node_st *cur=*me,*node;
	int i=1;
	while(cur!=cur->next)
	{
		while(i<n)
		{
			node=cur;
			cur=cur->next;
			i++;
		}
		printf("%d ",cur->data);
		node->next=cur->next;
		free(cur);
		cur=node->next;
		i=1;
	}
	*me=cur;
	printf("\n ");
}

int main()
{
	struct node_st *list;
	int n=3;
	list = jose_create(JOSE_NUM);
	jose_show(list);

	jose_kill(&list,n);
	jose_show(list);
	exit(0);
}
IU555
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表和链表
passion
08-03 2967
顺序表和链表的简单介绍和实现
顺序表与链表
m0_56931704的博客
09-06 1427
顺序表与链表 一.顺序表 1.定义：将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中 顺序表可以分为静态顺序表和动态顺序表 2.结构定义： #define MAXSIZE 100 typedef int ElemType; typedef struct Seqlist {//静态顺序表 ElemType data[MAXSIZE]; size_t size
Java顺序表和链表
xinhang10的博客
11-14 1801
此文章对Java数据结构中的顺序表和链表进行了十分细致的讲解，并为大家演示了如何从0开始创建一个顺序表和链表，并将他们编写成一个完整的顺序表(链表)。在此基础上，作者还为大家贴心的准备了10个链表的练习题，并将他们详细的讲解了一遍，相信这对初入数据结构的同学们来说一定是一个好的练习。在练习题后面我们还为大家附上了力扣和牛客网的链表练习题链接，有需要的小伙伴可以自己点击。在文章的最后，我们为大家分析了链表和顺序表到底有什么区别……
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
顺序表和链表的比较
icbbm的博客
08-04 3289
综上所述，顺序表适用于数据元素较少、读取操作频繁的场景，而链表适用于数据元素较多、插入、删除操作频繁的场景。
顺序表和链表的优缺点
weixin_57023347的博客
06-21 3760
顺序表 定义：在内存中用地址连续的一块存储空间顺序存放线性表的各元素。在程序设计语言中，一维数组在内存中占用的存储空间是一维连续的存储空间，因此我们用一维数组存储数据来表示顺序表。 优点： 由于顺序表是用数组来存储数据，内存空间连续，当访问数据时可以达到使用数组下标的方式随机访问。 CPU高速缓存的命中率高。 解释： 数据保存在内存中，数据是在CPU里进行运算的(逻辑和算术)。但是CPU速度太快，内存的速度跟不上CPU的速度。于是在CPU和内存之间存在一些寄存器和缓存器，用来保存数据。当CPU要使用数
数据结构---顺序表，链表
includeevey的博客
08-03 2423
2w字带你走进链表
数据结构-顺序表与链表详解
m0_62918577的博客
11-05 1702
顺序表概念及分类，以及动态顺序表的接口实现 链表的概念及结构以及无头单向非循环链表的接口实现 在不同方面解析顺序表和链表的区别
顺序表和链表的区别
Britney_dark的博客
04-25 3891
不同点 顺序表 链表 存储空间 物理上一定连续 逻辑上连续，但物理上不一定连续 随机访问 支持O(1) 不支持：O(N) 任意位置插入或者删除元素 可能需要搬移元素，效率低O(N) 只需修改指针指向 插入 动态顺序表，空间不够时需要扩容 没有容量的概念 应用场景 元素高效存储+频繁访问 任意位置插入和删除频繁 缓存利用率 高 低 由上表可总结出： 顺序表优点： 1. 物理空间是连续的，方便用
顺序链表的定义及操作
alBeLine的博客
12-06 1273
顺序链表 定义: 顺序链表 的本质是一个数组, 但和数组不一样. 它额外增添了一个属性—长度, 用来记录存储数据的个数. 所以将 长度 和 数组 封装在一起就形成了新的数据结构—顺序链表 typedef struct{ ElemType data[MAXSIZE]; int length; }SqList; 获取元素 顺序链表, 获取数据的方式较简单, 只需要根据位置, 直接索引即可, 然后通过传入e的地址来接收数据 代码如下: 时间复杂度为O(1) Status GetEl
数据结构实验 顺序表和链表
10-08
顺序表和链表的基本实现 数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍...
顺序链表C++实现
09-06
顺序链表是一种常见的数据结构，尤其在编程领域中被广泛使用。它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C++中实现顺序链表，我们需要理解基本的C++语法，包括类、构造函数、析构函数、指针...
使用C++实现顺序链表
01-20
这个`List`类提供了对顺序链表的基本操作，包括构造、析构、销毁、清空、检查是否为空、获取长度、查找元素、插入元素、删除元素以及遍历链表。 1. **构造与析构**： - `List(int size)`：构造函数，接收一个整型...
线性结构及其应用，顺序表，链表，静态链表
03-30
本主题主要探讨线性结构的三个重要概念：顺序表、链表以及静态链表，这些都是数据结构与算法中的核心知识。 首先，顺序表是一种最基础的线性结构，它的特点是元素在内存中是连续存储的，可以通过数组的形式来实现。...
数据结构顺序表和链表的相关操作
06-30
实现顺序表和链表的建立、取元素、修改元素、插入、删除等顺序表的基本操作。 设计要求: 首先设计一个含有多个菜单项的主菜单程序，然后再为这些菜单项配上相应的功能。 基本操作： 1.依次从键盘读入数据，建立...
28.【C语言】库函数
2401_85828611的博客
07-12 545
在计算机科学中，子程序是一个大型程序中的某部分代码，由一个或多个语句块组成。一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。3.分类：库函数（可以直接调用）（printf，strcpy（字符串拷贝），pow（求n的k次方））和自定义函数（先创建再调用，见第12篇）将str1（source）的内容拷贝到str2（destination）8.注意：调用库函数前一定要写#include （网站的Example有）以www.cplusplus.com为例。2.模型：输入-->函数-->输出。
小白学c嘎嘎（第二天）入门基础下
2302_80418176的博客
07-10 267
温馨提醒：本篇文章起，文章内容排版将更新，层层深入。
C语言——数组、sizeof关键字
最新发布
weixin_45720999的博客
07-13 712
C语言中的数组是一种基本的数据结构，用于在计算机内存中连续存储相同类型的数据。数组中的每个元素可以通过索引来访问，索引通常是一个整数，用于指定元素在数组中的位置。在C语言中，数组索引是从0开始的。要使用数组，必须在程序中先定义数组，即通知计算机：由哪些数据组成数组，数组中有多少元素，属于哪个数据类型。否则计算机不会自动地把一批数据作为数组处理。
求整数数组的子集【C语言】
m0_65146517的博客
07-10 694
方法1：通过二进制位，因为n个整数数组的子集有2的n次方个，例如整数数组为{1,2,3},子集有2的3次方，8个；n&1判断最低位是否有数。如果一个子集为{2}，利用二进制位2&1让其最低位空出来，依次类推。若n=3(011);n&1=1 其最低位可以得到，n>>1 = 1；本题本来打算写来回答力扣题78题求子集的，但是，才疏学浅，还是我不配。将n&1与n>>1结合就可以得到。以上述思想求整数数组的子集。最终结果将所有0都去掉了。其中需要了解关注的是。n>>1结果是n/2。可以通过下面代码解读。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值