最详细线性表知识点附加代码来了！

最新推荐文章于 2022-03-19 21:07:06 发布
最新推荐文章于 2022-03-19 21:07:06 发布
阅读量491 收藏 2
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnchouchou/article/details/120707684
版权

线性表

线性表的抽象数据类型：
InitList(*L):初始化操作，建立一个新的线性表
ListEmpty(L):判断线性表是否为空，如果为空返回True，否则返回False
ClearList(*L)：将线性表清空
GetElem(L, i, *e): 将线性表中第i个元素返回给e
LocateElem(L, e):在线性表中查找与给定e值相等的元素，如果查找成功，返回该元素在表中的序号表示成功，否则，返回0表示失败
ListInsert(*L, i, e):在线性表第i个位置插入新元素e
ListDelete(*L, i, *e):删除线性表L中第i个位置的元素e，并返回e其值
ListLength(L): 返回线性表L的长度
线性表的物理存储结构
分为线性存储结构和链式存储结构
1.线性表顺序存储的结构代码：
#define MAXSIZE 20;
typedef int ElemType;
typedef struct{
ElemType data[MAXSIZE];
int length;
}SqList;
线性表顺序存储的优缺点：
1.线性表的顺序存储结构，在读、写数据时，不管是哪个位置，时间复杂度都是O(1)，而插入或删除时时间复杂度都是O(n)
2.这说明，他比较适合元素个数比较稳定，不经常插入和删除元素，而更多的操作是存取数据

线性表的链式存储
线性表的链式存储结构的特点：除了存储其本身的信息外，还需要存储一个指示其直接后继的存储位置的信息
我们把存储 数据元素信息的域称之为数据域
把存储直接后继位置的域称之为指针域
这两部分信息组成数据元素成为存储映像，称为结点(Node)
在这里插入图片描述
线性表链式存储的结构代码(链表)：
#define int ElemType:其中可以把int替换为其他数据类型

typedef struct Node{
	ElemType data;  //数据域
	struct Node* Next;  //指针域
}Node;
typedef struct Node* LinkList;

// 实现单链表的基本功能
int GetElem(LinkList L, int i, ElemType *e) {
	int j = 1;
	LinkList p;
	j = i;
	p = L->Next;
	while (P && j < i)
	{
		p = p->Next;
		++j;
	}
	if (!p || j > i)
	{
		return ERROR;
	}
	*e = p->data;
	return OK;
}

// 单链表第i个数据插入结点
int ListInsert(LinkList L, int i, ElemType *e) {
	LinkList p, s;
	int j = 1;
	p = L;
	while (p && j < i) {  // 用于寻找第i个结点
		p = p->Next;
		j++;
	}
	if (!p || j > i) {
		return ERROR;
	}
	s = (Node*)malloc(sizeof(Node));
	s->data = e;
	s->Next = p->Next;
	p->Next = s;
	return OK;
}
// 删除单链表第i个数据结点
int ListDelete(LinkList L, int i, ElemType *e) {
	LinkList p, q;
	int j = 1;
	p = L;
	while (p && j < i) {
		p = p->Next;
		j++;
	}
	if (!p || j > i) {
		return ERROR;
	}
	q = p->Next;
	p ->Next = p->Next->Next;
	*e = q->data;
	delete(q);
	return OK;
}
// 头插法创建链表
void CreatListHead(LinkList L, int n)
{
	LinkList p;
	srand(time(0));  //随机初始化种子
	L = （LinkList)malloc(sizeof(Node));
	L->Next = NULL;
	for (int i = 0; i < n; i++)    // 插入n个结点
	{
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand() % 100 + 1;
		p->Next = L->Next;
		L->Next = p;
	}
}
// 尾插法创建链表
void CreatListTail(LinkList L, int n)
{
	LinkList p, r;
	srand(time(0));
	L = (LinkList)malloc(sizeof(Node));
	r = L;
	for (int i = 0; i < n; i++)
	{
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand() % 100 + 1;
		r->Next = p;
		r = p;
	}
	r->Next = NULL;
}
//单链表整表删除
int ClearList(LinkList L) {
	LinkList p, q;
	p = L->Next;
	while (p)
	{
		q = p->Next;
		free(p);
		p = q;
	}
	L->Next = NULL;
	return OK;
}

