数据结构(王道版本，主讲人:闲鱼学长)P7-P18

最新推荐文章于 2022-07-15 20:35:08 发布
最新推荐文章于 2022-07-15 20:35:08 发布
阅读量5.6k 收藏 13
点赞数 4
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Scxioi0/article/details/113831756
版权

2.1.1 线性表的定义和基本操作

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.2.1 顺序表的定义

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct {
	int data[MaxSize];//用静态的“数组”存放数据元素
	int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitSize(SqList& L);//初始化一个顺序表
void main()
{
	SqList L;//声明一个顺序表
	InitSize(L);//初始化顺序表
	for (int i = 0; i < L.length; i++)
	{
		printf("date[%d]=%d\n", i, L.data[i]);
	}
}
void InitSize(SqList& L)//初始化一个顺序表
{
	for (int i = 0; i < MaxSize; i++)
	{
		L.data[i] = i;//将所有数据元素设置为默认初始值
	}
	L.length = 10;//顺序表的初始长度为10
}
//date[0] = 0
//date[1] = 1
//date[2] = 2
//date[3] = 3
//date[4] = 4
//date[5] = 5
//date[6] = 6
//date[7] = 7
//date[8] = 8
//date[9] = 9

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2.2.2 顺序表的插入和删除

在这里插入图片描述
在这里插入图片描述

#include<stdio.h>
#define MaxSize 6
typedef struct
{
	int data[MaxSize];
	int length;
}SqList;
void InitList(SqList& L)
{
	for (int i = 0; i < 5; i++)
	{
		L.data[i] = i * 2;
		printf("%d ", L.data[i]);
	}
	printf("\n");
	L.length = 5;
}
bool ListInsert(SqList& L, int i, int e)
{
	if (i >= 1 && i <= L.length + 1)
	{
		for (int j = L.length; j >= i; j--)
		{
			L.data[j] = L.data[j - 1];//L.data[5]=L.data[4]  L.data[4]=L.data[3] L.data[3]=L.data[2]
		}
		L.data[i - 1] = e;//L.data[2]=3;
		L.length++;
		return true;
	}
	else
	{
		return false;
	}

}
int main()
{
	SqList L;
	InitList(L);
	if (ListInsert(L, 3, 3)==true)
	{
		for (int i = 0; i < L.length; i++)
		{
			printf("%d ", L.data[i]);
		}
	}
	else
	{
		printf("插入错误");
	}
	return 0;
}
//0 2 4 6 8
//0 2 3 4 6 8

在这里插入图片描述
在这里插入图片描述

#include<stdio.h>
#define MaxSize 5
typedef struct
{
	int data[MaxSize];
	int length;
}SqList;
void InitList(SqList& L)
{
	for (int i = 0; i < 5; i++)
	{
		L.data[i] = i * 2;
		printf("%d ", L.data[i]);
	}
	printf("\n");
	L.length = 5;
}
bool ListDelect(SqList& L, int i, int &e)
{
	if (i >= 1 && i < L.length + 1)
	{
		e = L.data[i - 1];
		for (int j = i; j <L.length; j++)
		{
			L.data[j-1] = L.data[j];
		}
		L.length--;
		return true;
	}
	else
	{
		return false;
	}
}
int main()
{
	SqList L;
	InitList(L);
	int e = -1;
	if (ListDelect(L, 5, e)==true)
	{
		for (int i = 0; i < L.length; i++)
		{
			printf("%d ", L.data[i]);
		}
		printf("\n");
		printf("删除元素为:%d\n", e);
	}
	else
	{
		printf("删除错误\n");
	}
	return 0;
}
//0 2 4 6 8
//0 2 4 6
//删除元素为:8

在这里插入图片描述
在这里插入图片描述

2.2.3 顺序表的查找

在这里插入图片描述

#include<stdio.h>
#define MaxSize 10
typedef struct
{
	int data[MaxSize];
	int length;
}SeqList;
void InitList(SeqList &L)
{
	L.length = 6;
	for (int i = 0; i < L.length; i++)
	{
		L.data[i] = i;//0 1 2 3 4 5
	}
}
int GetElem(SeqList& L, int i)
{
	return L.data[i - 1];
}
void main()
{
	int result;
	SeqList L;
	InitList(L);
	result=GetElem(L, 3);
	printf("该位置的元素为:%d", result);
}
//该位置的元素为:2

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#define InitSize 10
typedef struct
{
    int* data;		//动态分配
    int MaxSize;
    int length;
}SqList;

void InitList(SqList& L)
{
    //用malloc函数申请一片连续的存储空间    
    L.data = (int*)malloc(InitSize * sizeof(int));
    L.length = 0;
    L.MaxSize = InitSize;
}

int GetLem(SqList L, int i)
{
    return L.data[i - 1];		//和访问普通数组方法一样
}
void main()
{
    int result;
    SqList L;
    InitList(L);
    for (int i = 0; i < 5; i++)
    {
        L.data[i] = i;
    }
    result=GetLem(L,3);
    printf("该位置的元素为:%d\n", result);
    free(L.data);
}
//该位置的元素为:2

在这里插入图片描述
在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#define InitSize 10
typedef struct
{
	int* data;
	int MaxSize;
	int length;
}SeqList;
void InitList(SeqList &L)
{
	//用malloc函数申请一片连续的存储空间 
	L.data = (int*)malloc(InitSize * sizeof(int));
	L.length = 5;
	L.MaxSize = InitSize;
}
int LocateElem(SeqList L, int e)
{
	for (int i = 0; i < L.length; i++)
	{
		if (L.data[i] == e)
		{
			return i + 1;//数组下标为i的元素值为e，返回其位序i+1
		}
	}
	return 0;//退出循环，说明查找失败
}
void main()
{
	int result;
	SeqList L;
	InitList(L);
	for (int i = 0; i < L.length; i++)
	{
		L.data[i] = i;
	}
	result=LocateElem(L, 2);
	printf("该元素在第%d位置\n", result);
	free(L.data);
}
//该元素在第3位置

在这里插入图片描述
在这里插入图片描述

2.3 链表

2.3.1单链表的定义

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.3.2单链表的插入和删除

在这里插入图片描述
在这里插入图片描述

//在第i个位置插入元素e（带头结点）
typedef struct LNode{
	Elemtype data;
	struct LNode *next;
}LNode,*LinkList;

bool ListInsert(LinkList &L,int i,Elemtype e){
	if(i<1) return false;
	LNode *p;//指针p指向当前扫描到的结点 
	int j=0;//当前p指向的是第几个结点 
	p=L;//L指向头结点，头结点是第0个结点
	while(p!=NULL&&j<i-1){
		p=p->next;
		j++;
	} 
	if(p==NULL)return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}

在这里插入图片描述

//在第i个位置插入元素e（不带头结点）
typedef struct LNode{
	Elemtype data;
	struct LNode *next;
}LNode,*LinkList;

bool ListInsert(LinkList &L,int i,Elemtype e){
	if(i<1) return false;
	if(i==1){//插入第1个结点的操作与其他结点操作不同 
		LNode *s=(LNode *)malloc(sizeof(LNode));
		s->data=e;
		s->next=L;
		L=s;//头指针指向新结点 
		return true; 
	}
	LNode *p;//指针p指向当前扫描到的结点 
	int j=1;//当前p指向的是第几个结点 
	p=L;//p指向第1个结点（不是头结点） 
	while(p!=NULL&&j<i-1){
		p=p->next;
		j++;
	} 
	if(p==NULL)return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}

在这里插入图片描述

//后插操作：在p结点之后插入元素e 
typedef struct LNode{
	Elemtype data;
	struct LNode *next;
}LNode,*LinkList;

bool InsertNextNode(LNode *p,Elemtype e){
	if(p==NULL) return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	//某些情况下可能分配失败，如内存不足 
	if(s==NULL) return false;
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true; 
}

在这里插入图片描述

在这里插入图片描述

//指定结点的前插操作 
//前插操作：在p结点之前插入元素e 
typedef struct LNode{
	Elemtype data;
	struct LNode *next;
}LNode,*LinkList;
bool ListInsert(LNode *p,Elemtype e){
	if(p==NULL) return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	//某些情况下可能分配失败，如内存不足 
	if(s==NULL) return false;
	s->next=p->next;
	p->next=s;//新结点s连接到p之后 
	s->data=p->data;//将p中元素复制到s中 
	p->data=e;//p中元素覆盖为e 
	return true; 
}

在这里插入图片描述
带头结点

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

typedef struct LNode {
	int data;//数据域
	struct LNode* next;//指针域
}LNode, * LinkList;

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L)
{
	int i;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;
	printf("请输入你要存储的数据，999为退出输入:\n");
	scanf_s("%d",&i);
	while (i != 999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = i;
		r->next = s;
		r = s;
		scanf_s("%d", &i);
	}
	r->next = NULL;
	return L;
}
//判空
bool Empty(LinkList L) {
	if (L->next == NULL) {
		printf("表空.\n");
		return true;
	}
	else {
		printf("表创建成功.\n");
		printf("尾插法建立的单链表如下:\n");
		return false;
	}
}

