数据结构与算法-概述、线性结构：线性表

1 数据结构与算法概述

1.1 基本术语

1. 数据：能输入到计算机中被计算机处理的符号的总称。
2. 数据元素：是数据的基本单位，也称作元素、记录，是用一个结构体完整的表示一个对象。
3. 数据项：多个不同的数据项构成一个数据元素。
4. 数据对象：是数据元素的集合，无论这个集合是有限的、无限的，还是复合的，只要其中数据对象的性质相同，就可以称之为一个数据对象。

1.2 数据结构的定义

数据结构指的是数据元素之间又特定关系的集合

1.3 数据结构的分类

1.4 其他补充内容

教材内容概述

数据结构在计算机学科中的地位

1.5 抽象数据类型

抽象数据类型，比如顺序表、链表等，主要包括：数据对象、数据对象的关系和对数据对象的操作。

1.6 算法分析

时间复杂度、空间复杂度
时间复杂度就是算法执行的次数T(n)和问题规模n的关系。常见的时间复杂度按数量级递增排序为：常数阶O(1)、对数阶O(log2n)、线性阶O(n)、线性对数阶O(n log2n)、平方阶O(n2)、立方阶O(n3)…

线性表

定义：
同一线性表中的元素为同一数据对象，相邻数据元素之间存在着序偶关系。

顺序表

定义
顺序表，它是线性表的顺序表示。意思是用一组地址连续的存储单元一次存储线性表的数据元素，这种表示也称作线性表的顺序存储结构。顺序表的数据元素逻辑结构相邻，存储结构也相邻。

顺序表的存储结构

typedef struct {
	TypeElem* elem;//定义一个指针，该指针将在初始化函数中指向一个存储空间。
	int length;//线性表的长度
}SqList;

顺序表的初始化

int InitList(SqList& L) {
	L.elem = new TypeElem[MAXSIZE];//开辟一个大小为MAXSIZE，存储的数据类型为TypeElem的空间。并将该空间的首地址赋值给elem。
	if (!L.elem) return -2;//如果开辟的空间地址不存在，那么返回-2，表示内存溢出。
	L.length = 0;
	return 1;
}

顺序表的基本操作

int GetElem(SqList L, int i, TypeElem& e) {// i 表示的是位置，取值范围为1-MAXSIZE
	if (L.length == 0) return -1;
	if (i<1 || i>MAXSIZE) return -1;
	e = L.elem[i-1];
	return 1;
}

int AssignList(SqList& L, int length, int a[]) {
	for (int i = 0; i < length; i++)
		L.elem[i] = a[i];
	L.length = length;
	return 1;
}

int LocateElem(SqList L, TypeElem e) {
	if (L.length == 0) return -1;
	for (int i = 0; i < L.length; i++)
		if (L.elem[i] == e) return i + 1;
	return 1;
}

int InsertList(SqList& L, int i, TypeElem e) {
	if (i<1 || i>MAXSIZE) return -1;
	if (L.length == MAXSIZE) return -1;
	for (int j = L.length-1; j >= i-1; j--)
		L.elem[j + 1] = L.elem[j];
	L.elem[i-1] = e;
	++L.length;
	return 1;
}

链表

定义
链表是线性表的链式存储结构。链表是用一组任意的存储单元存储线性表的数据元素，存储的元素在逻辑结构上是连续的，但是在存储结构上可能是不连续的。链表包括两个域：数据域和指针域。

单链表的示意图

分类
单链表、循环链表、双向链表等等。
带头结点和不带头结点的链表。一般都是带头结点的链表。

单链表的存储结构

typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, *LinkList;         //实际上，LNode就是一个结构体（结点），LinkList就是指向结构体（结点）的指针。

• 单链表由表头指针唯一确定。

单链表的初始化

int InitList(LinkList &L) {
	L = new LNode;//开辟一个存放头结点的空间，并将这个头结点的地址赋值给L，L就是头指针。
	L->next = NULL;
	return 1;
}

单链表的基本操作

int ListEmpty(LinkList L) {
	if (L->next)//非空
		return 0;
	return 1;
}

