线性表
以下代码参考了【王道数据结构】，并作了适量补充，如有错，请指出
1.顺序表
1.1顺序表–静态存储–初始化
#include <windows.h>
#include <stdio.h>
#define MaxSize 10
typedef int ElemType;
//顺序表结构体的定义
typedef struct {
ElemType data[MaxSize];
int length;
}SqList;
//顺序表初始化
void InitList(SqList &L) {
for (int i = 0; i < MaxSize; i++)
L.data[i] = 0;
L.length = 0;
}
int main() {
SetConsoleOutputCP(65001);
SqList L;
printf("顺序表初始化：\n");
InitList(L);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
return 0;
}
输出结果如下：
顺序表初始化：
data[0]=0
data[1]=0
data[2]=0
data[3]=0
data[4]=0
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
1.2顺序表–动态存储–初始化
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#define InitSize 10
typedef int ElemType;
//顺序表结构体的定义
typedef struct {
ElemType *data;
int MaxSize;
int length;
}SqList;
//顺序表初始化
void InitList(SqList &L) {
L.data=(ElemType *)malloc(InitSize*sizeof(ElemType));
L.length = 0;
L.MaxSize=InitSize;
for (int i = 0; i < InitSize; i++){
L.data[i] = 0;
}
}
int main() {
SetConsoleOutputCP(65001);
SqList L;
printf("顺序表初始化：\n");
InitList(L);
for (int i = 0; i < L.MaxSize; i++) {
printf("data[%d]=%d\n", i, L.data[i]);
}
return 0;
}
输出结果如下：
顺序表初始化：
data[0]=0
data[1]=0
data[2]=0
data[3]=0
data[4]=0
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
1.3顺序表–按位序插入元素
#include <windows.h>
#include <stdio.h>
#define MaxSize 10
typedef int ElemType;
//顺序表结构体的定义
typedef struct {
ElemType data[MaxSize];
int length;
}SqList;
//顺序表初始化
void InitList(SqList &L) {
for (int i = 0; i < MaxSize; i++)
L.data[i] = 0;
L.length = 0;
}
//顺序表插入元素
bool ListInsert(SqList &L,int i,ElemType e){
if (i<1||i>L.length+1)
return false;
if (L.length>=MaxSize)
return false;
for (int j=L.length;j>=i;j--)
L.data[j]=L.data[j-1];
L.data[i-1]=e;
L.length++;
return true;
}
int main() {
SetConsoleOutputCP(65001);
SqList L;
InitList(L);
printf("顺序表初始化：\n顺序表长度为：%d\n",L.length);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("顺序表插入元素：\n顺序表长度为：%d\n",L.length);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
return 0;
}
输出结果如下：
顺序表初始化：
顺序表长度为：0
data[0]=0
data[1]=0
data[2]=0
data[3]=0
data[4]=0
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
顺序表插入元素：
顺序表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
1.4顺序表–指定结点的删除操作
#include <windows.h>
#include <stdio.h>
#define MaxSize 10
typedef int ElemType;
//顺序表结构体的定义
typedef struct {
ElemType data[MaxSize];
int length;
}SqList;
//顺序表初始化
void InitList(SqList &L) {
for (int i = 0; i < MaxSize; i++)
L.data[i] = 0;
L.length = 0;
}
//顺序表插入元素
bool ListInsert(SqList &L,int i,ElemType e){
if (i<1||i>L.length+1)
return false;
if (L.length>=MaxSize)
return false;
for (int j=L.length;j>=i;j--)
L.data[j]=L.data[j-1];
L.data[i-1]=e;
L.length++;
return true;
}
//顺序表删除元素
bool ListDelete(SqList &L,int i,ElemType &e){
if (i<1||i>L.length)
return false;
e=L.data[i-1];
for (int j=i;j<L.length;j++)
L.data[j-1]=L.data[j];
L.length--;
L.data[L.length]=0;
return true;
}
int main() {
SetConsoleOutputCP(65001);
SqList L;
InitList(L);
printf("顺序表初始化：\n顺序表长度为：%d\n",L.length);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("顺序表插入元素：\n顺序表长度为：%d\n",L.length);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
int e=-1;
ListDelete(L,3,e);
printf("顺序表删除元素：\n顺序表长度为：%d\n删除的元素为：%d\n",L.length,e);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
return 0;
}
输出结果如下：
顺序表初始化：
顺序表长度为：0
data[0]=0
data[1]=0
data[2]=0
data[3]=0
data[4]=0
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
顺序表插入元素：
顺序表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
顺序表删除元素：
顺序表长度为：4
删除的元素为：30
data[0]=10
data[1]=20
data[2]=40
data[3]=50
data[4]=0
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
1.5顺序表–按位查找元素
#include <windows.h>
#include <stdio.h>
#define MaxSize 10
typedef int ElemType;
//顺序表结构体的定义
typedef struct {
ElemType data[MaxSize];
int length;
}SqList;
//顺序表初始化
void InitList(SqList &L) {
for (int i = 0; i < MaxSize; i++)
L.data[i] = 0;
L.length = 0;
}
//顺序表插入元素
bool ListInsert(SqList &L,int i,ElemType e){
if (i<1||i>L.length+1)
return false;
if (L.length>=MaxSize)
return false;
for (int j=L.length;j>=i;j--)
L.data[j]=L.data[j-1];
L.data[i-1]=e;
L.length++;
return true;
}
//顺序表按位查找
int GetElem(SqList L,int i){
return L.data[i-1];
}
int main() {
SetConsoleOutputCP(65001);
SqList L;
InitList(L);
printf("顺序表初始化：\n顺序表长度为：%d\n",L.length);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("顺序表插入元素：\n顺序表长度为：%d\n",L.length);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
printf("顺序表查找元素(按位查找)：\n顺序表第3位元素为：%d\n",GetElem(L,3));
return 0;
}
输出结果如下：
顺序表初始化：
顺序表长度为：0
data[0]=0
data[1]=0
data[2]=0
data[3]=0
data[4]=0
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
顺序表插入元素：
顺序表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
顺序表查找元素(按位查找)：
顺序表第3位元素为：30
1.6顺序表–按值查找元素
#include <windows.h>
#include <stdio.h>
#define MaxSize 10
typedef int ElemType;
//顺序表结构体的定义
typedef struct {
ElemType data[MaxSize];
int length;
}SqList;
//顺序表初始化
void InitList(SqList &L) {
for (int i = 0; i < MaxSize; i++)
L.data[i] = 0;
L.length = 0;
}
//顺序表插入元素
bool ListInsert(SqList &L,int i,ElemType e){
if (i<1||i>L.length+1)
return false;
if (L.length>=MaxSize)
return false;
for (int j=L.length;j>=i;j--)
L.data[j]=L.data[j-1];
L.data[i-1]=e;
L.length++;
return true;
}
//顺序表按值查找
int LocateElem(SqList L,ElemType e){
for (int i=0;i<L.length;i++)
if (L.data[i]==e)
return i+1;
return -1;
}
int main() {
SetConsoleOutputCP(65001);
SqList L;
InitList(L);
printf("顺序表初始化：\n顺序表长度为：%d\n",L.length);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("顺序表插入元素：\n顺序表长度为：%d\n",L.length);
for (int i = 0; i < MaxSize; i++)
printf("data[%d]=%d\n", i, L.data[i]);
printf("顺序表查找元素(按值查找)：\n顺序表元素值为20在第%d位\n",LocateElem(L,20));
return 0;
}
输出结果如下：
顺序表初始化：
顺序表长度为：0
data[0]=0
data[1]=0
data[2]=0
data[3]=0
data[4]=0
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
顺序表插入元素：
顺序表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
data[5]=0
data[6]=0
data[7]=0
data[8]=0
data[9]=0
顺序表查找元素(按值查找)：
顺序表元素值为20在第2位
2.单链表
2.1单链表–带头结点–初始化
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表元素为空。
2.2单链表–不带头结点–初始化
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L==NULL);
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表元素为空。
2.3单链表–带头结点–按位序插入元素
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
2.4单链表–不带头结点–按位序插入元素
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
int data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L==NULL);
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
if (i==1){
LNode *s=(LNode*)malloc(sizeof(LNode));
s->data=e;
s->next=L;
L=s;
return true;
}
LNode *p;
int j=1;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode*)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
2.5单链表–指定结点的后插操作
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//单链表指定结点后插操作
bool InsertNextNode(LNode *p,ElemType e){
if (p==NULL)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
if (s==NULL)
return false;
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
return InsertNextNode(p,e);
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
int i=2;
int e=200;
printf("单链表在第%d位插入值为%d的元素：\n",i,e);
ListInsert(L,i,e);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
单链表在第2位插入值为200的元素：
单链表长度为：6
data[0]=10
data[1]=200
data[2]=20
data[3]=30
data[4]=40
data[5]=50
2.6单链表–指定结点的前插操作
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//单链表指定结点前插操作
bool InsertPriorNode(LinkList &L,int i,ElemType e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
if (s==NULL)
return false;
s->next=p->next;
p->next=s;
s->data=p->data;
p->data=e;
return true;
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
if (s==NULL)
return false;
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
int i=2;
int e=200;
printf("单链表在第%d位前面（即第%d位）插入值为%d的元素：\n",i,i-1,e);
InsertPriorNode(L,i,e);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
单链表在第2位前面（即第1位）插入值为200的元素：
单链表长度为：6
data[0]=200
data[1]=10
data[2]=20
data[3]=30
data[4]=40
data[5]=50
2.7单链表–带头结点–按位序删除元素
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//单链表删除元素（按位序删除）
bool ListDelete(LinkList &L,int i,ElemType &e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
if (p->next==NULL)
return false;
LNode *q=p->next;
e=q->data;
p->next=q->next;
free(q);
return true;
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表删除元素：\n");
int i=2;
ElemType e;
ListDelete(L,i,e);
printf("单链表删除在第%d位值为%d的元素：\n",i,e);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
单链表删除元素：
单链表删除在第2位值为20的元素：
单链表长度为：4
data[0]=10
data[1]=30
data[2]=40
data[3]=50
2.8单链表–不带头结点–按位序删除元素
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
int data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L==NULL);
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
if (i==1){
LNode *s=(LNode*)malloc(sizeof(LNode));
s->data=e;
s->next=L;
L=s;
return true;
}
LNode *p;
int j=1;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode*)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//单链表删除元素（按位序删除）
bool ListDelete(LinkList &L,int i,ElemType &e){
if (i<1)
return false;
LNode *p;
int j=1;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
if (p->next==NULL)
return false;
LNode *q=p->next;
e=q->data;
p->next=q->next;
free(q);
return true;
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表删除元素：\n");
int i=2;
ElemType e;
ListDelete(L,i,e);
printf("单链表删除在第%d位值为%d的元素：\n",i,e);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
单链表删除元素：
单链表删除在第2位值为20的元素：
单链表长度为：4
data[0]=10
data[1]=30
data[2]=40
data[3]=50
2.9单链表–带头结点–指定结点的删除操作
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//单链表指定结点删除操作
bool DeleteNode(LNode *p,ElemType &e){
if (p==NULL)
return false;
if (p->next==NULL)
return false;
LNode *q=p->next;
e=q->data;
p->next=q->next;
free(q);
return true;
}
//单链表删除元素（按位序删除）
bool ListDelete(LinkList &L,int i,ElemType &e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
return DeleteNode(p,e);
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表删除元素：\n");
int i=2;
ElemType e;
ListDelete(L,i,e);
printf("单链表删除在第%d位值为%d的元素：\n",i,e);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
单链表删除元素：
单链表删除在第2位值为20的元素：
单链表长度为：4
data[0]=10
data[1]=30
data[2]=40
data[3]=50
2.10单链表–不带头结点–指定结点的删除操作
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
int data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L==NULL);
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
if (i==1){
LNode *s=(LNode*)malloc(sizeof(LNode));
s->data=e;
s->next=L;
L=s;
return true;
}
LNode *p;
int j=1;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode*)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//单链表指定结点删除操作
bool DeleteNode(LNode *p,ElemType &e){
if (p==NULL)
return false;
if (p->next==NULL)
return false;
LNode *q=p->next;
e=q->data;
p->next=q->next;
free(q);
return true;
}
//单链表删除元素（按位序删除）
bool ListDelete(LinkList &L,int i,ElemType &e){
if (i<1)
return false;
LNode *p;
int j=1;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
return DeleteNode(p,e);
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表删除元素：\n");
int i=2;
ElemType e;
ListDelete(L,i,e);
printf("单链表删除在第%d位值为%d的元素：\n",i,e);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
单链表删除元素：
单链表删除在第2位值为20的元素：
单链表长度为：4
data[0]=10
data[1]=30
data[2]=40
data[3]=50
2.11单链表–按位查找元素
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//按位查找元素
int GetElem(LinkList L,int i){
if (i<0)
return NULL;
LNode *p;
int j=0;
p=L;
while (p!=NULL&&j<i){
p=p->next;
j++;
}
return p->data;
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
int i=3;
printf("按位查找链表第%d位的元素值为：%d\n",i,GetElem(L,i));
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
按位查找链表第3位的元素值为：30
2.12单链表–按值查找元素
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//单链表插入元素（按位序插入）
bool ListInsert(LinkList &L,int i,ElemType e){
if (i<1)
return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL && j<i-1){
p=p->next;
j++;
}
if (p==NULL)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//按值查找元素
int LocateElem(LinkList L,ElemType e){
LNode *p=L->next;
int i=1;
while (p!=NULL&&p->data!=e){
p=p->next;
i++;
}
if (p){
return i;
}
else{
return -1;
}
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
ListInsert(L,1,10);
ListInsert(L,2,20);
ListInsert(L,3,30);
ListInsert(L,4,40);
ListInsert(L,5,50);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
int e=30;
printf("按值查找链表值为%d的元素在第%d位\n",e,LocateElem(L,e));
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=10
data[1]=20
data[2]=30
data[3]=40
data[4]=50
按值查找链表值为30的元素在第3位
2.13单链表–头插法创建单链表
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//头插法建立单链表
LinkList ListHeadInsert(LinkList &L){
LNode *s;
int x;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
scanf("%d",&x);
while(x!=9999){
s=(LNode*)malloc(sizeof(LNode));
s->data=x;
s->next=L->next;
L->next=s;
scanf("%d",&x);
}
return L;
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("请输入单链表需要插入的元素(以回车键间隔每个元素，直至输入9999结束元素的插入)：\n");
ListHeadInsert(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
请输入单链表需要插入的元素(以回车键间隔每个元素，直至输入9999结束元素的插入)：
1
2
3
4
5
9999
单链表长度为：5
data[0]=5
data[1]=4
data[2]=3
data[3]=2
data[4]=1
2.14单链表–尾插法创建单链表
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//尾插法创建单链表
LinkList List_TailInsert(LinkList &L){
int x;
L=(LinkList)malloc(sizeof(LNode));
LNode *s,*r=L;
scanf("%d",&x);
while(x!=9999){
s=(LNode *)malloc(sizeof(LNode));
s->data=x;
r->next=s;
r=s;
scanf("%d",&x);
}
r->next=NULL;
return L;
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("请输入单链表需要插入的元素(以回车键间隔每个元素，直至输入9999结束元素的插入)：\n");
List_TailInsert(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
请输入单链表需要插入的元素(以回车键间隔每个元素，直至输入9999结束元素的插入)：
1
2
3
4
5
9999
单链表长度为：5
data[0]=1
data[1]=2
data[2]=3
data[3]=4
data[4]=5
2.15单链表–单链表逆置
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=NULL;
return true;
}
//单链表判断是否为空
bool Empty(LinkList L){
return (L->next==NULL);
}
//头插法建立单链表
LinkList ListHeadInsert(LinkList &L){
LNode *s;
int x;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
scanf("%d",&x);
while(x!=9999){
s=(LNode*)malloc(sizeof(LNode));
s->data=x;
s->next=L->next;
L->next=s;
scanf("%d",&x);
}
return L;
}
//单链表的逆置
LinkList ListInversion(LinkList &L){
LNode *p,*q;
p=L->next;
L->next=NULL;
while(p!=NULL){
q=p;
p=p->next;
q->next=L->next;
L->next=q;
}
return L;
}
//单链表长度计算
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("请输入单链表需要插入的元素(以回车键间隔每个元素，直至输入9999结束元素的插入)：\n");
ListHeadInsert(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表的逆置：\n");
ListInversion(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
请输入单链表需要插入的元素(以回车键间隔每个元素，直至输入9999结束元素的插入)：
1
2
3
4
5
9999
单链表长度为：5
data[0]=5
data[1]=4
data[2]=3
data[3]=2
data[4]=1
单链表的逆置：
单链表长度为：5
data[0]=1
data[1]=2
data[2]=3
data[3]=4
data[4]=5
3.双链表
3.1双链表–尾插法插入元素
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//双链表结构体的定义
typedef struct DNode{
ElemType data;
struct DNode *prior,*next;
}DNode,*DLinkList;
//双链表初始化
bool InitDLinkList(DLinkList &L){
L=(DNode *)malloc(sizeof(DNode));
if (L==NULL)
return false;
L->prior=NULL;
L->next=NULL;
return true;
}
//双链表的插入(后插法：在最后的结点p插入一个新的结点s)
bool InsertNextDNode(DNode *p,int x){
while (p->next!=NULL){
p=p->next;
}
DNode *s;
s=(DNode *)malloc(sizeof(DNode));
s->data=x;
if (p==NULL || s==NULL)
return false;
s->next=p->next;
if (p->next!=NULL)
p->next->prior=s;
s->prior=p;
p->next=s;
return true;
}
//双链表判断是否为空
bool Empty(DLinkList L){
if (L->next==NULL)
return true;
else
return false;
}
//双链表长度计算
int Length(DLinkList L){
int len=0;
DNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//双链表打印输出
void PrintList(DLinkList L){
if (Empty(L)){
printf("双链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
DLinkList L;
printf("双链表初始化：\n");
InitDLinkList(L);
printf("双链表长度为：%d\n",Length(L));
PrintList(L);
printf("双链表插入元素：\n");
InsertNextDNode(L,1);
InsertNextDNode(L,2);
InsertNextDNode(L,3);
InsertNextDNode(L,4);
InsertNextDNode(L,5);
printf("双链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
双链表初始化：
双链表长度为：0
双链表元素为空。
双链表插入元素：
双链表长度为：5
data[0]=1
data[1]=2
data[2]=3
data[3]=4
data[4]=5
3.2双链表–尾删法删除元素
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//双链表结构体的定义
typedef struct DNode{
ElemType data;
struct DNode *prior,*next;
}DNode,*DLinkList;
//双链表初始化
bool InitDLinkList(DLinkList &L){
L=(DNode *)malloc(sizeof(DNode));
if (L==NULL)
return false;
L->prior=NULL;
L->next=NULL;
return true;
}
//双链表的插入(后插法：在最后的结点p插入一个新的结点s)
bool InsertNextDNode(DNode *p,int x){
while (p->next!=NULL){
p=p->next;
}
DNode *s;
s=(DNode *)malloc(sizeof(DNode));
s->data=x;
if (p==NULL || s==NULL)
return false;
s->next=p->next;
if (p->next!=NULL)
p->next->prior=s;
s->prior=p;
p->next=s;
return true;
}
//双链表的删除(后删法：删除结点p的后继结点q)
bool DeleteNextDNode(DNode *p){
while (p->next!=NULL){
p=p->next;
}
p=p->prior;
if (p==NULL)
return false;
DNode *q=p->next;
if (q==NULL)
return false;
p->next=q->next;
if (q->next!=NULL)
q->next->prior=p;
free(q);
return true;
}
//删除整个双链表
void DestoryList(DLinkList L){
while (L->next!=NULL){
DeleteNextDNode(L);
}
free(L);
L=NULL;
}
//双链表判断是否为空
bool Empty(DLinkList L){
if (L->next==NULL)
return true;
else
return false;
}
//双链表长度计算
int Length(DLinkList L){
int len=0;
DNode *p=L;
while(p->next!=NULL){
p=p->next;
len++;
}
return len;
}
//双链表打印输出
void PrintList(DLinkList L){
if (Empty(L)){
printf("双链表元素为空。\n");
return;
}
L=L->next;
int i=0;
while (L!=NULL){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
DLinkList L;
printf("双链表初始化：\n");
InitDLinkList(L);
printf("双链表长度为：%d\n",Length(L));
PrintList(L);
printf("双链表插入元素：\n");
InsertNextDNode(L,1);
InsertNextDNode(L,2);
InsertNextDNode(L,3);
InsertNextDNode(L,4);
InsertNextDNode(L,5);
printf("双链表长度为：%d\n",Length(L));
PrintList(L);
printf("双链表删除元素：\n");
DeleteNextDNode(L);
printf("双链表长度为：%d\n",Length(L));
PrintList(L);
printf("删除整个双链表：\n");
DestoryList(L);
printf("双链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
双链表初始化：
双链表长度为：0
双链表元素为空。
双链表插入元素：
双链表长度为：5
data[0]=1
data[1]=2
data[2]=3
data[3]=4
data[4]=5
双链表删除元素：
双链表长度为：4
data[0]=1
data[1]=2
data[2]=3
data[3]=4
删除整个双链表：
双链表长度为：0
双链表元素为空。
4.循环链表
4.1循环单链表
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//单链表结构体的定义
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表初始化
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));
if (L==NULL)
return false;
L->next=L;
return true;
}
//尾插法创建单链表
LinkList List_TailInsert(LinkList &L,int x){
LNode *p=L;
while (p->next!=L){
p=p->next;
}
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=x;
s->next=p->next;
p->next=s;
p=p->next;
return L;
}
//单链表判断是否为空
bool Empty(LinkList L){
if (L->next==L)
return true;
else
return false;
}
//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L,LNode *p){
if (p->next==L)
return true;
else
return false;
}
//单链表长度计
int Length(LinkList L){
int len=0;
LNode *p=L;
while(p->next!=L){
p=p->next;
len++;
}
return len;
}
//单链表打印输出
void PrintList(LinkList L){
if (Empty(L)){
printf("单链表元素为空。\n");
return;
}
L=L->next;
int i=0;
LNode *p;
while (isTail(L,p)!=true){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
LinkList L;
LNode* p=L;
printf("单链表初始化：\n");
InitList(L);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
printf("单链表插入元素：\n");
List_TailInsert(L,1);
List_TailInsert(L,2);
List_TailInsert(L,3);
List_TailInsert(L,4);
List_TailInsert(L,5);
printf("单链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
单链表初始化：
单链表长度为：0
单链表元素为空。
单链表插入元素：
单链表长度为：5
data[0]=1
data[1]=2
data[2]=3
data[3]=4
data[4]=5
4.2循环双链表
#include <windows.h>
#include <stdio.h>
typedef int ElemType;
//双链表结构体的定义
typedef struct DNode{
ElemType data;
struct DNode *prior,*next;
}DNode,*DLinkList;
//双链表初始化
bool InitDLinkList(DLinkList &L){
L=(DNode *)malloc(sizeof(DNode));
if (L==NULL)
return false;
L->prior=L;
L->next=L;
return true;
}
//尾插法创建双链表
DLinkList List_TailInsert(DLinkList &L,int x){
DNode *p=L;
while (p->next!=L){
p=p->next;
}
DNode *s;
s=(DNode *)malloc(sizeof(DNode));
s->data=x;
s->next=p->next;
p->next->prior=s;
s->prior=p;
p->next=s;
return L;
}
//双链表判断是否为空
bool Empty(DLinkList L){
if (L->next==L)
return true;
else
return false;
}
//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinkList L,DNode *p){
if (p->next==L)
return true;
else
return false;
}
//双链表长度计算
int Length(DLinkList L){
int len=0;
DNode *p=L;
while(p->next!=L){
p=p->next;
len++;
}
return len;
}
//双链表打印输出
void PrintList(DLinkList L){
if (Empty(L)){
printf("双链表元素为空。\n");
return;
}
L=L->next;
int i=0;
DNode *p;
while (isTail(L,p)!=true){
printf("data[%d]=%d\n",i,L->data);
L=L->next;
i++;
}
}
int main(){
SetConsoleOutputCP(65001);
DLinkList L;
printf("双链表初始化：\n");
InitDLinkList(L);
printf("双链表长度为：%d\n",Length(L));
PrintList(L);
printf("双链表插入元素：\n");
List_TailInsert(L,1);
List_TailInsert(L,2);
List_TailInsert(L,3);
List_TailInsert(L,4);
List_TailInsert(L,5);
printf("双链表长度为：%d\n",Length(L));
PrintList(L);
return 0;
}
输出结果如下：
双链表初始化：
双链表长度为：0
双链表元素为空。
双链表插入元素：
双链表长度为：5
data[0]=1
data[1]=2
data[2]=3
data[3]=4
data[4]=5