数据结构-线性表

系列文章目录

第一章 线性表
第二章 栈与队列
第三章 串
第四章 数组与广义表

---

---

前言

线性表（Linear_list）是最常用且最简单的一种数据结构，简言之，一个线性表是n个数据元素的有限序列。
线性结构的特点：在数据元素的非空集中，
①存在唯一的一个首元素，（第一个）
②存在唯一的一个末元素，（最后一个）
③除首元素外每个元素均只有一个直接前驱，
④除末元素外每个元素均只有一个直接后继。

---

一、线性表

1.存储

   静态顺序存储结构：

一维数组。 注意：第i个元素的下标是i-1

   动态顺序存储结构：

#define LIST_INIT_SIZE 100
#define LIST_INCREMENT 10   // 存储空间的分配增量
typedef struct
 { ElemType *elem;  //存储空间基址
   int length;      //当前表长
   int listsize;    //当前已分配的存储空间
 }SqList;

动态分配：一旦因插入元素而空间不足时，可进行分配，即为顺序表增加一个大小为存储LIST_INCREMENT个数据元素的空间

2.初始化内存空间

void sqllist_init(SqList* L) {
	L->elem = (int*)malloc(LIST_INIT_SIZE * sizeof(int));
	L->length = 0;
	L->listsize = LIST_INIT_SIZE;
}

3.顺序表的创建

void sqlist_creat(SqList* L) {
	printf("请输入%d个整数:\n", LIST_INIT_SIZE); //LIST_INIT_SIZE为常量，指明顺序表存储的个数
	for (int i = 0; i < L->listsize; i++)
	{
		scanf("%d",&L->elem[i]);
	}
	L->length= L->listsize;
}

4.顺序表的遍历

void sqlist_print(SqList* L) {
	printf("您创建的线性表如下:\n");
	for (int i = 0; i < L->listsize; i++)
	{
		printf("%4d", L->elem[i]);
	}
	printf("\n");
}

5.顺序表的插入

 i为插入的位置空位，i后面的元素整体往后移一位，在将插入的元素插入。然后长度加1，L->length++；

int sqlist_insert(SqList* L,int i,ElemType e) {
	int * newbase;
	if(i<1||i>L-length+1){
		return 0;
	}
	if(L->length >= L->listsize){
		newbase =(int *)realloc(L->elem,(L->listsize +LIST_INCREMENT) *sizeof(size));
		L->elem =newbase;
		L->listsize =L->listsize +LIST_INCREMENT;
	}
	q=&(L->elem[i-1]); //q为插入位置
	for(p=&(L->elem[L->length-1]);p>=q;--p){
		*(p+1) = *p;     //插入位置以及之后的元素右移
	}
	*q = element; //插入元素
	L->length++; //表长增1
	return 1;
}

6.顺序表的删除

/*顺序表的删除操作 （删除L中第i个位置的元素并引用变量e返回）*/
int sqlist_delete(SqList* L,int i,ElemType e) {
	if(i<1||i>L-length+1){
		return 0;
	}
	p=&(L->elem[i-1]); //p为删除位置
	e = *p;			  //被删除元素的值赋给e
	q = L->elem + s->length -1; //表尾元素的位置
	for(p++;p<=q;p++){
		*(p-1) = *p;     //被删除位置之后的元素左移
	}
	L->length++; //表长减1
	return 1;
}

7.顺序表的合并

Sqlist * Sqlist_merge(Sqlist *La,Sqlist *Lb){
	SqList* Lc = (SqList*)malloc(sizeof(SqList));
	int* pa, * pb, * pc;
	pa = La->elem;
	pb = Lb->elem;
	Lc->elem =(int *)malloc ((La->length+Lb->length) * sizeof(int));
	Lc->listsize = La->listsize+ Lb->listsize;
	pc = Lc->elem;
	while (La->length && Lb->length)
	{
		if (*pa < *pb) {
			*pc = *pa;
			pc++;pa++;
			La->length--;
		}else if (*pa > *pb) {
			*pc = *pb;
			pc++;pb++;
			Lb->length--;
		}else{
			*pc = *pb;
			pc++;pb++;pa++;
			La->length--;
			Lb->length--;
		}
	}
	while (La->length)
	{
		*pc = *pa;
		pc++;pa++;
		La->length--;
	}
	while (Lb->length)
	{
		*pc = *pb;
		pc++;pb++;
		Lb->length--;
	}
	Lc->length = La->length + Lb->length;
	return Lc;
}

---

二、链表

  线性表的链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因而，为了表示每个数据元素与其直接后继之间的逻辑关系，每个元素除存储自身信息外，还需存储其后继元素的信息。
结点：包含两个域，数据域和指针域

链表、线性链表、头指针

1.线性链表的存储结构（动态）

#define ElemType  int
#define Create_Int  5
// 或者
//typedef int ElementType;
typedef struct LNode
{
	ElemType data;//数据域
	struct LNode* next; //指针域
}LNODE,*LinkList;

2.线性链表的初始化

void init_Linklist(LNODE* p) {
	p=(LNODE *)malloc(sizeof(LNODE));
	p->next = NULL;
}