//打印输入的单链表的值
void test(LNode* L) {
	LinkList p;
	p = L->next;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
//按位序删除(带头结点)
bool LiseDelete(LinkList& L, int m, int &e) {
	printf("请输入删除的位置:");
	scanf_s("%d", &m);
	if (m < 1)
	{
		printf("删除位置不合法\n");
		return false;
	}
	LNode* p;
	int j = 0;
	p = L;
	while (p != NULL && j < m - 1) {
		p = p->next;
		j++;
	}
	if (p == NULL)
	{
		return false;
	}
	if (p->next == NULL)
	{
		return false;
	}
	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
}
//主函数
void main() {
	int m = 0;
	int e = 0;
	LinkList L;
	List_TailInsert(L);
	Empty(L);
	test(L);
	LiseDelete(L, m, e);
	printf("该位置的元素为：%d\n", e);
	printf("得到的新的单链表为：");
	test(L);
}
//请输入你要存储的数据，999为退出输入:
//23 54 56 87 999
//表创建成功.
//尾插法建立的单链表如下 :
//	23 54 56 87
//	请输入删除的位置 : 3
//	该位置的元素为：56
//	得到的新的单链表为：23 54 87

不带头结点

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

typedef struct LNode {
	int data;//数据域
	struct LNode* next;//指针域
}LNode, * LinkList;

/*不带头结点的单链表的创建(头插法)*/
LinkList LinkCreate(LinkList& L) {
	LNode* p;
	int a;
	L = NULL;
	printf("请输入数据:");
	scanf_s("%d", &a);
	while (a != 999) { //数据为9999时，停止输入
		p = (LNode*)malloc(sizeof(LNode));
		p->data = a;
		p->next = L;
		L = p;
		scanf_s("%d", &a); //连续输入数据
	}
	return L;
}
//判空
bool Empty(LinkList L) {
	if (L == NULL) {
		printf("表空.\n");
		return true;
	}
	else {
		printf("表创建成功.\n");
		printf("尾插法建立的单链表如下:\n");
		return false;
	}
}

//打印输入的单链表的值
void test(LNode* L) {
	while (L!= NULL) {
		printf("%d ", L->data);
		L = L->next;
	}
	printf("\n");
}
//按位序删除(不带头结点)
bool LiseDelete(LinkList& L, int m, int& e) {
	printf("请输入删除的位置:");
	scanf_s("%d", &m);
	if (m < 1)
	{
		printf("删除位置不合法\n");
		return false;
	}
	LNode* p;
	int j = 1;
	p = L;
	while (p != NULL && j < m - 1) {
		p = p->next;
		j++;
	}
	if (p == NULL)
	{
		return false;
	}
	if (p->next == NULL)
	{
		return false;
	}
	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
}
//主函数
void main() {
	int m = 0;
	int e = 0;
	LinkList L;
	LinkCreate(L);
	Empty(L);
	test(L);
	LiseDelete(L, m, e);
	printf("该位置的元素为：%d\n", e);
	printf("得到的新的单链表为：");
	test(L);
}
//请输入数据:23 54 56 87 999
//表创建成功.
//尾插法建立的单链表如下 :
//	87 56 54 23
//	请输入删除的位置 : 3
//	该位置的元素为：54
//	得到的新的单链表为：87 56 23

在这里插入图片描述

//删除指定结点p
bool Delete(LNode *p){
	if(p==NULL) return false;
	LNode *q=p->next;
	p->data=p->next->data;
	p->next=q->next;
	free(q);
	return true;
}

在这里插入图片描述

2.3.3单链表的查找

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

typedef struct LNode {
	int data;//数据域
	struct LNode* next;//指针域
}LNode, * LinkList;

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L)
{
	int i;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;
	printf("请输入你要存储的数据，999为退出输入:\n");
	scanf_s("%d",&i);
	while (i != 999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = i;
		r->next = s;
		r = s;
		scanf_s("%d", &i);
	}
	r->next = NULL;
	return L;
}
//判空
bool Empty(LinkList L) {
	if (L->next == NULL) {
		printf("表空.\n");
		return true;
	}
	else {
		printf("表创建成功.\n");
		printf("尾插法建立的单链表如下:\n");
		return false;
	}
}