静态链表
我们对数组的第一个和最后一个元素做特殊处理他们的data不存放数据
数组的第一个元素，即下标为0的元素的cur存放备用链表的第一个结点的下标
数组的最后一个元素，即下标为MAXSIZE-1的cur则存放第一个有数值的元素的下标
我们通常把未使用的数组元素称为备用链表
注意：静态链表最后一个元素的游标为0
在这里插入图片描述
代码结构：
// 静态链表存储结构

#define MAXSIZE 1000
typedef struct{
	ElemType data;  // 数据
	int cur;    // 游标
}Component, StaticLinkList[MAXSIZE];

// 静态链表的初始化操作
int InitList(StatictLinkList space)
{
	int i;
	for(i = 0; i < MAXSIZE - 1; i++)
	{
		space[i].cur = i + 1;
	}
	space[MAXSIZE - 1].cur = 0;
	return 0;
}

// 静态链表的插入操作
int Malloc_SLL(StaticLinkList space)  // 获得空闲分量的下标
{
	int i = space[0].cur;
	if(space[0].cur)
	{
		space[0].cur = space[i].cur;
	}
	return i;   //待插入元素的下标位置i
}
int ListInsert(StaticLinkList L; int i; ElemType *e)
{
	int j, k, l;
	k = MAXSIZE - 1; // 数组的最后一个元素
	if(i < 1 || i > ListLength(L) + 1)
		return ERROR;
	j = Moalloc_SLL(L);
	if(j)   //  如果j不等于0
	{
		L[j].data = e;  //将要插入的元素赋值给新空出来的位置的data域
		for(l = 1; l <= i - 1; l++)
		{
			k = L[k].cur;
		}
		L[j].cur = L[k].cur;
		L[k].cur = j;
		return OK;
	}
	return ERROR;
}

// 静态链表的删除操作
int ListDelete(StaticLinkList L, int i)  // 删除第i个结点
{
	int j, k;
	if (i < 1 || i > ListLength(L))
		return ERROR;
	k = MAXSIZE - 1;
	for (j = 1; j <= i - 1; j++)
	{
		k = L[k].cur;
	}
	j = L[k].cur;
	L[k].c    
	Free_SLL(L, j);
	return OK;
}

//将下标为k的空间结点回收到备用链表
void Free_SLL(StaticLinkList space, int k)
{
	space[k].cur = space[0].cur;
	space[0].cur = k;
}

// 返回L中数据元素的个数
int ListLength(StaticLinkList L)
{
	int j = 0;  // 长度累加
	int i = L[MAXSIZE - 1].cur;
	while (i) {
		i = L[i].cur;
		j++;
	}
	return j;
}

静态链表优缺点总结
优点：
在插入和删除操作时，只需要修改下标，不需要移动元素
从而改进了顺序存储结构中的插入和删除操作需要移动大量元素的缺点
缺点：
1.没有解决连续存储分配(数组)带来的表长难以确定的问题
2.失去了顺序存储结构村级存储的特性
总结：总的来说静态链表是为了给没有指针的编程语言设计的一种实现单链表功能的方法
有了动态链表基本就不用静态链表了，不过我们要学习这个静态链表的算法思想

快慢指针：设置两个指针search，mid都是指向单链表的头节点，其中search的移动速度是mid的二倍，当*search指向末尾结点，*mid正好到中间
代码实现：

int GetMidNode(LinkList L, ElemType *e)
{
	LinkList search, mid;
	mid = search = L;
	while(search->Next != NULL)
	{
		if(search->Next->Next != NULL)
		{
			search = search->Next->Next;
			mid = mid->Next;
		}
		else
			search = search->Next;
	}
	*e = mid->data;
	return OK;
}

循环链表
代码结构：