int DestroyList(LinkList& L) {
	LinkList p;
	while (L) {
		p = L;
		L = p->next;
		delete p;
	}
	return 1;
}

int ClearList(LinkList& L) {
	LinkList p=L->next;
	LinkList q;
	while (p) {
		q = p;
		q = p->next;
		delete p;
	}
	L->next = NULL;
	return 1;
}

int ListLength(LinkList L) {
	int i=0;
	LinkList p=L->next;
	while (p) {
		i++;
		p = p->next;
	}
	return i;
}

int GetElem(LinkList L, int i, ElemType& e) {
	LinkList p = L->next;
	int j = 1;
	while (p && j < i) {
		p = p->next;
		j++;
	}
	if (!p || j > i) return -1; //第i个元素不存在，或者i的值不合法i>n，或者i<=0.
	e = p->data;
	return 1;
}

LNode* Locate(LinkList& L, ElemType e) {
	LinkList p=L->next;
	while (p && p->data!=e) {
		p = p->next;
	}
	return p;
}

int ListInsert(LinkList& L, int i, ElemType e) {
	//首先找到第i-1这个位置的结点
	LinkList p = L->next;//从首元结点开始
	int j = 1;
	while (p && j < i-1) {//这个判断语句还需要再思考？？？？？？？？？？是否p也可以是p->next
		p = p->next;
		j++;
	}

	//将s结点插入在i-1结点之后，i结点之前。
	if (!p || j > i-1) return -1;
	LinkList s = new LNode;
	s->data = e;
	s->next = p->next;
	p->next = s;
	return 1;
}

int ListDelete(LinkList& L, int i, ElemType e) {
	//首先找到第i-1这个位置的结点
	LinkList p = L->next;//从首元结点开始
	int j = 1;
	while (p->next && j < i - 1) {  //！！因为是“删除”，所以第i个位置可能是最后一个结点，最后一个结点的指针域为空。
		p = p->next;
		j++;
	}

	//插入到第i个结点。
	if (!p->next || j > i - 1) return -1;
	LinkList q = p->next;
	p->next = q->next;
	e = q->data;
	delete q;
	return 1;
}

单链表的创建：头插法、尾插法

//头插法
int CreatList_H(LinkList& L, int n) {
    L = new LNode;
    L->next = NULL;

    for (int i = 0; i < n; i++) {
        LinkList p = new LNode;
        cin >> p->data;
        p->next = L->next;
        L->next = p;
    }
    return 1;
}


//尾插法
int CreatList_D(LinkList& L, int n) {
    L = new LNode;
    L->next = NULL;
    LinkList r = L;

    for (int i = 0; i < n; i++) {
        LinkList p = new LNode;
        cin >> p->data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
    return 1;
}

循环链表

双向链表

双向循环链表

三种链表的比较

顺序表和链表特点的比较

！！！！！！！！！！！！！！！！非常重要！！！！！！！！！！！！！！！！！

线性表的应用

有序表的合并：顺序表实现、链表实现

//顺序表实现
void CombineList(SqList& L1, SqList& L2, SqList& L3) {
	TypeElem* p1, * p2, * p3;
	L3.elem = new TypeElem[L1.length + L2.length];
	L3.length = L1.length + L2.length;
	p3 = L3.elem;
	p1 = L1.elem;
	p2 = L2.elem;
	TypeElem* p1_tail = L1.elem + L1.length-1;
	TypeElem* p2_tail = L2.elem + L2.length-1;
	while (p1 <= p1_tail && p2 <= p2_tail) {
		if (*p1 <= *p2)  *p3++ = *p1++;
		else *p3++ = *p2++;
	}
	while(p1<= p1_tail) *p3++ = *p1++;
	while(p2<= p2_tail) *p3++ = *p2++;
}

//链表实现
void CombineList(LinkList La, LinkList Lb, LinkList& Lc) {
	LinkList pa, pb, pc;
	pa = La->next;
	pb = Lb->next;
	pc = Lc = La;

	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;
		}
		pc->next = pa ? pa : pb;//上面的while循环结束时，pa和pc有一个为空，这里判断哪一个为空，把不为空的哪一个的指针赋值给pc->next
	}
}