数据结构基础

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

2. 线性表部分操作

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

#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. 单链表的存储结构

1 2 3 4 5 6 7

typedef  struct  Node {      ElemType data;      struct  Node *next; }Node; typedef  struct  Node *LinkList;

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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. 单链表插入节点

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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. 单链表删除节点

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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. 顺序栈的构造 入栈出栈 及两栈共享空间

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

#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. 链栈的构造 入栈和出栈

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

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