```cpp
 #include<iostream>
 using namespace std;
 //链表存储结构的定义
 typedef struct CLinkList
 {
	int data;
	struct CLinkList *next;
}node;
//初始化循环链表
void ds_init(node **pNode)
{
    int item;
	node *temp;
	node *target;
	printf("输入节点的值，输入0完成初始化")；
	while(1){
		scanf("%d", &item);
		ffflush(stdin);
		if(item == 0)
		{
			return ;
		}
		if(*pNode) == NULL
		{
			//循环链表只有一个结点
		}
	}
}

// 返回节点所在的位置
int ds_search(node *pNode, int elem)
{
	node *target;
	int i = 1;
    for(target = pNode; target->data != elem && target->next != pNode; ++i)
    	target = target->next;
    if(target->next == pNode)
    	return 0;
    else
    	return i;
}


**约瑟夫问题**
用循环链表模拟约瑟夫问题
//n个人周围报数，报m出列，最后剩下几号？

```cpp
#include<iostream>
#include<string>
using namespace std;

typedef struct node {
	int data;
	node *next;
}node;

node *create(int n) {
	node *p = NULL, *head;
	head = (node*)malloc(sizeof(node));
	p = head;
	node *s = NULL;
	int i = 1;
	if (n != 0) {
		while (i <= n) {
			s = (node*)malloc(sizeof(node));
			s->data = i++;
			p->next = s;
			p = s;
		}
		s->next = head->next;  // 让s(最后一个结点)的下一个指向头节点的下一个也就是第一个结点
	}
	free(head);
	return s->next;  // 返回第一个结点
}


int main()
{
	int n = 41;
	int m = 3;
	int i;
	node *p = create(n);
	node *temp;
	m %= n;
	while (p != p->next)   //  当p=p->next时，代表循环链表为空，自己指向自己
	{
		for (i = 1; i < m - 1; i++)
			p = p->next;
		cout << p->next->data << "->";
		temp = p->next;
		p->next = temp->next;
		free(temp);
		p = p->next;
	}
	cout << p->data << endl;
	return 0;
}

循环链表的特点：
访问第一个结点时间复杂度O(1)，访问最后一个结点O(n)
用一个尾指针指向终端结点，就可以使访问第一个结点和最后一个节点的时间复杂度都为O(1)

一道例题：实现将两个线性表连接成一个线性表
在这里插入图片描述

LinkList Connect(LinkList A, LinkList B)
{
	LinkList p = A->next;   //保存A表的头节点位置
	A->next = S->next->next;   // B表的开始结点连接到A的表尾
	free(B->next);   //释放B表的头节点，
	S->next = p;
	return B;	  //返回新循环链表的尾指针
}

判断单链表中是否有环
方法一：使用 p，q两个指针，p每次向前走一步，但q每次都是从头开始走，对于每个结点看p走的步数和q是否一样
方法二：使用快慢指针，p每次向前走一步，q每次向前走两步，若在某个时候p == q，则存在环

完整代码：

#include<iostream>
#include<cstring>
#include <stdlib.h> 
#include <time.h>
using namespace std;
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

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

// 初始化带头结点的空链表
Status InitList(LinkList *L) {
	*L = (LinkList)malloc(sizeof(Node));
	if (!(*L))
		return ERROR;
	(*L)->next = NULL;
	return OK;
}

//初始条件，顺序线性表L已经存在，操作结果，返回L中数据元素个数
int	ListLength(LinkList L) {
	int i = 0;
	LinkList p = L->next;
	while (p) {
		i++;
		p = p->next;
	}
	return i;
}

// 随机产生n个元素的值，建立带表头结点的单链线性表L----------头插法
void CreateListHead(LinkList *L, int n) {
	LinkList p;
	int i;
	//srand(time(0));  // 初始化随机数种子
	srand((unsigned int)time(NULL));
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
	for (i = 0; i < n; i++) {
		p = (Node*)malloc(sizeof(Node));
		p->data = rand() % 100 + 1;
		p->next = (*L)->next;
		(*L)->next = p;
	}
}

// 尾插法创建链表
void CreateListTail(LinkList *L, int n)
{
	LinkList p, r;
	//srand(time(0));
	srand((unsigned int)time(NULL));
	*L = (LinkList)malloc(sizeof(Node));
	r = *L;
	for (int i = 0; i < n; i++)
	{
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand() % 100 + 1;
		r->next = p;
		r = p;
	}
	r->next = (*L)->next->next	;
}

