数据结构顺序表+链表基本操作部分代码

最新推荐文章于 2024-09-14 15:47:59 发布

自律天花板

最新推荐文章于 2024-09-14 15:47:59 发布

阅读量537

点赞数 8

文章标签：数据结构链表算法

本文链接：https://blog.csdn.net/weixin_64908198/article/details/140824982

版权

InitList(&L);//初始化表
DestoryList(&L);//销毁操作

ListInsert(&L, i, e);//插入操作
ListDelete(&L, i, &e)l//删除操作

LocateElem(L, e);//按值查找
GetElem(L, i);//按位查找

length(L);//表长
PrintList(L);//输出表元素
Empty();//判空操作

静态分配

#include<stdio.h>
#define Maxsize 10
typedef struct {
   ElemType data[Maxsize];
   int length;
}SeqList;
//初始化
void InitList(SqList& L) {
   for (int i = 0; i < MaxSize; i++)
       L.data[i] = 0;
   L.length = 0;
}
int main(){
   SeqList L;
   InitList(L);

return 0;
}

动态分配

#include<stdlib.h>
#define InitSize 10
typedef struct {
   int *data;
   int MaxSize;
   int length;
}SeqList;

void InitList(SeqList& L) {
   L.data = (int*)malloc(InitSize * sizeof(int));
   L.length = 0;
   L.MaxSize = InitSize;
}

void IncreaseSize(SeqList& L, int len) {
   int* p = L.data;
   L.data = (int*)malloc((InitSize + len) * sizeof(int));
   for (int i = 0; i < L.length; i++)
   {
       L.data[i] = p[i];
   }
   L.MaxSize = L.MaxSize + len;
   free(p);
}

int main() {
SeqList L;
InitList(L);

IncreaseSize(L, s);
return 0;
}

顺序表的基本操作

插入操作
#define MaxSize 10
typedef struct {
int data[MaxSize];
int length;
}SeqList;

bool ListInsert(SeqList& L, int i, int e) {
   if (i<i || i>L.length + 1)
       return false;
   if (L.length >= MaxSize)
       return false;
   for (int i = L.length; j >= i; j--)
       L.data[j] = L.data[j - 1];
   L.data[i - 1] = e;
   L.length++;
   return true;
}

删除操作
bool ListDelete(SeqList& L, int i, int& 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--;
   return true;
}

int main() {
SeqList L;
InitList(L);

   int e = -1;
   if (ListDelete(L, 3, e))
       printf("已删除第3个元素，删除元素值为%d\n", e);
   else
       printf("出错\n");
   return 0
}

查找操作
按位查找

#define MaxSize 10
typedef struct {
   ElemType data[MaxSize];
   //or ElmeType *data;
   int length;
}SeqList;

ElemType GetElem(SeqList L, int i) {
return L.data[i - 1];
}

按值查找
#define InitSize 10
typedef struct {
   ElemType* data;
   int MaxSize;
   int length;
}SeqList;

int LocateElem(SeqList L, ElemType e) {
   for (int i = 0; i < L.length; i++)
       if (L.data[i] == e)
           return i + 1;
   return 0;
}
*/

单链表基本操作

头插法
LinkList List_HeadInsert(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 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;
}
按序号查找结点(带头结点)
LNode* 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;
}
按值查找表结点
LNode* LocateElem(LinkList L, ElemType e) {
   LNode* p = L->next;
   while (p != NULL && p->data != e)
       p = p->next;
   return p;
}
插入结点操作
带头结点
bool LinkInsert(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 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 InsertPriorNode(LNode* p, ElemType e) {
   if (p == NULL)
       return true;
   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;
   //基本思想：仍然先在p后插入结点，然后交换值
}

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;
}
在第i个位置插入元素e
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 InsertPriorNode(p, e);
   or
       return InsertPriorNode(p, e);
}
删除结点操作
bool DeleteNode(LNode* p) {
   if (p == NULL)
       return false;
   LNode* q = p->next;
   p->data = p->next->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;
}

双链表基本操作

初始化
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;
}

void testDLinklist() {
   DLinklist L;
   InitDLinklist(L);
}
双链表后插
bool InsertNextDNode(DNode* p, DNode* s) {
   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结点的后继结点
bool DeleteNextDNode(DNode* p) {
   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)
       DeleteDNode(L);
   free(L);
   L = NULL;
}
双链表的遍历
//后向遍历
while (p != NULL) {
   p = p->next;
}

//前向遍历
while (p != NULL) {
p = p->prior;
}
//跳过头结点的前向遍历
while (p->prior != NULL) {
p = p->prior;
}*/

循环链表的基本操作

循环单链表

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;
}
bool Empty(LinkList L) {//判空
   if (L->next == L)
       return true;
   else
       return false;
}
bool isTail(LinkList L, LNode* p) {//判断尾结点
   if (p->next == L)
       return true;
   else
       return false;
}

循环双链表

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;
}

void testDLinklist() {
DLinklist L;
InitDLinklist(L);
}

bool Empty(DLinklist L) {
   if (L->next == L)
       return true;
   else
       return false;
}
bool isTail(DLinklist L, DNode* p) {//判断尾结点
   if (p->next == L)
       return true;
   else
       return false;
}
双链表的插入
bool InsertNextDNode(DNode* p, DNode* s) {
   s->next = p->next;
   p->next->prior = s;
   s->prior = p;
   p->next = s;
}
双链表删除
p->next = q->next;
q->next->prior = p;
free(q);