10.顺序表
1.顺序表的定义
- 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
- 顺序表：可动态增长的数组，要求数据是连续存储的
typedef struct _SqList SqList;
struct _SqList
{
int* elems;//顺序表的基地址
int length;//顺序表的长度
int size;//顺序表总的空间大小
};
typedef struct
{
int* elems;//顺序表的基地址
int length;//顺序表的长度
int size;//顺序表总的空间大小
}SqList;
大话数据结构版
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int ElemType; /* ElemType类型根据实际情况而定，这里为int */
typedef struct
{
ElemType data[MAXSIZE]; /* 数组，存储数据元素 */
int length; /* 线性表当前长度 */
}SqList;
2.顺序表的初始化
bool initList(SqList& L)//构造一个空的顺序表L
{
L.elems = new int[MAX_SIZE];//为顺序表分配MAX_SIZE个int元素的空间
if (!L.elems) return false;
L.length = 0;
L.size = MAX_SIZE;
return true;
}
3.顺序表的打印
void listPrint(SqList& L)
{
cout << "顺序表的存储空间size:" << L.size << "，已保存的元素个数length：" << L.length << endl;
for (int i = 0; i <= L.length - 1; i++)
{
cout << L.elems[i] << " ";
}
cout << endl;
}
4.表尾添加元素
bool listAppend(SqList& L, int e)
{
if (L.length == L.size) return false;//存储空间已满
L.elems[L.length] = e;
L.length++;//表长增加1
return true;
}
//2.添加元素
int count = 0;
cout << "请输入要添加的元素个数：" << endl;
cin >> count;
for (int i = 0; i < count; i++)
{
cout << "\n请输入要添加的元素e：";
cin >> e;
if (listAppend(list, e))
{
cout << "添加成功！" << endl;
}
else
{
cout << "添加失败！" << endl;
}
}
listPrint(list);
5.表中任意位置插入元素
bool listInsert(SqList &L, int i, int e)
{
if (i < 0 || i >= L.length) return false;//i值不合法
if (L.length == L.size) return false;//存储空间已满
for (int j = L.length - 1; j >= i; j--)
{
L.elems[j + 1] = L.elems[j];//从最后一个元素开始后移，直到下标为i的元素后移
}
L.elems[i] = e;//将新元素e放入第i的位置
L.length++;//表长加1
return true;
}
//3.插入元素
cout << "请输入要插入元素的个数,（先输入插入位置，后输入元素个数）：" << endl;
cin >> i >> e;
if (listInsert(list, i, e))
{
cout << "插入成功！" << endl;
}
else
{
cout << "插入失败！" << endl;
}
listPrint(list);
6.表中任意位置删除元素
bool listDelete(SqList& L, int i)
{
if (i < 0 || i >= L.length) return false;//删除位置无效
if (i == L.length - 1)//删除最后一个元素
{
L.length--;
return true;
}
for (int j = i; j < L.length - 1; j++)
{
L.elems[j] = L.elems[j + 1];//删除位置的后续元素依次往前移
}
L.length--;
return true;
}
//4.删除元素
cout << "请输入要删除元素的位置：";
cin >> i;
if (listDelete(list, i))
{
cout << "删除成功！" << endl;
}
else
{
cout << "删除失败!" << endl;
}
listPrint(list);
7.链表销毁
void destroyList(SqList& L)
{
if (L.elems) delete[]L.elems;//释放存储空间
L.length = 0;
L.size = 0;
}
8.获取元素
//获取元素
bool ListGetElement(SqList &L, int i, int &e)
{
if (L.length == 0 || i < 0 || i > L.length - 1) return false;
e = L.elems[i];
return true;
}
完整代码
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
#define MAX_SIZE 100
//typedef struct _SqList SqList;
//
//struct _SqList
//{
// int* elems;//顺序表的基地址
// int length;//顺序表的长度
// int size;//顺序表总的空间大小
//};
typedef struct
{
int* elems;//顺序表的基地址
int length;//顺序表的长度
int size;//顺序表总的空间大小
}SqList;
bool initList(SqList& L)//构造一个空的顺序表L
{
L.elems = new int[MAX_SIZE];//为顺序表分配MAX_SIZE个int元素的空间
if (!L.elems) return false;
L.length = 0;
L.size = MAX_SIZE;
return true;
}
void listPrint(SqList& L)
{
cout << "顺序表的存储空间size:" << L.size << "，已保存的元素个数length：" << L.length << endl;
for (int i = 0; i <= L.length - 1; i++)
{
cout << L.elems[i] << " ";
}
cout << endl;
}
bool listAppend(SqList& L, int e)
{
if (L.length == L.size) return false;//存储空间已满
L.elems[L.length] = e;
L.length++;//表长增加1
return true;
}
bool listInsert(SqList &L, int i, int e)
{
if (i < 0 || i >= L.length) return false;//i值不合法
if (L.length == L.size) return false;//存储空间已满
for (int j = L.length - 1; j >= i; j--)
{
L.elems[j + 1] = L.elems[j];//从最后一个元素开始后移，直到下标为i的元素后移
}
L.elems[i] = e;//将新元素e放入第i的位置
L.length++;//表长加1
return true;
}
bool listDelete(SqList& L, int i)
{
if (i < 0 || i >= L.length) return false;//删除位置无效
if (i == L.length - 1)//删除最后一个元素
{
L.length--;
return true;
}
for (int j = i; j < L.length - 1; j++)
{
L.elems[j] = L.elems[j + 1];//删除位置的后续元素依次往前移
}
L.length--;
return true;
}
void destroyList(SqList& L)
{
if (L.elems) delete[]L.elems;//释放存储空间
L.length = 0;
L.size = 0;
}
int main()
{
SqList list;
int i, e;
cout << "顺序表的初始化：" << endl;
//1.初始化
if (initList(list))
{
cout << "顺序表初始化成功！" << endl;
}
listPrint(list);
//2.添加元素
int count = 0;
cout << "请输入要添加的元素个数：" << endl;
cin >> count;
for (int i = 0; i < count; i++)
{
cout << "\n请输入要添加的元素：";
cin >> e;
if (listAppend(list, e))
{
cout << "添加成功！" << endl;
}
else
{
cout << "添加失败！" << endl;
}
}
listPrint(list);
//3.插入元素
cout << "请输入要插入元素的个数,（先输入插入位置，后输入所插入的元素）：" << endl;
cin >> i >> e;
if (listInsert(list, i, e))
{
cout << "插入成功！" << endl;
}
else
{
cout << "插入失败！" << endl;
}
listPrint(list);
//4.删除元素
cout << "请输入要删除元素的位置：";
cin >> i;
if (listDelete(list, i))
{
cout << "删除成功！" << endl;
}
else
{
cout << "删除失败!" << endl;
}
listPrint(list);
//5.销毁链表
destroyList(list);
system("pause");
return EXIT_SUCCESS;
}
大话数据结构课程代码
Status ListInsert(StaticLinkList L, int i, ElemType e)
{
int j, k, l;
k = MAXSIZE - 1; /* 注意k首先是最后一个元素的下标 */
if (i < 1 || i > ListLength(L) + 1)
return ERROR;
j = Malloc_SSL(L); /* 获得空闲分量的下标 */
if (j)
{
L[j].data = e; /* 将数据赋值给此分量的data */
for(l = 1; l <= i - 1; l++) /* 找到第i个元素之前的位置 */
k = L[k].cur;
L[j].cur = L[k].cur; /* 把第i个元素之前的cur赋值给新元素的cur */
L[k].cur = j; /* 把新元素的下标赋值给第i个元素之前元素的ur */
return OK;
}
return ERROR;
}
/*将所有的在线性表Lb中但不在La中的数据元素插入到La中*/
void unionL(SqList *La,SqList Lb)
{
int La_len,Lb_len,i;
ElemType e; /*声明与La和Lb相同的数据元素e*/
La_len=ListLength(*La); /*求线性表的长度 */
Lb_len=ListLength(Lb);
for (i=1;i<=Lb_len;i++)
{
GetElem(Lb,i,&e); /*取Lb中第i个数据元素赋给e*/
if (!LocateElem(*La,e)) /*La中不存在和e相同数据元素*/
ListInsert(La,++La_len,e); /*插入*/
}
}
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int ElemType; /* ElemType类型根据实际情况而定，这里为int */
typedef struct
{
ElemType data[MAXSIZE]; /* 数组，存储数据元素 */
int length; /* 线性表当前长度 */
}SqList;
#define OK 1
#define ERROR 0
/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Status;
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值，注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(SqList L,int i,ElemType *e)
{
if(L.length==0 || i<1 || i>L.length)
return ERROR;
*e=L.data[i-1];
return OK;
}
/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList *L,int i,ElemType e)
{
int k;
if (L->length==MAXSIZE) /* 顺序线性表已经满 */
return ERROR;
if (i<1 || i>L->length+1) /* 当i比第一位置小或者比最后一位置后一位置还要大时 */
return ERROR;
if (i<=L->length) /* 若插入数据位置不在表尾 */
{
for(k=L->length-1;k>=i-1;k--) /* 将要插入位置后的元素向后移一位 */
L->data[k+1]=L->data[k];
}
L->data[i-1]=e; /* 将新元素插入 */
L->length++;
return OK;
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L,int i,ElemType *e)
{
int k;
if (L->length==0) /* 线性表为空 */
return ERROR;
if (i<1 || i>L->length) /* 删除位置不正确 */
return ERROR;
*e=L->data[i-1];
if (i<L->length) /* 如果删除不是最后位置 */
{
for(k=i;k<L->length;k++) /* 将删除位置后继元素前移 */
L->data[k-1]=L->data[k];
}
L->length--;
return OK;
}
/* 线性表的单链表存储结构 */
typedef struct Node
{
ElemType data;
struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */
/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
int j;
LinkList p; /* 声明一结点p */
p = L->next; /* 让p指向链表L的第一个结点 */
j = 1; /* j为计数器 */
while (p && j<i) /* p不为空或者计数器j还没有等于i时，循环继续 */
{
p = p->next; /* 让p指向下一个结点 */
++j;
}
if ( !p || j>i )
return ERROR; /* 第i个元素不存在 */
*e = p->data; /* 取第i个元素的数据 */
return OK;
}
s->next = p->next; /* 将p的后继结点赋值给s的后继 */
p->next = s; /* 将s赋值给p的后继 */
/* 初始条件：链式线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
int j;
LinkList p,s;
p = *L;
j = 1;
while (p && j < i) /* 寻找第i个结点 */
{
p = p->next;
++j;
}
if (!p || j > i)
return ERROR; /* 第i个元素不存在 */
s = (LinkList)malloc(sizeof(Node)); /* 生成新结点(C语言标准函数) */
s->data = e;
s->next = p->next; /* 将p的后继结点赋值给s的后继 */
p->next = s; /* 将s赋值给p的后继 */
return OK;
}
q = p->next;
p->next = q->next; /* 将q的后继赋值给p的后继 */
/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
int j;
LinkList p,q;
p = *L;
j = 1;
while (p->next && j < i) /* 遍历寻找第i个元素 */
{
p = p->next;
++j;
}
if (!(p->next) || j > i)
return ERROR; /* 第i个元素不存在 */
q = p->next;
p->next = q->next; /* 将q的后继赋值给p的后继 */
*e = q->data; /* 将q结点中的数据给e */
free(q); /* 让系统回收此结点，释放内存 */
return OK;
}
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)
{
LinkList p;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node));
(*L)->next = NULL; /* 先建立一个带头结点的单链表 */
for (i=0; i<n; i++)
{
p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
p->next = (*L)->next;
(*L)->next = p; /* 插入到表头 */
}
}
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{
LinkList p,r;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
r=*L; /* r为指向尾部的结点 */
for (i=0; i<n; i++)
{
p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
r->next=p; /* 将表尾终端结点的指针指向新结点 */
r = p; /* 将当前的新结点定义为表尾终端结点 */
}
r->next = NULL; /* 表示当前链表结束 */
}
/* 初始条件：链式线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{
LinkList p,q;
p=(*L)->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
q=p->next;
free(p);
p=q;
}
(*L)->next=NULL; /* 头结点指针域为空 */
return OK;
}
#define MAXSIZE 1000 /* 存储空间初始分配量 */
/* 线性表的静态链表存储结构 */
typedef struct
{
ElemType data;
int cur; /* 游标(Cursor) ，为0时表示无指向 */
} Component,StaticLinkList[MAXSIZE];
/* 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针 */
Status InitList(StaticLinkList space)
{
int i;
for (i=0; i<MAXSIZE-1; i++)
space[i].cur = i+1;
space[MAXSIZE-1].cur = 0; /* 目前静态链表为空，最后一个元素的cur为0 */
return OK;
}
/* 若备用空间链表非空，则返回分配的结点下标，否则返回0 */
int Malloc_SSL(StaticLinkList space)
{
int i = space[0].cur; /* 当前数组第一个元素的cur存的值 */
/* 就是要返回的第一个备用空闲的下标 */
if (space[0]. cur)
space[0]. cur = space[i].cur; /* 由于要拿出一个分量来使用了， */
/* 所以我们就得把它的下一个 */
/* 分量用来做备用 */
return i;
}
/* 删除在L中第i个数据元素 */
Status ListDelete(StaticLinkList L, int 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].cur = L[j].cur;
Free_SSL(L, j);
return OK;
}
/* 将下标为k的空闲结点回收到备用链表 */
void Free_SSL(StaticLinkList space, int k)
{
space[k].cur = space[0].cur; /* 把第一个元素的cur值赋给要删除的分量cur */
space[0].cur = k; /* 把要删除的分量下标赋值给第一个元素的cur */
}
/* 初始条件：静态链表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(StaticLinkList L)
{
int j=0;
int i=L[MAXSIZE-1].cur;
while(i)
{
i=L[i].cur;
j++;
}
return j;
}
p=rearA->next; /* 保存A表的头结点，即① */
rearA->next=rearB->next->next; /* 将本是指向B表的第一个结点（不是头结点）*/
/* 赋值给reaA->next，即② */
q=rearB->next;
rearB->next=p; /* 将原A表的头结点赋值给rearB->next，即③ */
free（q）; /* 释放q */
/*线性表的双向链表存储结构*/
typedef struct DulNode
{
ElemType data;
struct DuLNode *prior; /*直接前驱指针*/
struct DuLNode *next; /*直接后继指针*/
} DulNode, *DuLinkList;
p->next->prior = p = p->prior->next
s - >prior = p; /*把p赋值给s的前驱，如图中①*/
s -> next = p -> next; /*把p->next赋值给s的后继，如图中②*/
p -> next -> prior = s; /*把s赋值给p->next的前驱，如图中③*/
p -> next = s; /*把s赋值给p的后继，如图中④*/
p->prior->next=p->next; /*把p->next赋值给p->prior的后继，如图中①*/
p->next->prior=p->prior; /*把p->prior赋值给p->next的前驱，如图中②*/
free（p）; /*释放结点*/
参考资料来源：
奇牛学院
