线性表
线性表的抽象数据类型：
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;
}
3597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