//打印输入的单链表的值
void test(LNode* L) {
	LinkList p;
	p = L->next;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
//按位序查找(带头结点)
LNode* GetElem(LinkList L, int i) {
	printf("请输入查找的位置:");
	scanf_s("%d", &i);
	if (i < 0)
	{
		return NULL;
	}
	LNode* p;
	int j = 0;
	p = L;
	while (p != NULL && j < i)
	{
		p = p->next;
		j++;
	}
	return p;
}
//主函数
void main() {
	int m = 0;
	int i = 0;
	LNode* result;
	LNode* L = NULL;
	List_TailInsert(L);
	Empty(L);
	test(L);
	result=GetElem(L,i);
	printf("该位置的元素为:%d", *result);
}
//请输入你要存储的数据，999为退出输入:
//23 32 54 75 87 999
//表创建成功.
//尾插法建立的单链表如下 :
//	23 32 54 75 87
//	请输入查找的位置 : 3
//	该位置的元素为:54

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

2.3.4单链表的建立

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
带头结点

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

typedef struct LNode {
	int data;//数据域
	struct LNode* next;//指针域
}LNode, * LinkList;

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L)
{
	int i;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;
	printf("请输入你要存储的数据，999为退出输入:\n");
	scanf_s("%d",&i);
	while (i != 999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = i;
		r->next = s;
		r = s;
		scanf_s("%d", &i);
	}
	r->next = NULL;
	return L;
}