//比较步数的办法
int HasLoop1(LinkList L) {
	LinkList cur1 = L;
	int pos1 = 0;
	while (cur1) {				// cur1结点存在
		LinkList cur2 = L;
		int pos2 = 0;			// cur2的步数
		while (cur2) {			//cur2的结点部位孔
			if (cur2 == cur1)		//当cur1和cur2达到相同的结点时
			{
				if (pos1 == pos2)     //如果走过的步数一样
					break;            //说明没有环
				else {
					cout << "环的位置在第" << pos2 << "个结点处" << endl;
					return 1;          //有环并返回1
				}
			}
			cur2 = cur2->next;            //如果没发现环，继续下一个结点
			pos2++;                   // cur2步数自增
		}
		cur1 = cur1->next;			//cur1继续向后一个结点
		pos1++;						//cur1步数自增
	}
	return 0;
}

//利用快慢指针的方法
int HasLoop2(LinkList L) {
	int step1 = 1;
	int step2 = 2;
	LinkList p = L;
	LinkList q = L;
	while (p != NULL && q != NULL && q->next != NULL) {
		p = p->next;
		if (q->next != NULL)
			q = q->next->next;
		cout << "p:" << p->data << "," << "q:" << p->data << endl;
		if (p == q) {
			return 1;
		}
	}
	return 0;
}

int main() {
	LinkList L;
	Status i;
	char opp = NULL;
	i = InitList(&L);
	cout << "初始化L后，ListLength(L) = " << ListLength(L) << endl;
	cout << endl;
	cout << "1.创建有环链表<尾插法>" << endl << "2.创建无环链表<头插法>" << endl << "3.判断链表是否有环" << endl << "0.退出" << endl;
	cout << endl;
	while (opp != '0') {
		cin >> opp;
		switch (opp)
		{
		case '1':
			CreateListTail(&L, 20);
			cout << "成功创建有环L<尾插法>" << endl << endl;
			break;
		case '2':
			CreateListHead(&L, 20);
			cout << "成功创建无环L<头插法>" << endl << endl;
			break;
		case '3':
			cout << "方法一" << endl;
			if (HasLoop1(L))
				cout << "结论，链表有环" << endl << endl << endl;
			else
				cout << "结论，链表无环" << endl << endl << endl;
			cout << "方法二" << endl;
			if (HasLoop2(L))
				cout << "结论，链表有环" << endl << endl << endl;
			else
				cout << "结论，链表无环" << endl << endl << endl;
			break;
		case '0':
			exit(0);
		}
	}
	return 0;
}

魔术师发牌问题
核心代码：

void Magician(LinkList head){
	LinkList p;
	int j;
	int Countnumber = 2;
	p = head;
	p->data = 1;
	while(1){
		for(j = 0; j < Countnumber; j++){
			p = p->next;
			if(p->data != 0)
			{
				p->next;
				j--;
			}
		}
		if(p->data == 0){
			p->data = Countnumber;
			Countnumber++;
			if(Countnumber == 14)
				break;
		}
	}
}

拉丁方阵问题
拉丁方阵是一个n*n方阵，方阵中恰有n种不同的元素，每种元素恰有n个，并且每种元素在一行或一列中恰好只出现一次
例如：
在这里插入图片描述

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

typedef struct Node
{
    int data;
    struct Node* pNext;
}Node;

typedef struct Node* LinkList;

//构造一个带有N个节点的循环链表
Node* CreateList(Node* L, int n)
{
    Node *pCur, *pTemp;
    L = (LinkList)malloc(sizeof(Node));
    L->pNext = nullptr;
    pCur = L;//当前节点指向表头
    for (int i = 1; i <= n;i++)
    {
        pTemp = (LinkList)malloc(sizeof(Node));
        pTemp->data = i;
        pTemp->pNext = pCur->pNext;
        pCur->pNext = pTemp;
        pCur = pTemp;  //在尾部插入
    }
    pCur->pNext = L->pNext; //循环结构
    return L->pNext;
}

//实现拉丁方阵的输出
void print(struct Node *La, int n)
{
    int i, j;
    struct Node *p, *q;
    p = La;
    for (i = 1; i <= n; i++)
    {
        q = p;
        for (j = 1; j <= n; j++)
        {
            printf("%3d", q->data);
            q = q->pNext;
        }
        printf("\n");
        p = p->pNext;
    }
}

