数据结构之线性表（三）

最新推荐文章于 2024-07-18 17:57:16 发布
最新推荐文章于 2024-07-18 17:57:16 发布
阅读量181 收藏 3
点赞数 6
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/semu2000/article/details/130045183
版权

目录

1.循环单向链表

1.1 定义

1.2 基本操作

1.3 代码实现

1.3.1 初始化

1.3.2 求表长

1.3.3 判空

1.3.4 整表创建 头插法

1.3.5 遍历输入

1.3.6 整表清除

1.3.7 整表创建 头插法

1.3.8 插入

1.3.9 按位查找

1.3.10 按值查找

1.3.11 删除

 1.4 完整代码

2.循环双向链表 

2.1 定义

2.2 基本操作

2.3 代码实现

2.3.1 初始化

2.3.2 求表长

2.3.3 判空

2.3.4 整表创建 尾插法

2.3.5 遍历

2.3.6 整表清空

2.3.7 插入

​编辑2.3.8 按位查找

​编辑2.3.9 按值查找

​编辑2.3.10 删除

2.4 双向循环链表的完整代码实现

tips:本章节讲述 循环单向链表 与 循环双向链表！！！

1.循环单向链表

1.1 定义

        循环单链表 和 单链表的区别在于，表中最后一个结点的指针不是NULL，而是改为指向头结点，从而整个链表形成一个环。

        在循环单链表中，表尾结点的指针域指向L，故表中没有指针域为NULL的结点，因此循环单链表的判空条件不是头结点的指针是否为空，而是它是否等于头指针。

        在单链表中只能从表头结点开始往后顺序遍历整个链表，而循环单链表可以从表中的任意一个结点开始遍历整个表。有时对单链表常做的操作是在表头和表尾进行的，此时对循环单链表不设头指针而仅设尾指针，从而使得操作的效率更高。其原因是，若设的是头指针，对表尾进行操作需要O(n)的时间复杂度，而设的是尾指针r,r->next 即是头指针，对表头和表尾进行操作都只需要O(1）的时间复杂度。

 

1.2 基本操作

//初始化
//求表长
//判空
//整表创建 尾插法
//遍历输入
//整表清除
//整表创建 头插法
//插入
//按位查找
//按值查找
//删除

1.3 代码实现

#define _CRT_SECURE_NO_WARNINGS 1

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0


typedef int ElemType;
typedef int Status;

typedef struct Node
{
	ElemType data;
	struct Node* next;
}Node,*LinkList;

1.3.1 初始化

//初始化循环单链表
Status InitList(LinkList* L)
{
	//开辟内存空间
	*L = (LinkList)malloc(sizeof(Node));  //创建头结点，并让头指针L指向此结点
	if (!(*L))
	{
		return ERROR;
	}
	//头指针的指针域 指向 头结点   //循环
	(*L)->next = (*L);
	
}


1.3.2 求表长

/* 初始条件：循环单链表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
	LinkList p = L;   //指针p指向头结点
	int i = 0;
	while (p->next != L)    //当指针p的下一个结点不是头结点时进入循环
	{
		p = p->next;    //p指向下一个结点
		i++;
	}

	return i;
}


1.3.3 判空

/* 初始条件：链式线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{
	if (L->next == L)   //若头结点的指针域 指向 它自己，则为空
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

        

1.3.4 整表创建 头插法

 

/*  随机产生n个元素的值，建立带表头结点的循环单链表L（头插法） */
void CreateList_Head(LinkList* L, int n)
{
	//srand(time(0));   //初始化随机种子

	//创建一个带头结点的单链表
	(*L) = (LinkList)malloc(sizeof(Node));
	(*L)->next = (*L);

	//在头结点后，循环插入n个随机数
	LinkList p;
	for (int i = 0; i < n; i++)
	{
		//创建新的结点，并让p指向新的结点
		p = (LinkList)malloc(sizeof(Node));
		p->data = i;
		//p->data = rand() % 100 + 1;  //随机生成100以内的数字

		p->next = (*L)->next;   //把头结点后面的结点（第一个结点）的地址 赋值 给新指针p指向结点的指针域
		(*L)->next = p;
	}
}


1.3.5 遍历输入

/* 初始条件：循环单链表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status visit(ElemType c)
{
	printf("%d ", c);
	return OK;
}

void ListTraverse(LinkList L)
{
	LinkList p = L->next;   //指针p指向第一个结点
	while (p != L)  //当遍历到最后一个结点后，循环单链表回到头结点，遍历结束
	{
		visit(p->data);
		p = p->next;    //指针p指向下一个结点
	}
	printf("\n");
	return OK;
}

        测试代码：

1.3.6 整表清除

/* 初始条件：循环单链表L已存在。操作结果：将L重置为空表 */
Status ListClear(LinkList* L)
{
	LinkList p, q;
	//指针p指向第一个结点
	p = (*L)->next;

	while (p != *L)
	{
		q = p->next;  //指针q指向 p指向结点的 后一个结点（把p指向结点 后一个结点的地址赋值给q）
		free(p);   //释放 p指向的结点
		p = q;     //让指针p指向（新的）第一个结点
	}

	(*L)->next = (*L);   //头结点的指针域 指向头结点
	return OK;
}

        测试代码：

1.3.7 整表创建 头插法

/*  随机产生n个元素的值，建立带表头结点的循环单链表L（尾插法） */
void CreateList_Tail(LinkList* L, int n)
{
	//srand(time(0));   //初始化随机种子

	(*L) = (LinkList)malloc(sizeof(Node));   //创建头结点

	LinkList p, r;  //声明两个结构体指针
	r = (*L);    //指针r 指向链表尾部的结点

	for (int i = 0; i < n; i++)
	{
		p = (Node*)malloc(sizeof(Node));  //创建新结点，让p指向新结点
		//p->data = rand() % 100 + 1;
		p->data = i;

		r->next = p;   //把新结点的地址 赋值给 表尾结点的指针域 
		r = p;        //让r指向新的表尾结点
	}

	r->next = (*L);
}

        测试代码：

1.3.8 插入


/* 初始条件：循环单链表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e*/
Status ListInsert(LinkList* L, int i, ElemType e)
{
	LinkList p, s;
	p = (*L); //p指向头结点
	int j = 1;
	while ((p->next != (*L)) && j < i)   //逻辑与，同真才为真，即需要同时满足两个条件才进入循环
	{
		p = p->next;
		j++;
	}
	if ((p->next == L) || j > i)   
	{
		return ERROR;
	}

	s = (LinkList)malloc(sizeof(Node));
	s->data = e;
	s->next = p->next;    //把p的后继结点的地址 赋值给 s的指针域
	p->next = s;    //再把s的地址 赋值给 p的指针域

	return OK;
}

        测试代码：

1.3.9 按位查找

/* 初始条件：L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
//按位查找
Status GetElem(LinkList L, int i, ElemType* e)
{
	LinkList p;
	p = L->next;    //指针p指向第一个结点
	int j = 1;             //当查找的元素i为1时，直接返回p指向结点的数据域
	while ((p->next != L) && j < i)   //逻辑与，同真才为真，同时满足两个条件才进入循环
	{
		p = p->next;    //让p指向下一个结点
		j++;
	}
	if (j > i)   //逻辑与，同假为假，即满足其中一个条件，便可进入循环
	{
		return ERROR;
	}
	*e = p->data;

	return OK;
}

1.3.10 按值查找

/* 初始条件：循环单链表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
Status LocateElem(LinkList L, ElemType e)
{
	LinkList p = L->next;  //p指向头结点的后继结点（第一个结点）
	int i = 1;
	while (p != L)
	{
		if (p->data == e)
		{
			return i;
		}
		else
		{
			p = p->next;
			i++;
		}
	}

	return 0;
}


1.3.11 删除

 

/* 初始条件：循环单链表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList* L, int i, ElemType* e)
{
	LinkList p, q;
	p = (*L);  // p指向头结点
	int j = 1;
	while ((p->next != L) && j < i)
	{
		p = p->next;
		j++;
	}
	if ((p->next == L) || j > i)
	{
		return ERROR;
	}
	q = p->next;
	p->next = q->next;
	*e = q->data;
	free(q);

	return OK;
}

 

 1.4 完整代码

#define _CRT_SECURE_NO_WARNINGS 1

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0


typedef int ElemType;
typedef int Status;

typedef struct Node
{
	ElemType data;
	struct Node* next;
}Node,*LinkList;


//初始化循环单链表
Status InitList(LinkList* L)
{
	//开辟内存空间
	*L = (LinkList)malloc(sizeof(Node));  //创建头结点，并让头指针L指向此结点
	if (!(*L))
	{
		return ERROR;
	}
	//头指针的指针域 指向 头结点   //循环
	(*L)->next = (*L);
	
}


/* 初始条件：链式线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{
	if (L->next == L)   //若头结点的指针域 指向 它自己，则为空
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}


/* 初始条件：循环单链表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
	LinkList p = L;   //指针p指向头结点
	int i = 0;
	while (p->next != L)    //当指针p的下一个结点不是头结点时进入循环
	{
		p = p->next;    //p指向下一个结点
		i++;
	}

	return i;
}

/*  随机产生n个元素的值，建立带表头结点的循环单链表L（头插法） */
void CreateList_Head(LinkList* L, int n)
{
	//srand(time(0));   //初始化随机种子

	//创建一个带头结点的单链表
	(*L) = (LinkList)malloc(sizeof(Node));
	(*L)->next = (*L);

	//在头结点后，循环插入n个随机数
	LinkList p;
	for (int i = 0; i < n; i++)
	{
		//创建新的结点，并让p指向新的结点
		p = (LinkList)malloc(sizeof(Node));
		p->data = i;
		//p->data = rand() % 100 + 1;  //随机生成100以内的数字

		p->next = (*L)->next;   //把头结点后面的结点（第一个结点）的地址 赋值 给新指针p指向结点的指针域
		(*L)->next = p;
	}
}

/* 初始条件：循环单链表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status visit(ElemType c)
{
	printf("%d ", c);
	return OK;
}

void ListTraverse(LinkList L)
{
	LinkList p = L->next;   //指针p指向第一个结点
	while (p != L)  //当遍历到最后一个结点后，循环单链表回到头结点，遍历结束
	{
		visit(p->data);
		p = p->next;    //指针p指向下一个结点
	}
	printf("\n");
	return OK;
}



/* 初始条件：循环单链表L已存在。操作结果：将L重置为空表 */
Status ListClear(LinkList* L)
{
	LinkList p, q;
	//指针p指向第一个结点
	p = (*L)->next;

	while (p != *L)
	{
		q = p->next;  //指针q指向 p指向结点的 后一个结点（把p指向结点 后一个结点的地址赋值给q）
		free(p);   //释放 p指向的结点
		p = q;     //让指针p指向（新的）第一个结点
	}

	(*L)->next = (*L);   //头结点的指针域 指向头结点
	return OK;
}

/*  随机产生n个元素的值，建立带表头结点的循环单链表L（尾插法） */
void CreateList_Tail(LinkList* L, int n)
{
	//srand(time(0));   //初始化随机种子

	(*L) = (LinkList)malloc(sizeof(Node));   //创建头结点

	LinkList p, r;  //声明两个结构体指针
	r = (*L);    //指针r 指向链表尾部的结点

	for (int i = 0; i < n; i++)
	{
		p = (Node*)malloc(sizeof(Node));  //创建新结点，让p指向新结点
		//p->data = rand() % 100 + 1;
		p->data = i;

		r->next = p;   //把新结点的地址 赋值给 表尾结点的指针域 
		r = p;        //让r指向新的表尾结点
	}

	r->next = (*L);
}

/* 初始条件：循环单链表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e*/
Status ListInsert(LinkList* L, int i, ElemType e)
{
	LinkList p, s;
	p = (*L); //p指向头结点
	int j = 1;
	while ((p->next != (*L)) && j < i)   //逻辑与，同真才为真，即需要同时满足两个条件才进入循环
	{
		p = p->next;
		j++;
	}
	if ((p->next == L) || j > i)   
	{
		return ERROR;
	}

	s = (LinkList)malloc(sizeof(Node));
	s->data = e;
	s->next = p->next;    //把p的后继结点的地址 赋值给 s的指针域
	p->next = s;    //再把s的地址 赋值给 p的指针域

	return OK;
}

/* 初始条件：L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
//按位查找
Status GetElem(LinkList L, int i, ElemType* e)
{
	LinkList p;
	p = L->next;    //指针p指向第一个结点
	int j = 1;             //当查找的元素i为1时，直接返回p指向结点的数据域
	while ((p->next != L) && j < i)   //逻辑与，同真才为真，同时满足两个条件才进入循环
	{
		p = p->next;    //让p指向下一个结点
		j++;
	}
	if (j > i)   //逻辑与，同假为假，即满足其中一个条件，便可进入循环
	{
		return ERROR;
	}
	*e = p->data;

	return OK;
}

/* 初始条件：循环单链表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
Status LocateElem(LinkList L, ElemType e)
{
	LinkList p = L->next;  //p指向头结点的后继结点（第一个结点）
	int i = 1;
	while (p != L)
	{
		if (p->data == e)
		{
			return i;
		}
		else
		{
			p = p->next;
			i++;
		}
	}

	return 0;
}


/* 初始条件：循环单链表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList* L, int i, ElemType* e)
{
	LinkList p, q;
	p = (*L);  // p指向头结点
	int j = 1;
	while ((p->next != L) && j < i)
	{
		p = p->next;
		j++;
	}
	if ((p->next == L) || j > i)
	{
		return ERROR;
	}
	q = p->next;
	p->next = q->next;
	*e = q->data;
	free(q);

	return OK;
}

void test01()
{
	LinkList L;
	//初始化
	InitList(&L);
	//判空
	Status i_empty = ListEmpty(L);
	printf("表是否为空（1为是/0为否）：%d\n", i_empty);   //表是否为空（1为是/0为否）：1
	//求表长
	int i_length = ListLength(L);
	printf("表的长度为：%d\n", i_length);  //表的长度为：0
}


void test02()
{
	LinkList L;
	//头插法
	CreateList_Head(&L,10);  //在表头插入0~9
	//判空
	Status i_empty = ListEmpty(L);
	printf("表是否为空（1为是/0为否）：%d\n", i_empty);  //表是否为空（1为是/0为否）：0
	//求表长
	int i_length = ListLength(L);
	printf("表的长度为：%d\n", i_length);    //表的长度为：10
	//遍历
	ListTraverse(L);  //9 8 7 6 5 4 3 2 1 0

	printf("---------------------------------------\n");

	//清空表
	ListClear(&L);
	//判空
	i_empty = ListEmpty(L);
	printf("表是否为空（1为是/0为否）：%d\n", i_empty);  //表是否为空（1为是/0为否）：1
	//求表长
	i_length = ListLength(L);
	printf("表的长度为：%d\n", i_length);    //表的长度为：0
	//遍历
	ListTraverse(L);  //(为空)



}


void test03()
{
	LinkList L;
	//创建循环单链表（尾插法）
	CreateList_Tail(&L, 10);
	//判空
	Status i_empty = ListEmpty(L);
	printf("表是否为空（1为是/0为否）：%d\n", i_empty);  //表是否为空（1为是/0为否）：0
	//求表长
	int i_length = ListLength(L);
	printf("表的长度为：%d\n", i_length);    //表的长度为：10
	//遍历
	ListTraverse(L);  //0 1 2 3 4 5 6 7 8 9

	printf("-----------------------------------\n");

	ListInsert(&L, 10, 20); //在表中第10个位置之前插入20
	//判空
	i_empty = ListEmpty(L);
	printf("表是否为空（1为是/0为否）：%d\n", i_empty);  //表是否为空（1为是/0为否）：0
	//求表长
	i_length = ListLength(L);
	printf("表的长度为：%d\n", i_length);    //表的长度为：11
	//遍历
	ListTraverse(L);   //0 1 2 3 4 5 6 7 8 20 9

	printf("-----------------------------------\n");
	//按位查找
	//int i = 11;
	//ElemType e ;
	//GetElem(L, i, &e);
	//printf("表中第 %d 位元素为 %d \n", i, e);  //表中第 1 位元素为 0


	//按值查找
	//ElemType e = 9;
	//Status i_locate = LocateElem(L, e);
	//printf("元素 %d 位于标志的第 %d 位(0表示元素不存在)\n", e, i_locate);  //元素 9 位于标志的第 11 位(0表示元素不存在)

	//按位删除
	ElemType e = 0;
	int i = 10;
	ListDelete(&L, i, &e);
	printf("表中被删除的位序为%d的元素是 %d \n", i, e);   //表中被删除的位序为10的元素是 20
}

int main()
{
	test01();

	//test02();

	//test03();

	system("pause");
	return 0;
}

2.循环双向链表 

2.1 定义

      由循环单链表的定义不难推出循环双链表。不同的是在循环双链表中，头结点的prior指针还要指向表尾结点。

 

 

2.2 基本操作

//初始化
//求表长
//判空
//整表创建 尾插法
//遍历
//整表清空
//插入
//按位查找
//按值查找
//删除

2.3 代码实现

#define _CRT_SECURE_NO_WARNINGS 1

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


#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;

typedef struct DLNode
{
	ElemType data;
	struct DLNode* prior;
	struct DLNode* next;
}DLNode,*DLinkList;

2.3.1 初始化


//初始化循环双向链表
Status InitList(DLinkList* DL)
{
	//动态开辟一个结点的空间
	(*DL) = (DLinkList)malloc(sizeof(DLNode));  //创建头结点 并让头指针DL指向该结点

	if (!(*DL)) //开辟空间失败，返回FALSE
	{
		return ERROR;
	}

	(*DL)->prior = (*DL);   //将头结点的 前继指针和后继指针指向其自己
	(*DL)->next = (*DL);

	return OK;
}


2.3.2 求表长

//求表长
int ListLength(DLinkList DL)
{
	DLinkList p = DL->next;
	int i = 0;
	while(p != DL)
	{
		p = p->next;
		i++;
	}
	return i;
}


2.3.3 判空

//判空（空返回TRUE，不为空返回FALSE）
Status ListEmpty(DLinkList DL)
{
	if (DL->next != DL) 
	{
		return FALSE;  //不为空
	}
	else
	{ 
		return TRUE;  //为空
	}
}


2.3.4 整表创建 尾插法

//整表创建
//创建一个n个元素的双向循环链表
void CreateList_Tail(DLinkList* DL, int n)
{
	//初始化
	(*DL) = (DLinkList)malloc(sizeof(DLNode));
	(*DL)->prior = (*DL);
	(*DL)->next = (*DL);

	DLinkList p, s;
	p = (*DL);
	for (int i = 0; i < n; i++)
	{
		//创建新的结点
		s = (DLinkList)malloc(sizeof(DLNode));
		s->data = i;

		s->prior = p;
		s->next = p->next;
		p->next = s;
		(*DL)->prior = s;

		p = s; //p指针向后移动到新的结点
		//printf("%d ", p->data);
	}

}


2.3.5 遍历

//遍历输出
/* 初始条件：双向循环链表DL已存在 */
/* 操作结果：依次对DL的每个数据元素输出 */
Status visit(ElemType c)
{
	printf("%d ", c);
	return OK;
}

void ListTraverse(DLinkList DL)
{
	DLinkList p = DL->next;
	while (p != DL)
	{
		//visit(p->data);
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");

}

 


2.3.6 整表清空

//清空表
Status ListClear(DLinkList* DL)
{
	DLinkList p, q;
	p = (*DL)->next;

	while (p != (*DL))
	{
		q = p->next;
		free(p);
		p = q;
	}
	(*DL)->next = (*DL);
}

 


2.3.7 插入

//按位插入（1 <= i <= length）
Status ListInsert(DLinkList* DL, int i, ElemType e)
{
	DLinkList p, s;
	p = (*DL); // p指向头结点
	int j = 1;
	while (p->next != (*DL) && j < i)
	{
		p = p->next;
		j++;
	}
	if (p->next == (*DL) || j > i)  //空表 或 输入非法时
	{
		return ERROR;
	}

	s = (DLinkList)malloc(sizeof(DLNode));
	s->data = e;

	s->prior = p;
	s->next = p->next;
	p->next->prior = s;
	p->next = s;

	p = s;

	return OK;
}


2.3.8 按位查找

 

//按位查找
Status GetElem(DLinkList DL, int i, ElemType* e)
{
	DLinkList p = DL->next;   //p指向第一个结点
	int j = 1;
	while ((p != DL) && j < i)   //p不指向头结点 与 j<i 同时满足时进入循环
	{
		p = p->next;               //向后遍历寻找第i个元素
		j++;
	}
	if ((p == DL) || j > i)     // 为空表 或 输入i值非法  有一个被满足时进入分支
	{
		return ERROR;         
	}
	
	*e = p->data;

	return OK;
}


2.3.9 按值查找

 

//按值查找
Status LocateElem(DLinkList DL, ElemType e)
{
	DLinkList p = (DL)->next;

	int i = 1;
	while (p != DL)
	{
		if (p->data == e)
		{
			return i;
		}
		else
		{
			p = p->next;
			i++;
		}
	}

	return FALSE;
}


2.3.10 删除

 


//按位删除
Status DeleteElem(DLinkList* DL, int i, ElemType* e)
{
	DLinkList p = (*DL)->next;
	int j = 1;
	while ((p != (*DL)) && j < i)
	{
		p = p->next;
		j++;
	}
	if ((p == (*DL)) || j > i)
	{
		return ERROR;
	}

	*e = p->data;
	
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	
	return OK;
}

2.4 双向循环链表的完整代码实现

#define _CRT_SECURE_NO_WARNINGS 1

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


#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;

typedef struct DLNode
{
	ElemType data;
	struct DLNode* prior;
	struct DLNode* next;
}DLNode,*DLinkList;

//初始化双向循环链表
Status InitList(DLinkList* DL)
{
	//动态开辟一个结点的空间
	(*DL) = (DLinkList)malloc(sizeof(DLNode));  //创建头结点 并让头指针DL指向该结点

	if (!(*DL)) //开辟空间失败，返回FALSE
	{
		return ERROR;
	}

	(*DL)->prior = (*DL);   //将头结点的 前继指针和后继指针指向其自己
	(*DL)->next = (*DL);

	return OK;
}

//求表长
int ListLength(DLinkList DL)
{
	DLinkList p = DL->next;
	int i = 0;
	while(p != DL)
	{
		p = p->next;
		i++;
	}
	return i;
}

//判空（空返回TRUE，不为空返回FALSE）
Status ListEmpty(DLinkList DL)
{
	if (DL->next != DL) 
	{
		return FALSE;  //不为空
	}
	else
	{ 
		return TRUE;  //为空
	}
}

//整表创建
//创建一个n个元素的双向循环链表
void CreateList_Tail(DLinkList* DL, int n)
{
	//初始化
	(*DL) = (DLinkList)malloc(sizeof(DLNode));
	(*DL)->prior = (*DL);
	(*DL)->next = (*DL);

	DLinkList p, s;
	p = (*DL);
	for (int i = 0; i < n; i++)
	{
		//创建新的结点
		s = (DLinkList)malloc(sizeof(DLNode));
		s->data = i;

		s->prior = p;
		s->next = p->next;
		p->next = s;
		(*DL)->prior = s;

		p = s; //p指针向后移动到新的结点
		//printf("%d ", p->data);
	}

}

//遍历输出
/* 初始条件：双向循环链表DL已存在 */
/* 操作结果：依次对DL的每个数据元素输出 */
Status visit(ElemType c)
{
	printf("%d ", c);
	return OK;
}

void ListTraverse(DLinkList DL)
{
	DLinkList p = DL->next;
	while (p != DL)
	{
		//visit(p->data);
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");

}


//清空表
Status ListClear(DLinkList* DL)
{
	DLinkList p, q;
	p = (*DL)->next;

	while (p != (*DL))
	{
		q = p->next;
		free(p);
		p = q;
	}
	(*DL)->next = (*DL);
}

//按位插入（1 <= i <= length）
Status ListInsert(DLinkList* DL, int i, ElemType e)
{
	DLinkList p, s;
	p = (*DL); // p指向头结点
	int j = 1;
	while (p->next != (*DL) && j < i)
	{
		p = p->next;
		j++;
	}
	if (p->next == (*DL) || j > i)  //空表 或 输入非法时
	{
		return ERROR;
	}

	s = (DLinkList)malloc(sizeof(DLNode));
	s->data = e;

	s->prior = p;
	s->next = p->next;
	p->next->prior = s;
	p->next = s;

	p = s;

	return OK;
}

//按位查找
Status GetElem(DLinkList DL, int i, ElemType* e)
{
	DLinkList p = DL->next;   //p指向第一个结点
	int j = 1;
	while ((p != DL) && j < i)   //p不指向头结点 与 j<i 同时满足时进入循环
	{
		p = p->next;               //向后遍历寻找第i个元素
		j++;
	}
	if ((p == DL) || j > i)     // 为空表 或 输入i值非法  有一个被满足时进入分支
	{
		return ERROR;         
	}
	
	*e = p->data;

	return OK;
}


//按值查找
Status LocateElem(DLinkList DL, ElemType e)
{
	DLinkList p = (DL)->next;

	int i = 1;
	while (p != DL)
	{
		if (p->data == e)
		{
			return i;
		}
		else
		{
			p = p->next;
			i++;
		}
	}

	return FALSE;
}

//按位删除
Status DeleteElem(DLinkList* DL, int i, ElemType* e)
{
	DLinkList p = (*DL)->next;
	int j = 1;
	while ((p != (*DL)) && j < i)
	{
		p = p->next;
		j++;
	}
	if ((p == (*DL)) || j > i)
	{
		return ERROR;
	}

	*e = p->data;
	
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	
	return OK;
}

void test01()
{
	//整表创建 尾插法
	DLinkList DL;
	CreateList_Tail(&DL, 10);
	//判空
	Status i_empty = ListEmpty(DL);
	printf("表是否为空（1为是/0为否）：%d\n", i_empty);  //表是否为空（1为是/0为否）：0
	//求表长
	int i_length = ListLength(DL);
	printf("表的长度为：%d\n", i_length);  //	表的长度为：10
	//遍历
	ListTraverse(DL);  //0 1 2 3 4 5 6 7 8 9

	printf("--------------------------------------\n");
	
	清空表
	//ListClear(&DL);
	判空
	//i_empty = ListEmpty(DL);
	//printf("表是否为空（1为是/0为否）：%d\n", i_empty);  // 表是否为空（1为是/0为否）：1
	求表长
	//i_length = ListLength(DL);
	//printf("表的长度为：%d\n", i_length);  //	表的长度为：0
	遍历
	//ListTraverse(DL);  //

	printf("--------------------------------------\n");

	//按位插入
	ListInsert(&DL, 1, 10);  //在表中第1个元素之前插入10
	//判空
	i_empty = ListEmpty(DL);
	printf("表是否为空（1为是/0为否）：%d\n", i_empty);  //表是否为空（1为是/0为否）：0
	//求表长
	i_length = ListLength(DL);
	printf("表的长度为：%d\n", i_length);  //	表的长度为：11
	//遍历
	ListTraverse(DL);  //	10 0 1 2 3 4 5 6 7 8 9

	printf("--------------------------------------\n");

	//按位查找
	ElemType e1 = 0;
	int i1 = 1;
	GetElem(DL, i1, &e1);
	printf("表中第 %d 个元素是 %d \n", i1, e1);  //表中第 1 个元素是 10

	//按值查找
	ElemType e2 = 10;
	int i2 = LocateElem(DL,e2);
	printf("值为 %d 的元素在表的第 %d 个位置\n", e2, i2);   //值为 10 的元素在表的第 1 个位置

	//按位删除
	int i3 = 11;
	ElemType e3 = -1;
	DeleteElem(&DL, i3, &e3);
	printf("表中被删除的第 %d 个元素为 %d \n", i3, e3);  //表中被删除的第 11 个元素为 9
	//求表长
	i_length = ListLength(DL);
	printf("表的长度为：%d\n", i_length);  //	表的长度为：10
	//遍历
	ListTraverse(DL);  //10 0 1 2 3 4 5 6 7 8
}

void test02()
{
	DLinkList DL;
	//初始化
	InitList(&DL);
	//判空
	Status i_empty = ListEmpty(DL);
	printf("表是否为空（1为是/0为否）：%d\n", i_empty);  //表是否为空（1为是/0为否）：1
	//求表长
	int i_length = ListLength(DL);
	printf("表的长度为：%d\n", i_length);  // 表的长度为：0

}

int main()
{

	//test01();

	test02();

	system("pause");
	return 0;
}

 END

semu2000
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
数据结构--3.线性表
weixin_43798821的博客
03-30 614
3.线性表 3.1线性表的定义 零个或多个数据元素的有限序列 它是一个序列，就是说元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继其他每个元素都有且仅有一个前驱和后继 同时，线性表强调有限，元素个数是有限的 用数学语言定义如下 3.2线性表的抽象数据类型 定义如下 ADT 线性表(List) Data 线性表的数据对象集合为(a1,a2,...an),每个元素的类型均为DataType。 其中，除第一元素a1外，每一个元素有且仅有一个直接前驱元素， 除了最
数据结构之线性表（Java）
m0_46340286的博客
03-09 1687
Java写数据结构01 线性表 定义 ​ 线性表是最常用且最简单的一种数据结构。简言之，一个线性表是n个数据元素的有限序列。在稍复杂的线性表中，一个数据元素可以有若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称文件。（为什么称为线性表，是因为符合线性结构：结构中的数据元素存在一个对一个的关系。而常见的非线性结构有：树，广义表，多维数组等等，他们都不是一对一的关系） 1.线性表的顺序表示 ​ 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。假设
大话数据结构——3线性表
spark
10-08 218
线性表 线性表的定义         定义：零个或多个数据元素的有限序列。         一个有顺序的序列。第一个元素无前驱，最后一个元素无后继。其他每个元素都只有一个前驱和一个后继。         线性表的元素个数n定义为线性表的长度n，当n=0的时候为空表。在非空的数...
数据结构（3）— 线性表之顺序存储详解介绍（含代码）
在嵌入式嵌入式领域奋斗的程序猿的博客
03-10 3235
数据结构（3）— 线性表之顺序存储详解介绍（含代码）
python数据结构之线性表
m0_71417856的博客
04-12 1312
python线性表的一些基本操作，包括顺序表和单链表
数据结构之线性表
总结论文中的算法并给出论文的复现代码
02-09 3959
线性表是最基本且最常用的一种线性结构，同时也是其他数据结构的基础。本文首先介绍线性表的定义和特点，然后对线性表的主要操作用C语言程序进行实现，最后给出线性表的应用实例。
数据结构——线性表
qq_52434831的博客
04-24 2872
数据结构线性表的基础知识及常用算法的总结
数据结构之线性表之线性表顺序存储结构
m0_74018560的博客
12-10 657
数据结构之线性表部分之线性表存储结构
数据结构之线性表插入与删除运算
AIMing_byte的博客
02-19 1500
线性表，或称表，是一种非常灵便的结构，可以根据需要改变表的长度，也可以在表中任何位置对元素进行访问、插入或删除等操作。另外，还可以将多个表连接成一个表，或把一个表拆分成多个表。例如，26个英文字母的字母表：（A，B，C，......，Z）就是一个线性表，表中的数据元素是单个字母。在稍复杂的线性表中，一个数据元素可以包含若干个数据项。例如在学生基本信息表中，每个学生为一个数据元素，包括学号、姓名、性别、籍贯、专业等数据项。
数据结构：线性表
y_h_k_666的博客
03-28 2740
线性表是基本的数据结构之一，是一组元素的抽象。 线性表包含顺序表和链接表（简称链表），顺序表在C语言中一般使用数组去实现，链表使用结构体去实现。在Python中，list对象是采用顺序表实现的。 1. 顺序表 顺序表是将表中的元素顺序的存储在连续的内存里。 优点： 查询速度快，时间复杂度为O(1) 缺点： 插入元素速度慢，时间复杂度为O(n) 表中元素个数需要提前定义 2. 链表 链表：通过链接各个结点实现的技术就叫做链表。链表中的结点分为指针域和数据域，具体见下图。结点中的data用来存放数据
数据结构之线性表.rar
04-07
在本资料“数据结构之线性表.rar”中，我们将探讨如何使用C++实现线性表，并涵盖增、删、改、查等基本操作。 1. **线性表的概念**： 线性表的每个元素都有一个唯一的序号，称为位置或者索引。元素之间存在一对一的...
数据结构之线性表的实现.rar
07-27
在这个压缩包“数据结构之线性表的实现.rar”中，我们可以找到关于线性表实现的详细内容，特别是针对严蔚敏版数据结构的实现。 线性表的常见实现方式有两种：顺序表和链表。在顺序表中，元素在内存中是连续存储的，...
Java数据结构之线性表
08-31
Java中的线性表是一种基本的数据结构，它由一系列具有线性关系的元素构成，这些元素在逻辑上形成一个序列。线性表支持多种操作，包括获取元素、设置元素值、遍历、插入、删除、查找、替换和排序。线性表的存储方式有...
数据结构之线性表教程3.zip
01-02
在这个“数据结构之线性表教程3.zip”压缩包中，很可能是对线性表的深入讲解和实践应用的资源集合。 线性表是一种一维数组结构，其中的元素按照特定顺序排列。每个元素都有一个唯一的索引，通常从0或1开始。线性表...
用C#学习数据结构之线性表
12-22
　线性表是简单、基本、常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即：（1）除第一个位置的...
数据结构（初阶3.单链表）
2401_83968713的博客
07-14 654
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构day3
最新发布
qq_55245263的博客
07-18 135
【代码】数据结构day3。
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 209
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构初阶·排序算法(内排序)
2301_79697943的博客
07-18 375
目前常见的排序算法有9种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，计数排序，基数排序，桶排序。实际生活中排序的应用也是有限的，今天我们介绍其中7个，基数排序和桶排序不介绍。介绍常用的即可。顺带一嘴，本文里面所有的排序都是内排序，也就是在内存里面进行排序的，还有一种排序叫做外排序，即是在磁盘里面进行排序的，这种排序具有记忆性，外排序用到的就是归并排序，因为归并排序有一个特点就是空间复杂度为O(N)。好了正文开始。
数据结构：线性表与操作详解
"本资源主要针对数据结构中的线性表进行深入学习，涵盖了线性表的基本概念、特点以及常见的操作。首先，线性表被定义为有限序列的集合，每个元素都有明确的前后关系，其数据类型可以相同，也可以不同。通常假设元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值