数据结构基础

来源：互联网发布：nginx 默认404页面编辑：程序博客网时间：2024/06/06 00:09

1. 线性表存取效率为O(1)

2. 线性表部分操作

#define OK 1

#define ERROR 0

#define TRUE 1

#define FALSE 0

typedef int Status;

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;

}

Status ListInsert(SqList *L, int i, ElemType e)

{

if (L->length == MAXSIZE) //顺序线性表已满

return ERROR;

if (i<1 || i>L->length + 1) //插入位置不合理因为是插入所以i可以等于length+1即插入到表最末位

return ERROR;

if (i <= L->lenth) //若插入位置不在表尾即i不等于length+1的情况

{

for (int k = L->length - 1; k > i; k--) //将第i+1到第length-1个元素分别往后移动一位

{

L->data[k + 1] = L->data[k];

}

L->data[i-1] = e; //插入新元素

L->length++;

return OK;

}

Status ListDelete(SqList* L, int i, ElemType e)

{

if (L->length == 0) //顺序线性表为空

return ERROR;

if (i<1 || i>L->length) //删除位置不正确

return ERROR;

*e = L->data[i - 1];

if (i < L->lenth) //如果删除不是最后位置

{

for (int k = i; k < L->length; k++) //将删除位置后继元素前移

L->data[k-1] = L->data[k];

}

L->length--;

}

3. 线性表存、读数据时时间复杂度O(1)；插入或删除是时间复杂度为O(n).

1. 单链表的存储结构

typedef struct Node

{

ElemType data;

struct Node *next;

}Node;

typedef struct Node *LinkList;

2. 单链表访问第i个节点

Status GetElem(LinkList L, int i, ElemType *e)

{

LinkList p;

p = L->next;

while (p || j < i)

{

p = p->next;

j++;

}

if (!p && j>i)

return ERROR;

*e = p->data;

return OK;

}

由于单链表的结构中没有定义表厂，所以事先不知道要循环多少次，因此通常用while而不是for来控制循环

3. 单链表插入节点

Status ListInsert(LinkList L, int i, ElemType e)

{

LinkList *p, *s;

p = L->next;

int j = 1;

while (p || j < i)

{

p = p->next;

j++;

}

if (!p || j>i)

return ERROR;

s = (LinkList)malloc(sizeof(Node));

s->data = e;

s->next = p->next;

p->next = s;

}

4. 单链表删除节点

Status ListDel(LinkNode *L, int n)

{

LinkNode *p = L->pNext;

int j = 0;

while (!p && j < n)

{

p = p->pNext;

j++;

}

if (!p)

return ERROR;

LinkNode *q = p->pNext;

p->pNext = q->pNext;

delete[] q;

return OK;

}

1. 顺序栈的构造入栈出栈及两栈共享空间

#define MAXSIZE 100

typedef int SElemType;

typedef struct

{

SElemType data[MAXSIZE];

int top;

}SqStack;

int Push(SqStack *S, SElemType e)

{

if(S->top == MAXSIZE-1)

return -1;

S->top++;

S->data[S->top]=e;

return 0;

}

int Pop(SqStack *S)

{

if(S->top == -1)

return -1;

S->top--;

return 0;

}

typedef struct

{

SElemType data[MAXSIZE];

int top1;

int top2;

}SqDoubleStack;

int Push2(SqDoubleStack *S,SElemType e,int stackNumber)

{

if(S->top1+1 == S->top2)

return -1;

if(stackNumber == 1)

{

S->top1++;

S->data[top1] = e;

}

if(stackNumber == 2)

{

S->top2--;

S->data[top2] = e;

}

return 0;

}

int Pop2(SqDoubleStack *S,int stackNumber)

{

if(stackNumber == 1)

{

if(S->top1 == -1)

return -1;

S->top1--;

}

else if(stackNumber == 2)

{

if(S->top2 == MAXSIZE)

return -1;

S->top2++;

}

return 0;

}

2. 链栈的构造入栈和出栈

#define MAXSIZE 100

typedef int SElemType;

typedef struct StackNode

{

SElemType data;

struct StackNode *next;

}StackNode,*LinkStackPtr;

typedef struct LinkStack

{

LinkStackPtr top;

int count;

}LinkStack;

int Push(LinkStack *L,SElemType e)

{

LinkStackPtr p = (LinkStackPtr)malloc(sizeof(StackNode));

p->data = e;

p->next = L->top;

L->top = p;

L->count++;

return 0;

}

int Pop(LinkStack *L,SElemType *e)

{

LinkStackPtr p = NULL;

if(StackEmpty(L))

return -1;

*e = L->top->data;

p = L->top;

L->top = L->top->next;

free(p);

L->count--;

return 0;

如果栈的使用过程中元素变化不可预料，有时很小有时很大，最好用链栈；反之，如果它的变化在可控范围内，建议用顺序栈。

3. 队列：插入数据只能在队尾进行，删除数据只能在对头进行。

front指针指向对头元素，rear指针指向队尾元素的下一位置。当front == rear时说明队列为空。

4. 循环队列满的条件是(rear+1)%QueueSize == front;

通用的计算队列长度公式：(rear-front+QueueSize)%QueueSize;

0 0