3.线性链表的建立

void create_Linklist(LNODE* p, int n) {
	int data;
	while (n)
	{
		scanf("%d", &data);
		LNODE* q = (LNODE*)malloc(sizeof(LNODE));
		q->data = data;
		q->next=p->next; //尾插法
		p->next = q;
		p = p->next;
		n--;
	}
	free(q);
}

4.线性链表的遍历

//带特殊头节点
void traverse_Linklist(LNODE* p) {
	LNODE* L;
	L = p->next;
	while (L)
	{
		printf("%d\n", L->data);
		L = L->next;
	}
}

5.线性链表的查找

LNODE* search_Linklist(LNODE* p,int position) {
	LNODE* L; L = p;
	while (L&& position)
	{
		position--;
		L = L->next;
	}
	return L; //返回检索到的节点
}

6.线性链表的插入

 (1)在指定位置position之前插入

void InserFront_Linklist(LNODE* p, int position) {
	LNODE* q, L;
	L = search_Linklist(p, position-1); //查找前一个节点
	q = (LNODE*)malloc(sizeof(LNODE));
	printf("请输入数据:");
	scanf("%d", &q->data);
	q->next = L->next;
	L->next = q;
}

 (2)在指定位置position之后插入

void InserRear_Linklist(LNODE* L, int position) {
	LNODE* q, p;
	p = search_Linklist(p, position); //查找前一个节点
	q = (LNODE*)malloc(sizeof(LNODE));
	printf("请输入数据:");
	scanf("%d", &q->data);
	q->next = p->next;
	p->next = q;
}

7.线性链表的逆序(有特殊头节点)

LNODE* reverse_Linklist(LNODE* head) {
	LNODE* NewHead,*p;
	NewHead = (LNODE*)malloc(sizeof(LNODE));
	NewHead->next = NULL;
	while (head->next!=NULL)
	{
		p = head -> next;
		head -> next = p -> next;
		p->next = NewHead->next;
		NewHead->next = p;
	}
	free(head);
	return NewHead; 
}

8.两个有序链表的合并

LNODE* Linklist_merge(LNODE* La,LNODE* Lb){
	LNODE* pa,*pb,*pc,Lc;
	pc=Lc = (LNODE*)malloc(sizeof(LNODE));
	pa = La->next;
	pb = Lb->next;
	while (pa&&pb)
	{
		if (pa->data < pb->data) {
			pc->next = pa;
			pc= pa;
			pa=pa->next;
		}else {
			pc->next = pb;
			pc= pb;
			pb=pb->next;
		}
	}
	while (pa)
	{
		pc->next = pa;
		pc= pa;
		pa=pa->next;
	}
	while (Lb->length)
	{
		pc->next = pb;
		pc= pb;
		pb=pb->next;
	}
	return Lc;
}

9.顺序表和链表的优缺点

(1)顺序表

优点

1. 顺序表的内存空间连续。
2. 尾插、尾删效率较高，时间复杂度是O(1)。
3. 支持随机访问，可以高效的按下标进行操作，时间复杂度是O(1)。

缺点

1. 在顺序表中间插入或删除元素时都涉及到元素的移动，效率较低，时间复杂度为O(N)。
2. 顺序表长度固定，有时需要扩容。

(2)链表

优点

1. 链表的内存空间不连续。
2. 如果知道要处理节点的前一个位置，则进行插入和删除的复杂度为O(1);
3. 如果不知道要处理节点的前一个位置，则进行插入和删除的复杂度为O(N)。
4. 头插、头删的效率高，时间复杂度是O(1)。
5. 没有空间限制，不会溢出，可以存储很多元素。

缺点

1. 链表不支持随机访问，查找元素效率低，需要遍历节点，时间复杂度是O(n)。

(3)总结

• 当线性表的长度变化不大、易于确定其大小时，采用顺序表作为存储结构。
• 若线性表主要操作是查找。很少进行插入或删除操作时，采用顺序表作为存储结构。
• 对于频繁进行插入和删除的线性表，则应该使用链表作为存储结构。

---

三、循环链表

1.循环链表的存储

struct node
{ int code;
  struct node *next;
};
typedef struct node NODE;

---

四、双向链表

为克服单链表的单向性的缺点，可利用双向链表。
双向循环链表中存在两个环。

                 非空表 　　　　　 　　　             空表

1.双向链表的存储

typedef struct DuLNode
{ ElemType data;
  struct DuLNode *pre, *next;
}DuLinkNode, *DuLinkList;

2.双向链表的插入

 (1)在p之后插入结点q

q->next =p->next;
q->pre = p;
p->next=q;
q->next->pre = q

 (2)在p之前插入结点q

q->pre =p->pre
p->pre->next =q;
p->pre=q;
q->next=p

3.双向链表的删除

 (1)删除*p

(p->pre)->next=p->next;
(p->next)->pre=p->pre;
free§;

 (2)删除*p的前驱结点

思考

 (2)删除*p的后继结点

思考

总结

本文只是数据结构的基础，单纯为了期末考试做的笔记，后续还会更新其它章节的内容