目录
顺序表重点操作
1.顺序表的静态定义
#define MaxSize 100; //定义顺序表最大长度
typedef struct{
ElemType data[MaxSize];
int length; //当前顺序表的长度
}SqList; //顺序表的类型定义2.顺序表的动态定义
typedef struct{
int *data; //动态分配数组的指针
int MaxSize; //顺序表的最大容量
int length; //当前顺序表的长度
}SqList; //顺序表的类型定义3.顺序表的静态初始化
void InitList(SqList *L){
int i;
for(i = 0;i < L->length; i++){
L->data[i] = 0;
}
L->length = 0;
}
4.顺序表的动态初始化
#define InitSize 10
void InitList(SqList *L){
L->data = (int *)malloc(InitSize * sizeof(int))
L->length = 0;
L->MaxSize = InitSize;
}5.顺序表的插入
bool ListInsert(SqList *L,int i,ElemType e){
if(i < 1 || i > L->length) //判断i值是否合法
return false;
if(L->length > L->MaxSize) //判断
return false;
int j;
for(j = L->length;j >= i;j--)
L->data[j] = L->data[j-1];
L->data[i-1] = e;
L->length++;
return true;
}
6.顺序表的删除
bool ListDelete(SqList *L,int i,ElemType *e){
if(i < 1 || i > L->length)
return false;
e = L->data[i-1];
int j;
for(j = i;j < L->length;j++)
L->data[j-1] = L->data[j];
L->length--;
return true;
}7.顺序表的按位查找
ElemType GetElem(SqList L,int i){
return L.data[i-1];
}8. 顺序表的按值查找
ElemType LocateElem(SqList L,ElemType e){
int i;
for(i = 0;i < L.length;i++)
if(L.data[i] == e)
return i+1;
return 0;
}9.动态增长内存
void IncreaseSize(SqList *L,int len){
int *p = L->data;
L->data = (int *)malloc((L->MaxSize+len) * sizeof(int));
int i;
for(i= 0;i < L->length;i++)
L->data[i] = p[i];
L->MaxSize = L->MaxSize + len;
free(p);
}10.顺序表的重要操作全部代码
//代码中的ElemType使用时换成相应的元素类型
#include<stdio.h>
#define maxsize 10
#define FALSE 0
typedef struct{
int data[maxsize];
int length;
}SqList;//定义一个结构体，重命名为SqList
/*当传入函数的是指着类型的变量引用时使用->，如L->length
指针引用的好处是修改线性表以后，可以返回去修改后的结果
当传入的是非指针类型时直接使用.引用，如L.length*/
void InitList(SqList *L){//初始化一个线性表
int i;
for(i=0;i<maxsize;i++){
L->data[i]=0;
}
L->length=0;
}
int ListInsert(SqList *L,int i,int e){//插入
int j;//先查特殊情况
if(i<1||i>L->length+1){
return FALSE;
}
if(L->length>=maxsize){
return FALSE;
}
for(j=L->length;j>=i;j--){//从最后一个往前一次移动
L->data[j]=L->data[j-1];
}
L->data[i-1]=e;//第i个位置也就是数组里面的第i-1个
L->length++;
}
int ListDelete(SqList *L,int i,int *e){//删除操作
if(i<1||i>L->length){
return FALSE;
}
*e=L->data[i-1];
int j;
for(j=i;j<L->length;j++){//从第i个位置到最后依次向前移动
L->data[j-1]=L->data[j];
}
L->length--;
}
int LocateElem(SqList L,int e){//按值查找
int i;
for(i=0;i<L.length;i++){
if(L.data[i]==e){
return i+1;
}
}
return 0;
}
int GetElem(SqList L,int i){//按位查找
return L.data[i-1];
}
void print(SqList *L){//输出
int i;
for(i=0;i<L->length;i++){
printf("%d ",L->data[i]);
}
printf("\n");
}
int main(){
SqList L;
int e;
int a[]={1,2,3,4,5};
int i;
for(i=0;i<5;i++){
L.data[i]=a[i];
}
L.length=5;
//InitList(&L);//初始化一个顺序表
ListInsert(&L,5,3);//插入
printf("插入后的顺序表元素：");
print(&L);
ListDelete(&L,3,&e);//删除
printf("删除的元素为：%d\n",e);
printf("删除后的顺序表元素：");
print(&L);
printf("元素5的位置为：%d\n",LocateElem(L,5));//按值查找
printf("位置3的元素为：%d\n",GetElem(L,3));//按位查找
return 0;
}
单链表重点操作
1.头插法建立单链表
void CreateListF(LinkNode** L, ElemType a[], int n)
//头插法建立单链表
/*这里我们使用双指针的目的是为了修改指针指向的内容。
在函数中，我们需要修改L指向的地址，使其指向新创建的链表头节点。
如果只使用单指针传递，那么在函数内部修改L的值只会影响局部变量，不会影响到外部的指针。
因此，为了能够在函数内部修改外部指针的值，需要使用指向指针的指针，即双指针*/
{
LinkNode* s;
*L = (LinkNode*)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;//使用指针来传递链表头节点的地址
int i;
for (i = 0; i < n; i++)
{
s = (LinkNode*)malloc(sizeof(LinkNode)); //创建新结点s
s->data = a[i];
s->next = (*L)->next; //将结点s插在原开始结点之前,头结点之后
(*L)->next = s;
}
}2.尾插法建立单链表
void CreateListR(LinkNode** L, ElemType a[], int n)
//尾插法建立单链表
{
LinkNode* s, * r;
*L = (LinkNode*)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;
r = *L;
int i; //r始终指向终端结点,开始时指向头结点
for (i = 0; i < n; i++)
{
s = (LinkNode*)malloc(sizeof(LinkNode)); //创建新结点s
s->data = a[i];
r->next = s; //将结点s插入结点r之后
r = s;
}
r->next = NULL; //终端结点next域置为NULL
}3.初始化单链表
void InitList(LinkNode** L)
{
*L = (LinkNode*)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;
}4.销毁单链表
void DestroyList(LinkNode** L)
{
LinkNode* pre = *L, * p = pre->next;
while (p != NULL)
{
free(pre);
pre = p;
p = pre->next;
}
free(pre); //此时p为NULL,pre指向尾结点,释放它
}5.判断单链表是否为空
int ListEmpty(LinkNode* L)
{
if (L->next == NULL) {
return true;
}
return false;
}6.求单链表长度
int ListLength(LinkNode* L)
{
LinkNode* p = L; int i = 0;
while (p->next != NULL)
{
i++;
p = p->next;
}
return i;
}7.输出单链表
void printList(LinkNode* L)
{
LinkNode* p = L->next;
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}8.单链表按位查找
int GetElem(LinkNode* L, int i, ElemType* e)
{
int j = 0;
LinkNode* p = L;
if (i <= 0) return false; //i错误返回假
while (j < i && p != NULL)
{
j++;
p = p->next;
}
if (p == NULL) //不存在第i个数据结点
return false;
else //存在第i个数据结点
{
*e = p->data;
return true;
}
}9.单链表按值查找
int LocateElem(LinkNode* L, ElemType e)
{
LinkNode* p = L->next;
int n = 1;
while (p != NULL && p->data != e)
{
p = p->next;
n++;
}
if (p == NULL)
return false;
else
return n;
}10.单链表插入
int ListInsert(LinkNode* L, int i, ElemType e)
{
int j = 0;
LinkNode* p = L, * s;
if (i <= 0)
return false; //i错误返回假
while (j < i - 1 && p != NULL) //查找第i-1个结点p
{
j++;
p = p->next;
}
if (p == NULL) //未找到位序为i-1的结点
return false;
else //找到位序为i-1的结点*p
{
s = (LinkNode*)malloc(sizeof(LinkNode)); //创建新结点*s
s->data = e;
s->next = p->next; //将s结点插入到结点p之后
p->next = s;
return true;
}
}11.单链表删除
int ListDelete(LinkNode* L, int i, ElemType* e)
{
int j = 0;
LinkNode* p = L, * q;
if (i <= 0)
return false; //i错误返回假
while (j < i - 1 && p != NULL) //查找第i-1个结点
{
j++;
p = p->next;
}
if (p == NULL) //未找到位序为i-1的结点
return false;
else //找到位序为i-1的结点p
{
q = p->next; //q指向要删除的结点
if (q == NULL)
return false; //若不存在第i个结点,返回false
*e = q->data;
p->next = q->next; //从单链表中删除q结点
free(q); //释放q结点
return true;
}
}12.单链表的重要操作全部代码
#include <stdio.h>
#include <stdlib.h>
#define false 0
#define true 1
typedef int ElemType;
typedef struct LNode {
ElemType data;
struct LNode* next; //指向后继结点
} LinkNode; //声明单链表结点类型
void CreateListF(LinkNode** L, ElemType a[], int n)
//头插法建立单链表
/*这里我们使用双指针的目的是为了修改指针指向的内容。
在函数中，我们需要修改L指向的地址，使其指向新创建的链表头节点。
如果只使用单指针传递，那么在函数内部修改L的值只会影响局部变量，不会影响到外部的指针。
因此，为了能够在函数内部修改外部指针的值，需要使用指向指针的指针，即双指针*/
{
LinkNode* s;
*L = (LinkNode*)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;//使用指针来传递链表头节点的地址
int i;
for (i = 0; i < n; i++)
{
s = (LinkNode*)malloc(sizeof(LinkNode)); //创建新结点s
s->data = a[i];
s->next = (*L)->next; //将结点s插在原开始结点之前,头结点之后
(*L)->next = s;
}
}
void CreateListR(LinkNode** L, ElemType a[], int n)
//尾插法建立单链表
{
LinkNode* s, * r;
*L = (LinkNode*)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;
r = *L;
int i; //r始终指向终端结点,开始时指向头结点
for (i = 0; i < n; i++)
{
s = (LinkNode*)malloc(sizeof(LinkNode)); //创建新结点s
s->data = a[i];
r->next = s; //将结点s插入结点r之后
r = s;
}
r->next = NULL; //终端结点next域置为NULL
}
void InitList(LinkNode** L)
{
*L = (LinkNode*)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;
}
void DestroyList(LinkNode** L)
{
LinkNode* pre = *L, * p = pre->next;
while (p != NULL)
{
free(pre);
pre = p;
p = pre->next;
}
free(pre); //此时p为NULL,pre指向尾结点,释放它
}
int ListEmpty(LinkNode* L)
{
if (L->next == NULL) {
return true;
}
return false;
}
int ListLength(LinkNode* L)
{
LinkNode* p = L; int i = 0;
while (p->next != NULL)
{
i++;
p = p->next;
}
return i;
}
void printList(LinkNode* L)
{
LinkNode* p = L->next;
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
int GetElem(LinkNode* L, int i, ElemType* e)
{
int j = 0;
LinkNode* p = L;
if (i <= 0) return false; //i错误返回假
while (j < i && p != NULL)
{
j++;
p = p->next;
}
if (p == NULL) //不存在第i个数据结点
return false;
else //存在第i个数据结点
{
*e = p->data;
return true;
}
}
int LocateElem(LinkNode* L, ElemType e)
{
LinkNode* p = L->next;
int n = 1;
while (p != NULL && p->data != e)
{
p = p->next;
n++;
}
if (p == NULL)
return false;
else
return n;
}
int ListInsert(LinkNode* L, int i, ElemType e)
{
int j = 0;
LinkNode* p = L, * s;
if (i <= 0)
return false; //i错误返回假
while (j < i - 1 && p != NULL) //查找第i-1个结点p
{
j++;
p = p->next;
}
if (p == NULL) //未找到位序为i-1的结点
return false;
else //找到位序为i-1的结点*p
{
s = (LinkNode*)malloc(sizeof(LinkNode)); //创建新结点*s
s->data = e;
s->next = p->next; //将s结点插入到结点p之后
p->next = s;
return true;
}
}
int ListDelete(LinkNode* L, int i, ElemType* e)
{
int j = 0;
LinkNode* p = L, * q;
if (i <= 0)
return false; //i错误返回假
while (j < i - 1 && p != NULL) //查找第i-1个结点
{
j++;
p = p->next;
}
if (p == NULL) //未找到位序为i-1的结点
return false;
else //找到位序为i-1的结点p
{
q = p->next; //q指向要删除的结点
if (q == NULL)
return false; //若不存在第i个结点,返回false
*e = q->data;
p->next = q->next; //从单链表中删除q结点
free(q); //释放q结点
return true;
}
}
int main()
{
LinkNode* L;
ElemType e;
ElemType a[] = { 1,2,3,4 };
CreateListF(&L, a, 4); //尾插法建立链表
printf("尾插法所得顺序为: ");
printList(L);
DestroyList(&L);
CreateListR(&L, a, 4); //头插法建立链表
printf("头插法所得顺序为：");
printList(L);
printf("链表的长度为:%d\n", ListLength(L));
ListInsert(L, 4, 5); //在链表第四个元素前插入5
printf("插入一个元素后链表的元素为:");
printList(L);
ListDelete(L, 1, &e); //删除链表中第一个元素，并将它的值赋给e
printf("删除的元素为:%d\n", e);
printf("删除一个元素后链表的元素为:");
printList(L);
printf("当前链表是否为空:%d\n", ListEmpty(L));
GetElem(L, 1, &e);
printf("链表第一个元素为:%d\n", e);
printf("值为2的元素在链表中的位置为:%d\n", LocateElem(L, 2));
return 0;
}循环单链表重点操作
1.头插法建立循环单链表
void CreateListF(LinkNode **L, ElemType a[], int n)
//头插法建立循环单链表
{
LinkNode *s;
*L = (LinkNode *)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;
int i;
for (i = 0; i < n; i++)
{
s = (LinkNode *)malloc(sizeof(LinkNode));//创建新结点
s->data = a[i];
s->next = (*L)->next; //将结点s插在原开始结点之前,头结点之后
(*L)->next = s;
}
s = (*L)->next;
while (s->next != NULL) //查找尾结点,由s指向它
s = s->next;
s->next = *L; //尾结点next域指向头结点
}2.尾插法建立循环单链表
void CreateListR(LinkNode **L, ElemType a[], int n)
//尾插法建立循环单链表
{
LinkNode *s, *r;
*L = (LinkNode *)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;
r = *L; //r始终指向终端结点,开始时指向头结点
int i;
for (i = 0; i < n; i++)
{
s = (LinkNode *)malloc(sizeof(LinkNode));//创建新结点
s->data = a[i];
r->next = s; //将结点s插入结点r之后
r = s;
}
r->next = *L; //尾结点next域指向头结点
}3.初始化循环单链表
void InitList(LinkNode **L)
{
*L = (LinkNode *)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = *L;
}4.销毁循环单链表
void DestroyList(LinkNode **L)
{
LinkNode *p = *L, *q = p->next;
while (q != *L)
{
free(p);
p = q;
q = p->next;
}
free(p);
}5.循环单链表判空
int ListEmpty(LinkNode *L)
{
if(L->next==L){
return 1;
}
return 0;
}6.求循环单链表的长度
int ListLength(LinkNode *L)
{
LinkNode *p = L;
int i = 0;
while (p->next != L)
{
i++;
p = p->next;
}
return i;
}7.输出循环单链表
void DispList(LinkNode *L)
{
LinkNode *p = L->next;
while (p != L)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}8.循环单链表按位查找
int GetElem(LinkNode *L, int i, ElemType *e)
{
int j = 0;
LinkNode *p;
if (L->next != L) //单链表不为空表时
{
if (i == 1)
{
e = L->next->data;
return true;
}
else //i不为1时
{
p = L->next;
while (j < i - 1 && p != L)
{
j++;
p = p->next;
}
if (p == L)
return false;
else
{
e = p->data;
return true;
}
}
}
else //单链表为空表时
return false;
}9.循环单链表按值查找
int LocateElem(LinkNode *L, ElemType e)
{
LinkNode *p = L->next;
int n = 1;
while (p != L && p->data != e)
{
p = p->next;
n++;
}
if (p == L)
return 0;
else
return n;
}10.循环单链表插入
int ListInsert(LinkNode **L, int i, ElemType e)
{
int j = 0;
LinkNode *p = *L, *s;
if (p->next == *L || i == 1) //原单链表为空表或i==1时
{
s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点s
s->data = e;
s->next = p->next; //将结点s插入到结点p之后
p->next = s;
return true;
}
else
{
p = p->next;
while (j < i - 2 && p != *L)
{
j++;
p = p->next;
}
if (p == *L) //未找到第i-1个结点
return false;
else //找到第i-1个结点p
{
s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点s
s->data = e;
s->next = p->next; //将结点s插入到结点p之后
p->next = s;
return true;
}
}
}11.循环单链表删除
int ListDelete(LinkNode **L, int i, ElemType *e)
{
int j = 0;
LinkNode *p = *L, *q;
if (p->next != *L) //原单链表不为空表时
{
if (i == 1) //i==1时
{
q = p->next; //删除第1个结点
e = q->data;
p->next = q->next;
free(q);
return true;
}
else //i不为1时
{
p = p->next;
while (j < i - 2 && p != *L)
{
j++;
p = p->next;
}
if (p == *L) //未找到第i-1个结点
return false;
else //找到第i-1个结点p
{
q = p->next; //q指向要删除的结点
e = q->data;
p->next = q->next; //从单链表中删除q结点
free(q); //释放q结点
return true;
}
}
}
else return false;
}12.循环单链表的重点操作全部代码
#include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
typedef int ElemType;
typedef struct LNode //定义单链表结点类型
{
ElemType data;
struct LNode *next;
} LinkNode;
void CreateListF(LinkNode **L, ElemType a[], int n)
//头插法建立循环单链表
{
LinkNode *s;
*L = (LinkNode *)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;
int i;
for (i = 0; i < n; i++)
{
s = (LinkNode *)malloc(sizeof(LinkNode));//创建新结点
s->data = a[i];
s->next = (*L)->next; //将结点s插在原开始结点之前,头结点之后
(*L)->next = s;
}
s = (*L)->next;
while (s->next != NULL) //查找尾结点,由s指向它
s = s->next;
s->next = *L; //尾结点next域指向头结点
}
void CreateListR(LinkNode **L, ElemType a[], int n)
//尾插法建立循环单链表
{
LinkNode *s, *r;
*L = (LinkNode *)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = NULL;
r = *L; //r始终指向终端结点,开始时指向头结点
int i;
for (i = 0; i < n; i++)
{
s = (LinkNode *)malloc(sizeof(LinkNode));//创建新结点
s->data = a[i];
r->next = s; //将结点s插入结点r之后
r = s;
}
r->next = *L; //尾结点next域指向头结点
}
void InitList(LinkNode **L)
{
*L = (LinkNode *)malloc(sizeof(LinkNode)); //创建头结点
(*L)->next = *L;
}
void DestroyList(LinkNode **L)
{
LinkNode *p = *L, *q = p->next;
while (q != *L)
{
free(p);
p = q;
q = p->next;
}
free(p);
}
int ListEmpty(LinkNode *L)
{
if(L->next==L){
return 1;
}
return 0;
}
int ListLength(LinkNode *L)
{
LinkNode *p = L;
int i = 0;
while (p->next != L)
{
i++;
p = p->next;
}
return i;
}
void DispList(LinkNode *L)
{
LinkNode *p = L->next;
while (p != L)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
int GetElem(LinkNode *L, int i, ElemType *e)
{
int j = 0;
LinkNode *p;
if (L->next != L) //单链表不为空表时
{
if (i == 1)
{
e = L->next->data;
return true;
}
else //i不为1时
{
p = L->next;
while (j < i - 1 && p != L)
{
j++;
p = p->next;
}
if (p == L)
return false;
else
{
e = p->data;
return true;
}
}
}
else //单链表为空表时
return false;
}
int LocateElem(LinkNode *L, ElemType e)
{
LinkNode *p = L->next;
int n = 1;
while (p != L && p->data != e)
{
p = p->next;
n++;
}
if (p == L)
return 0;
else
return n;
}
int ListInsert(LinkNode **L, int i, ElemType e)
{
int j = 0;
LinkNode *p = *L, *s;
if (p->next == *L || i == 1) //原单链表为空表或i==1时
{
s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点s
s->data = e;
s->next = p->next; //将结点s插入到结点p之后
p->next = s;
return true;
}
else
{
p = p->next;
while (j < i - 2 && p != *L)
{
j++;
p = p->next;
}
if (p == *L) //未找到第i-1个结点
return false;
else //找到第i-1个结点p
{
s = (LinkNode *)malloc(sizeof(LinkNode)); //创建新结点s
s->data = e;
s->next = p->next; //将结点s插入到结点p之后
p->next = s;
return true;
}
}
}
int ListDelete(LinkNode **L, int i, ElemType *e)
{
int j = 0;
LinkNode *p = *L, *q;
if (p->next != *L) //原单链表不为空表时
{
if (i == 1) //i==1时
{
q = p->next; //删除第1个结点
e = q->data;
p->next = q->next;
free(q);
return true;
}
else //i不为1时
{
p = p->next;
while (j < i - 2 && p != *L)
{
j++;
p = p->next;
}
if (p == *L) //未找到第i-1个结点
return false;
else //找到第i-1个结点p
{
q = p->next; //q指向要删除的结点
e = q->data;
p->next = q->next; //从单链表中删除q结点
free(q); //释放q结点
return true;
}
}
}
else return false;
}
int main()
{
LinkNode *L;
ElemType e;
ElemType a[] = {1, 2, 3, 4};
CreateListF(&L, a, 4); //尾插法建立链表
printf("尾插法所得顺序为: ");
DispList(L);
DestroyList(&L);
CreateListR(&L, a, 4); //头插法建立链表
printf("头插法所得顺序为：");
DispList(L);
printf("链表的长度为:%d\n", ListLength(L));
ListInsert(&L, 4, 5); //在链表第四个元素前插入5
printf("插入一个元素后链表的元素为:");
DispList(L);
ListDelete(&L, 1, e); //删除链表中第一个元素，并将它的值赋给e
printf("删除的元素为:%d\n", e);
printf("删除一个元素后链表的元素为:");
DispList(L);
printf("当前链表是否为空:%d\n", ListEmpty(L));
GetElem(L, 1, e);
printf("链表第一个元素为:%d\n", e);
printf("值为2的元素在链表中的位置为:%d\n", LocateElem(L, 2));
return 0;
}双向链表重点操作
1.头插法建立双向链表
void CreateListF(DLinkNode **L, ElemType a[], int n)
//头插法建双链表
{
DLinkNode *s;
*L = (DLinkNode *)malloc(sizeof(DLinkNode)); //创建头结点
(*L)->prior = (*L)->next = NULL;
int i;
for (i = 0; i < n; i++)
{
s = (DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
s->data = a[i];
s->next = (*L)->next; //将结点s插在原开始结点之前,头结点之后
if ((*L)->next != NULL)
(*L)->next->prior = s;
(*L)->next = s;
s->prior = *L;
}
}2.尾插法建立双向链表
void CreateListR(DLinkNode **L, ElemType a[], int n)
//尾插法建双链表
{
DLinkNode *s, *r;
*L = (DLinkNode *)malloc(sizeof(DLinkNode)); //创建头结点
(*L)->prior = (*L)->next = NULL;
r = *L; //r始终指向终端结点,开始时指向头结点
int i;
for (i = 0; i < n; i++)
{
s = (DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
s->data = a[i];
r->next = s; s->prior = r; //将结点s插入结点r之后
r = s;
}
r->next = NULL; //尾结点next域置为NULL
}
3.初始化双向链表
void InitList(DLinkNode **L)
{
*L = (DLinkNode *)malloc(sizeof(DLinkNode)); //创建头结点
(*L)->prior = (*L)->next = NULL;
}4.销毁双向链表
void DestroyList(DLinkNode **L)
{
DLinkNode *pre = *L, *p = pre->next;
while (p != NULL)
{
free(pre);
pre = p;
p = pre->next;
}
free(pre);
}5.双向链表判空
int ListEmpty(DLinkNode *L)
{
if(L->next==NULL){
return 1;
}
return 0;
}6.求双向链表的长度
int ListLength(DLinkNode *L)
{
DLinkNode *p = L;
int i = 0;
while (p->next != NULL)
{
i++;
p = p->next;
}
return i;
}7.输出双向链表
void DispList(DLinkNode *L)
{
DLinkNode *p = L->next;
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}8.双向链表按位查找
int GetElem(DLinkNode *L, int i, ElemType *e)
{
int j = 0;
DLinkNode *p = L;
if (i <= 0)
return false; //i错误返回假
while (j < i && p != NULL)
{
j++;
p = p->next;
}
if (p == NULL)
return false;
else
{
e = p->data;
return true;
}
}
9.双向链表按值查找
int LocateElem(DLinkNode *L, ElemType e)
{
int n = 1;
DLinkNode *p = L->next;
while (p != NULL && p->data != e)
{
n++;
p = p->next;
}
if (p == NULL)
return(0);
else
return(n);
}10.双向链表插入
int ListInsert(DLinkNode **L, int i, ElemType e)
{
int j = 0;
DLinkNode *p = *L, *s;
if (i <= 0)
return false; //i错误返回假
while (j < i - 1 && p != NULL)
{
j++;
p = p->next;
}
if (p == NULL) //未找到第i-1个结点
return false;
else //找到第i-1个结点p
{
s = (DLinkNode *)malloc(sizeof(DLinkNode)); //创建新结点s
s->data = e;
s->next = p->next; //将结点s插入到结点p之后
if (p->next != NULL)
p->next->prior = s;
s->prior = p;
p->next = s;
return true;
}
}11.双向链表删除
int ListDelete(DLinkNode **L, int i, ElemType *e)
{
int j = 0;
DLinkNode *p = *L, *q;
if (i <= 0)
return false; //i错误返回假
while (j < i - 1 && p != NULL)
{
j++;
p = p->next;
}
if (p == NULL) //未找到第i-1个结点
return false;
else //找到第i-1个结点p
{
q = p->next; //q指向要删除的结点
if (q == NULL)
return false; //不存在第i个结点
e = q->data;
p->next = q->next; //从单链表中删除*q结点
if (p->next != NULL) p->next->prior = p;
free(q); //释放q结点
return true;
}
}12.双向链表的重要操作全部代码
#include <stdio.h>
#include <stdlib.h>
#define true 1
#define false 0
typedef int ElemType;
typedef struct DNode //定义双链表结点类型
{
ElemType data;
struct DNode *prior; //指向前驱结点
struct DNode *next; //指向后继结点
} DLinkNode;
void CreateListF(DLinkNode **L, ElemType a[], int n)
//头插法建双链表
{
DLinkNode *s;
*L = (DLinkNode *)malloc(sizeof(DLinkNode)); //创建头结点
(*L)->prior = (*L)->next = NULL;
int i;
for (i = 0; i < n; i++)
{
s = (DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
s->data = a[i];
s->next = (*L)->next; //将结点s插在原开始结点之前,头结点之后
if ((*L)->next != NULL)
(*L)->next->prior = s;
(*L)->next = s;
s->prior = *L;
}
}
void CreateListR(DLinkNode **L, ElemType a[], int n)
//尾插法建双链表
{
DLinkNode *s, *r;
*L = (DLinkNode *)malloc(sizeof(DLinkNode)); //创建头结点
(*L)->prior = (*L)->next = NULL;
r = *L; //r始终指向终端结点,开始时指向头结点
int i;
for (i = 0; i < n; i++)
{
s = (DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
s->data = a[i];
r->next = s; s->prior = r; //将结点s插入结点r之后
r = s;
}
r->next = NULL; //尾结点next域置为NULL
}
void InitList(DLinkNode **L)
{
*L = (DLinkNode *)malloc(sizeof(DLinkNode)); //创建头结点
(*L)->prior = (*L)->next = NULL;
}
void DestroyList(DLinkNode **L)
{
DLinkNode *pre = *L, *p = pre->next;
while (p != NULL)
{
free(pre);
pre = p;
p = pre->next;
}
free(pre);
}
int ListEmpty(DLinkNode *L)
{
if(L->next==NULL){
return 1;
}
return 0;
}
int ListLength(DLinkNode *L)
{
DLinkNode *p = L;
int i = 0;
while (p->next != NULL)
{
i++;
p = p->next;
}
return i;
}
void DispList(DLinkNode *L)
{
DLinkNode *p = L->next;
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
int GetElem(DLinkNode *L, int i, ElemType *e)
{
int j = 0;
DLinkNode *p = L;
if (i <= 0)
return false; //i错误返回假
while (j < i && p != NULL)
{
j++;
p = p->next;
}
if (p == NULL)
return false;
else
{
e = p->data;
return true;
}
}
int LocateElem(DLinkNode *L, ElemType e)
{
int n = 1;
DLinkNode *p = L->next;
while (p != NULL && p->data != e)
{
n++;
p = p->next;
}
if (p == NULL)
return(0);
else
return(n);
}
int ListInsert(DLinkNode **L, int i, ElemType e)
{
int j = 0;
DLinkNode *p = *L, *s;
if (i <= 0)
return false; //i错误返回假
while (j < i - 1 && p != NULL)
{
j++;
p = p->next;
}
if (p == NULL) //未找到第i-1个结点
return false;
else //找到第i-1个结点p
{
s = (DLinkNode *)malloc(sizeof(DLinkNode)); //创建新结点s
s->data = e;
s->next = p->next; //将结点s插入到结点p之后
if (p->next != NULL)
p->next->prior = s;
s->prior = p;
p->next = s;
return true;
}
}
int ListDelete(DLinkNode **L, int i, ElemType *e)
{
int j = 0;
DLinkNode *p = *L, *q;
if (i <= 0)
return false; //i错误返回假
while (j < i - 1 && p != NULL)
{
j++;
p = p->next;
}
if (p == NULL) //未找到第i-1个结点
return false;
else //找到第i-1个结点p
{
q = p->next; //q指向要删除的结点
if (q == NULL)
return false; //不存在第i个结点
e = q->data;
p->next = q->next; //从单链表中删除*q结点
if (p->next != NULL) p->next->prior = p;
free(q); //释放q结点
return true;
}
}
int main()
{
DLinkNode *L;
ElemType e;
ElemType a[] = {1, 2, 3, 4};
CreateListF(&L, a, 4); //尾插法建立链表
printf("尾插法所得顺序为: ");
DispList(L);
DestroyList(&L);
CreateListR(&L, a, 4); //头插法建立链表
printf("头插法所得顺序为：");
DispList(L);
printf("链表的长度为:%d\n", ListLength(L));
ListInsert(&L, 4, 5); //在链表第四个元素前插入5
printf("插入一个元素后链表的元素为:");
DispList(L);
ListDelete(&L, 1, e); //删除链表中第一个元素，并将它的值赋给e
printf("删除的元素为:%d\n", e);
printf("删除一个元素后链表的元素为:");
DispList(L);
printf("当前链表是否为空:%d\n", ListEmpty(L));
GetElem(L, 1, e);
printf("链表第一个元素为:%d\n", e);
printf("值为2的元素在链表中的位置为:%d\n", LocateElem(L, 2));
return 0;
}
扫一扫
366
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