int main(int argc, char* argv[])
{
    int m;
    struct Node *L=nullptr, *t=nullptr;
    //while (1)
    {
        printf("****************************************************\n");
        printf("*****          ESC键：    退出程序             *****\n");
        printf("*****                                          *****\n");
        printf("*****          其他任意键：打印df拉丁方阵        *****\n");
        printf("****************************************************\n");
        /*    if (_getch() == 27)
                break;
                else*/
        {
            printf("\n请输入您要打印的拉丁方阵规模（要打印的行数）：\n\n");
            scanf("%d", &m);
            L = CreateList(L, m);
            printf("\n您输入的规模为%d，打印的方阵如下：\n\n", m);
            print(L, m);
            printf("\n请输入任意键继续：\n");
            _getch();
            system("cls");
        }
    }
    return 0;
}

双向链表
双向链表的结点结构

  typedef struct DualNode
  {
	ElemType data;
	struct DualNode *prior;   //前驱节点
	struct DualNode *next;   //后继节点
}DualNode, *DuLinkList;

在这里插入图片描述
既然单链表可以有循环链表，那么双向链表也可以有循环链表
在这里插入图片描述
双向链表的插入操作：
在这里插入图片描述
代码结构：

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

双向链表的删除操作：
在这里插入图片描述
代码结构：

p->prior->next = p->next;
p->next->prior = 	p->prior;
free(p);

双向循环链表实践
要求实现用户输入一个数使26个字母的排列发生变化，例如输入3，输出结果：
DEFGHILJKLMNOPQRSTUVWXYZABC
例如输入3，输出结果为：
XYZABCDEFGHILJKLMNOPQRSTUVW

全部代码：

#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
typedef char ElemType;
typedef int Status;
typedef struct DualNode {
	ElemType data;
	DualNode *prior;
	DualNode *next;
}*DuLinkList;

Status  InitList(DuLinkList *L) {
	DualNode *p, *q;
	*L = (DuLinkList)malloc(sizeof(DualNode));
	if (!(*L)) {
		return ERROR;
	}
	(*L)->next = (*L)->prior = NULL;
	p = (*L);
	for (int i = 0; i < 26; i++) {
		q = (DuLinkList)malloc(sizeof(DualNode));
		if (!q)
			return ERROR;
		q->data = 'A' +i;
		q->prior = p;
		q->next = p->next;
		p->next = q;
		p = q;
	}
	(*L)->next->prior = p; 
	p->next = (*L)->next;
	return OK;
}

void cussion(DuLinkList *L, int n) {
	if (n > 0) {
		do {
			(*L) = (*L)->next;
		} while (--n);
	}
	if (n < 0) {
		do {
			(*L) = (*L)->next;
		} while (++n);
	}
}