//判空
bool Empty(LinkList L) {
	if (L->next == NULL) {
		printf("表空.\n");
		return true;
	}
	else {
		printf("表创建成功.\n");
		printf("尾插法建立的单链表如下:\n");
		return false;
	}
}

//打印输入的单链表的值
void test(LNode* L) {
	LinkList p;
	p = L->next;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
//指定结点后插
bool InsertNextNode(LNode* p, int e) {
	if (p == NULL) {
		printf("插入位置不合法");
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
//按位序插入(带头结点插入)
bool ListInsert(LinkList& L, int m, int n) {
	printf("请输入插入的位置:");
	scanf_s("%d", &m);
	if (m < 1)
	{
		printf("插入位置不合法\n");
		return false;
	}
	LNode* p;
	int j = 0;
	p = L;
	while (p != NULL && j < m - 1) {
		p = p->next;
		j++;
	}
	//指定结点后插
	printf("插入的值为：");
	scanf_s("%d", &n);
	return InsertNextNode(p, n);
}
//主函数
void main() {
	int m = 0;
	int n = 0;
	LinkList L;
	List_TailInsert(L);
	Empty(L);
	test(L);
	ListInsert(L, m, n);
	printf("得到的新的单链表为：\n");
	test(L);
}
//请输入你要存储的数据，999为退出输入:
//23 32 4232 32 999
//表创建成功.
//尾插法建立的单链表如下 :
//	23 32 4232 32
//	请输入插入的位置 : 2
//	插入的值为：32
//	得到的新的单链表为：
//	23 32 32 4232 32

不带头结点

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

typedef struct Node {
	int data;          //数据域
	struct Node* next;   //指针域
}LNode, * LinkList; //单链表节点类型

//尾插法
void LinkCreate(LinkList& L) {
	int a;
	L = NULL;
	LNode* p, * r = L;
	printf("请输入数据:");
	scanf_s("%d", &a);
	while (a != 999) {
		p = (LNode*)malloc(sizeof(LNode));
		p->data = a;
		p->next = NULL;
		if (L == NULL) {
			L = p;
			r = L;
		}
		else {
			r->next = p;
			r = p;
		}
		scanf_s("%d", &a);
	}
}

//单链表的输出
void display(LinkList L) {
	printf("表中数据输出：");
	while (L != NULL) {
		printf("%d ", L->data);
		L = L->next;
	}
	printf("\n");
}

//指定结点后插
bool InsertNextNode(LNode* p, int e) {
	if (p == NULL) {
		printf("插入位置不合法");
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
//按位序插入(带头结点插入)
bool ListInsert(LinkList& L, int m, int n) {
	printf("请输入插入的位置:");
	scanf_s("%d", &m);
	if (m < 1)
	{
		printf("插入位置不合法\n");
		return false;
	}
	if (m == 1) {//插入第1个结点的操作与其他结点操作不同 
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = n;
		s->next = L;
		L = s;//头指针指向新结点 
		return true;
	}
	LNode* p;
	int j = 1;
	p = L;
	while (p != NULL && j < m - 1) {
		p = p->next;
		j++;
	}
	//指定结点后插
	printf("插入的值为：");
	scanf_s("%d", &n);
	return InsertNextNode(p, n);
}
int main() {
	int m = 0;
	int n = 0;
	LinkList L;
	LinkCreate(L);
	display(L);
	ListInsert(L, m, n);
	printf("得到的新的单链表为：\n");
	display(L);
	return 0;

}
//请输入数据:12 43 65 76 87 999
//表中数据输出：12 43 65 76 87
//请输入插入的位置 : 3
//插入的值为：432
//得到的新的单链表为：
//表中数据输出：12 43 432 65 76 87

在这里插入图片描述
在这里插入图片描述
带头结点

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

typedef struct LNode {
	int data;//数据域
	struct LNode* next;//指针域
}LNode, * LinkList;

//头插法建立单链表
LinkList List_HeadInsert(LinkList& L) {
	LNode* s;
	int i;
	L = (LNode*)malloc(sizeof(LNode));//创建头结点
	L->next = NULL;   //头结点的指针域设置为null
	printf("请输入你要存储的数据，999为退出输入:\n");
	scanf_s("%d", &i);
	while (i != 999)
	{
		s = (LNode*)malloc(sizeof(LNode));
		s->data = i;
		s->next = L->next; //实质就是s的后继指针域置为NULL，之所以写L->next是为了实现头插循环
		L->next = s;
		scanf_s("%d", &i);
	}
	return L;
}

//判空
bool Empty(LinkList L) {
	if (L->next == NULL) {
		printf("表空.\n");
		return true;
	}
	else {
		printf("表创建成功.\n");
		printf("头插法建立的单链表如下:\n");
		return false;
	}
}

//打印输入的单链表的值
void test(LNode* L) {
	LinkList p;
	p = L->next;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

//按位序插入(带头结点插入)
bool ListInsert(LinkList& L, int m, int n) {
	printf("请输入插入的位置:");
	scanf_s("%d", &m);
	if (m < 1)
	{
		printf("插入位置不合法\n");
		return false;
	}
	LNode* p;
	int j = 0;
	p = L;
	while (p != NULL && j < m - 1) {
		p = p->next;
		j++;
	}
	//指定结点后插
	if (p == NULL) {
		printf("插入位置不合法");
		return false;
	}
	printf("插入的值为：");
	scanf_s("%d", &n);
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = n;
	s->next = p->next;
	p->next = s;
	printf("得到的新的单链表为：\n");
	test(L);
	return true;
}
//主函数
void main() {
	int m = 0;
	int n = 0;
	LinkList L;
	List_HeadInsert(L);
	Empty(L);
	test(L);
	ListInsert(L, m, n);
}
//请输入你要存储的数据，999为退出输入:
//23 324 432 655 999
//表创建成功.
//头插法建立的单链表如下 :
//	655 432 324 23
//	请输入插入的位置 : 3
//	插入的值为：99
//	得到的新的单链表为：
//	655 432 99 324 23

不带头结点

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

//单链表的结构体
typedef struct LNode {
	int data;
	struct LNode* next;
}LNode, * LinkList;


/*不带头结点的单链表的创建(头插法)*/
LinkList  LinkCreate(LinkList& L) {
	LNode* p;
	int a;
	L = NULL;
	printf("请输入数据:");
	scanf_s("%d", &a);
	while (a != 999) { //数据为9999时，停止输入
		p = (LNode*)malloc(sizeof(LNode));
		p->data = a;
		p->next = L;
		L = p;
		scanf_s("%d", &a); //连续输入数据
	}
	return L;
}
//判空
bool Empty(LinkList L) {
	if (L == NULL) {
		printf("表空.\n");
		return true;
	}
	else {
		printf("表创建成功.\n");
		printf("头插法建立的单链表如下:\n");
		return false;
	}
}
//单链表的输出
void display(LinkList L) {
	printf("表中数据输出：");
	while (L != NULL) {
		printf("%d ", L->data);
		L = L->next;
	}
	printf("\n");
}
//指定结点后插
bool InsertNextNode(LNode* p, int e) {
	if (p == NULL) {
		printf("插入位置不合法");
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
//按位序插入(带头结点插入)
bool ListInsert(LinkList& L, int m, int n) {
	printf("请输入插入的位置:");
	scanf_s("%d", &m);
	if (m < 1)
	{
		printf("插入位置不合法\n");
		return false;
	}
	if (m == 1) {//插入第1个结点的操作与其他结点操作不同 
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = n;
		s->next = L;
		L = s;//头指针指向新结点 
		return true;
	}
	LNode* p;
	int j = 1;
	p = L;
	while (p != NULL && j < m - 1) {
		p = p->next;
		j++;
	}
	//指定结点后插
	printf("插入的值为：");
	scanf_s("%d", &n);
	return InsertNextNode(p, n);
}
/*主函数*/
int main() {
	int m = 0;
	int n = 0;
	LinkList L;
	LinkCreate(L);
	Empty(L);
	display(L);
	ListInsert(L, m, n);
	printf("得到的新的单链表为：\n");
	display(L);
	return 0;
}
//请输入数据:23 32 4232 32 999
//表创建成功.
//头插法建立的单链表如下 :
//	表中数据输出：32 4232 32 23
//	请输入插入的位置 : 2
//	插入的值为：124
//	得到的新的单链表为：
//	表中数据输出：32 124 4232 32 23

在这里插入图片描述

2.3.5双链表的定义

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.3.6循环链表的定义

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.3.7静态链表的定义

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.3.8顺序表和链表的对比

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Scean周
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
推荐几个正经网站，让你的数据结构和算法学习事半功倍！
weixin_48655626的博客
01-10 4868
前言 相信对于大部分程序员来说，数据结构和算法学起来是比较难的，但是它在工作中又是非常的重要，可以说是开发中的一块基石。 所以为了更好的学习和理解数据结构和算法，当时我是趁着双十一搞活动买了几本算法书，打算一鼓作气把它吃透，可想而知有点吃不消。 于是我就琢磨着应该会有更简单的学习数据结构和算法的方法？然后经过一轮技术论坛的“逛街”之后，终于找到了一些可以比较直观而又简单的学习数据结构和算法的网站。 其实主要是介绍几个用于学习数据结构和算法的“酷炫”网站。有了这几个网站就可以让你轻松的以动画的形式学习数据结
XianYU:仿闲鱼二手交易平台-iOS
04-29
XianYU 添加 首页模块和我的模块 首页水平滑动图利用自定义UICollectionViewFlowLayout实现 利用KVC,基于系统自带tabBar的进行定制实现底部TabBar。 页面跳转转场动画效果 封装刷新控件，仿闲鱼动画效果
王道数据结构
08-28
最新版王道数据结构，高清PDF，可以下载打印，来的同学都有了解，不多解释，只求好评
数据结构(王道版本，主讲人:闲鱼学长)P3-P6
Scxioi0的博客
02-16 3113
1.1.1：绪论 1.2.1 算法的基本概念 1.2.1 算法的时间复杂度 1.2.3 算法的空间复杂度
数据结构(王道版本，主讲人:闲鱼学长)P19-P31
Scxioi0的博客
02-19 4574
第三章 栈和队列 3.1.1 栈的基本概念 3.1.2 顺序栈的实现 #include <stdio.h> #define MaxSize 10 typedef struct { int date[MaxSize]; int top; }SqStack; void InitStack(SqStack& S) { S.top = -1; } bool StackEmpty(SqStack S) { if (S.top == -1) { return tru
【咸鱼期末】数据结构知识点（1）
soviet1941的博客
11-24 431
期末复习ppt 三到八章
闲鱼接单-音乐播放器项目p2p传输 falsk框架
07-25
# MusicInfo Player CUHK22-23 CSCI3280 Group Project ### 未完成列表： * [ ] p2p传输 * [ ] 歌词滚动 * [ ] cd封面 * [ ] 歌曲动效（参考网易云） * [ ] 徒手wav解码 ...> #### `Components`: UI組件, 有共通的底...
交易猫转转闲鱼源码-二手闲置源码
01-04
交易猫转转闲鱼源码一款二手闲置源码，今天测试了一下，交易猫转转闲鱼源码功能完整 感兴趣的可以下载了解。 搭建教程： 上传源码到服务器然后解压好，将域名绑定到源码所在文件夹，然后找到数据库config/Conn....
（35节）闲鱼电商运营高级课程，一部手机学会闲鱼开店赚钱-课程网盘链接提取码下载 .txt
最新发布
05-26
（35节）闲鱼电商运营高级课程，一部手机学会闲鱼开店赚钱-课程网盘链接提取码下载 .txt
闲鱼-1.zip
05-21
标题“闲鱼-1.zip”和描述中的信息虽然没有提供具体的IT知识点，但根据压缩包内的文件名，我们可以推测这可能是一个与网站建设和管理相关的项目。以下是对这些文件的详细解释： 1. `.htaccess`：这是一个Apache...
王道2019数据结构
08-29
分享给时间不够又急于找资源的同学们，实在木有积分的可以私信。
王道考研2015年数据结构
03-02
王道考研 2015年 数据结构 pdf 经过极限压缩了 章节都在的
2019王道论坛四本专业课辅导书高清pdf打包下载
04-04
2019年王道论坛四本专业辅导书,高清pdf; 2019年王道论坛四本专业辅导书,高清pdf打包下载;
2019年王道考研单科计算机组成原理
02-25
2019年王道考研单科计算机组成原理 高清
咸鱼学数据结构和算法——约瑟夫问题
qq_37324376的博客
01-19 243
本文主要介绍约瑟夫问题算法和具体代码实现
安利一个学习数据结构的宝藏网站
阿鹏的博客
04-27 1172
安利一个学习数据结构的宝藏网站！！！
计算机网络学习笔记——第六章：应用层
番茄炒蛋不加蛋！的博客
07-14 1080
第六章：应用层 6.1 网络应用模型 1、应用层概述 应用层对应用程序的通信提供服务。 应用层协议定义：应用进程交换的报文类型，请求还是相应；各种报文类型的语法，如报文中的各个字段及其详细描述；字段的语义，即包含在字段中的信息的含义；进程何时、如何发送报文，以及对报文进行相应的规则。 应用层的功能：文件传输、访问和管理；电子邮件；虚拟终端；查询服务和远程作业登录 应用层的重要协议：FTP、SMTP、POP3、HTTP、DNS 2、网络应用模型 1）客户/服务器（C/S）模型（Client/S
算法与数据结构王道天勤_21年西电网信学长考研951数据结构复习经验
weixin_39566864的博客
01-01 638
951数据结构复习规划 一、复习资料 《数据结构与算法分析》（荣政）《王道数据结构》+《天勤数据结构》西电数据结构期末题951历年真题951讲课+押题班二、复习规划 第一轮： 7月初至8月中旬。目标：攻克选择+判断+填空 ，并保证扣分少于10分分值：75用书：王道+荣政课本每日建议复习时间：2.5小时每日复习方法：1. 先完成王道上的一个小节（注意不是一章），包括知识点和选择题，选择题不会的先看答...
2023最新广西大学计算机电子信息考研828数据结构与程序设计上岸冲刺宝典（后续会更新复试资料） 算法模板+历年真题+必背C语言题型+必背算法
热门推荐
weixin_45185577的博客
07-15 1万+
广西大学计算机电子信息考研828数据结构与程序设计上岸冲刺宝典（后续会有复试资料） 算法模板+历年真题+必背C语言题型+必背算法
深度竞品分析：阿里旗下闲鱼与58旗下转转.pdf
07-22
深度竞品分析：阿里旗下闲鱼与58旗下转转.pdf

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值