int main() {
	DuLinkList L;
	int i, n;
	InitList(&L);
	cout << "请输入一个数：";
	cin >> n;
	cout << endl;
	cussion(&L, n);
	for (int i = 0; i < 26; i++) {
		L = L->next;
		cout << L->data;
	}
	cout << endl;
	return 0;
}
陈闹闹爱闹
关注
数据结构知识点总结详细无题目1.doc
11-30
数据结构知识点总结详细无...数据结构知识点总结详细无题目1.doc为计算机科学和信息技术专业学生提供了一个全面的数据结构知识点总结，涵盖了基本概念、算法设计、线性表、栈与队列、算法设计和数据结构的应用等方面。
【C语言-＞数据结构】线性表
debug...
04-30 1563
ADT 抽象数据类型名 Data 数据元素之间逻辑关系的定义 Operation 操作 endADT ADT 线性表（List） Data 线性表的数据对象集合为 { a1, a2, a3,..., an }，每个元素类型为 DataType 。其中， 除 a1 外每个元素都有直接前驱元素， 除 an 外每个元素都有直接后继元素。 Operation 初始化线性表 L InitList(*L);//初始...
【数据结构】线性表的基本操作（C语言）
jxyyyy的博客
11-01 539
//Operation /* list_init(L); //初始化线性表 list_empty(L); //判断线性表是否为空 list_get_elem(L,i); //获取第i个位置的数据 list_search_e(L,e); //查找与数据e相等的元素 list_insert_e(L,i,e);//在第i个位置插入元素 list_delete_location(L,i);//删除第i个位置的元素 list_delete_e(L,e
线性表
m0_45699847的博客
07-12 4118
一、线性表基本操作如下： 1、线性表的置空操作clear()：将一个已经存在的线性表置为空表。 2、线性表判空操作isEmpty()：判断线性表是否为空，若为空，则返回true；否则，返回为false。 3、求线性表的长度操作length()：求线性表中的数据元素的个数并返回其值。 4、取元素操作get(i)：读取并返回线性表中的第i个数据元素的值。其中i的取值范围为0≤i≤length()-1。 5、插入操作insert(i,x)：在线性表的第i个数据元素之前插入一个值为x的数据元素。其中i的取值范围为0
【数据结构】第二章 线性表的基本知识及代码实现（1）
weixin_64682807的博客
03-19 2290
一、线性表的定义和特点 1、定义：由n(n>=0)个数据元素（结点）组成的有序序列 2、逻辑特征：同一线性表中的元素必须具有相同的特性，数据元素之间的关系为线性。线性表是一种典型的线性结构。 二、线性表的基本定义 1、抽象数据类型的线性表定义如下： ADT List{ 数据对象：D={ai | ai属于Elemset，(i=1,2,....n)} 数据关系：R={<ai-1,ai>,ai-1和ai属于D} 数据操作：InitList（&L）等 }ADT List
【数据结构与算法】线性表
Jeloys的博客
01-11 835
此文为FishC大佬《数据结构与算法》线性表的笔记整理。 线性表定义 线性表（List）：由零个或多个数据元素组成的有限序列。 这里需要强调几个关键的地方： 首先，它是一个序列，也就是说元素之间是有顺序的 若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他元素有且仅有一个前驱和后继。 线性表强调是有限的。  数据类型 数据类型：是指一组性质相同的值的集合及定义在此集合上的一...
深入剖析编程中线性表与链表的核心知识点
最新发布
10-10
本文详细阐述了编程中最常用的线性表数据结构及其重要的变种—链表的相关理论与实现技术，包括基本概念、逻辑结构、物理结构、初始化、链式存储的特点及其实际应用场景等多个方面内容。此外，通过详细的步骤展示和...
线性表（c语言代码）
03-14
线性表是计算机科学中最基本的数据结构之一，它是由n个相同类型的元素组成的一个有限序列。线性表可以通过顺序存储或链式存储两种方式来实现。本文将通过分析一段C语言代码来深入理解如何使用顺序存储方式来实现...
线性表的实现全部代码
07-14
### 线性表的实现知识点详解 #### 一、线性表的概述与存储方式 线性表是计算机科学中最基本的一种数据结构之一，它由相同类型的数据元素构成，这些元素之间存在着一种先后关系。根据存储方式的不同，线性表可以分为...
c++实现线性表完整代码
11-07
根据给定的信息，我们可以总结出以下关于C++中线性表实现的相关知识点： ### C++实现线性表 #### 1. 引言 线性表是数据结构中最基本的一种线性表结构，它是由一组相同类型的数据元素构成的序列。在C++中，可以通过...
线性表的实现_代码(初始化、判断是否为空表、求表长、输出表、插入、删除、查找、修改、清空表、释放表空间、退出
10-16
线性表的实现_代码(初始化、判断是否为空表、求表长、输出表、插入、删除、查找、修改、清空表、释放表空间、退出。
2、 掌握线性表的基本操作：初始化，插入，删除，查找，判空，求线性表长度等运算在顺序存储结构和链式存储结构上的实现
10-29
一、 实验目的 1、 掌握线性表的结构特点。 2、 掌握线性表的基本操作：初始化，插入，删除，查找，判空，求线性表长度等运算在顺序存储结构和链式存储结构上的实现。 3、 通过本章实验帮助学生加深对C语言的使用（特别是函数的参数调用、指针类型的应用）。 二、 实验要求 1、 选择何时的存储方式实现线性表。其中，必须实现的线性表基本操作为：InitList、 ClearList、ListEmpty、ListLength、GetElem、PriorElem、ListInsert、ListDelete这8个基本操作，其余的可以选作。 2、 所写源代码编程风格良好，有详细注释。 3、 程序运行界面良好，使用菜单实现每个基本操作。 4、 实验报告书写规范。
【数据结构和算法】Day 7
RiRiRicardo的博客
08-26 351
线性表的抽象数据类型定义： ADT 线性表(List) Data 线性表的数据对象集合为{a1,a2,...,an}，每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。 Operation InitList(*L)：初始化操作，建立一个空的线性
数据结构的判空操作
weiker12的专栏
08-07 4776
1.顺序表的判空： bool ListEmpty(SqList *L) //判线性表是否为空表 { return(L -> length == 0); //长度为0即为空表 } 2.单链表的判空： bool ListEmpty(LinkList *L) //判线性表是否为空表 { return(L->next == NULL); //链表的指针指向下一个为空为空表 } 3.
数据结构与算法（二）——线性表
站在远方看童年的博客
12-13 227
线性表，栈-顺序表、链表 1、Collection接口——（译：聚集） Collections API位于java. util 包中。集合( collection)的概念在Collection接口中得 到抽象，它存储一组类型相同的对象。图3-5显示该接口一些最重要的部分(但一些方法未 被显示)。 在collection接口中的许多方法所做的工作由它们的英文名称可以看出，因此size返 回集合中的项...
数据结构与算法——线性表(1)
你说小白白不白的博客
07-19 578
一、线性表介绍 线性表是由零个或多个数据元素组成的有限序列，线性表的特征是在一个序列中，除了头尾元素，每个元素都有且只有一个直接前驱，有且只有一个直接后继，而序列头元素没有直接前驱，序列尾元素没有直接后继。 二、线性表抽象数据类型定义 ADT 线性表（List） Data Operation InitList(*L): 初始化操作，建立一个空的线性表L。 ListEmpty(L): 判断线性表是否为空表，若线性表为空，...
【数据结构】顺序表定义和基本操作
Z_sea的博客
12-11 4538
线性表主要两种结构： 顺序存储  和  链式存储： 这次写的顺序表，指的是线性表的顺序存储模式； 定义类型： #define ListInitSize 100 #define ListIncrement 10 #define LElemType int typedef struct Sqlist{ LElemType *base; int length; int...
数据结构 | C++ | 线性表的基本操作
IronBull_Zhang的博客
03-23 776
重写一遍代码,温故而知新.结点类型全部是"训练笔记"类,为以后做准备. 数据套格式函数void MakeData(ListNode data),应用在main()里而非.h头文件里. 在头文件里,数据以节点结构体ListNode 的形式在各个函数中传递、流通. 在main()调用时套个壳子,显示出来. 1.顺序表的头文件: //结点类 struct ListNod...
数据结构期末复习 第二章线性表知识点加代码
09-28
第二章线性表通常涉及计算机科学的基础数据结构，它是数据结构中最基本的一种，包括数组、链表等。下面是几个重要的线性表知识点： 1. **数组（Array）**： - 定义：固定大小的一组有序元素集合，通过索引来访问。 - 知识点：动态数组（如ArrayList），静态数组（如一维字符数组char[]），插入和删除操作的效率（一般情况下，插入/删除在数组头部快，尾部慢）。 ```java List<Integer> array = new ArrayList<>(); array.add(1); // 插入元素 array.remove(0); // 删除第一个元素 ``` 2. **单链表（Linked List）**： - 定义：由节点组成，每个节点包含数据和指向下一个节点的指针。 - 知识点：顺序查找速度快，插入和删除操作可以在常数时间内完成（对于头节点）；但是访问任意位置需要从头开始遍历。 ```java ListNode linkedList = new ListNode(1); linkedList.next = new ListNode(2); // 插入节点 LinkedListNode current = linkedList; while (current.next != null) { current = current.next; // 遍历列表 } current.next = new ListNode(3); // 在特定位置插入 ``` 3. **双向链表（Double Linked List）**： - 每个节点有两个指针，分别指向前一个和后一个节点。 - 插入和删除操作比单链表更方便，因为可以双向移动。 4. **栈（Stack）和队列（Queue）**： - 栈是一种特殊类型的线性表，只允许在一端进行插入和删除（后进先出LIFO）。 - 队列则是另一端进行插入（先进先出FIFO）。 ```java Stack<Integer> stack = new Stack<>(); stack.push(1); // 入栈 int topElement = stack.pop(); // 出栈 Queue<Integer> queue = new LinkedList<>(); queue.offer(1); // 入队 int frontElement = queue.poll(); // 出队 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈闹闹爱闹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值