数据结构期末复习

数据结构

算法概念,及其特性;数据结构的基本术语

1. 算法是解决特定问题求解步骤的描述,在计算机中表现为指令的有限序列,并且每条指令表示一个或者多个操作
2. 算法的五大特性:输入,输出,有穷性,确定性,可行性
3. 数据结构的基本术语:
   1. 数据结构:相互之间存在一种或者多种特定关系的数据元素的集合
   2. 数据元素:一个数据元素可以由若干个数据项组成
   3. 数据项: 是数据不可分割的最小单元

顺序表,链表中各种情况下的插入,删除,访问操作的时间复杂度;执行插入,删除操作时,空和满的判断条件

操作	顺序表	链表
访问	O(1)	O(n)
插入	O(n)	O(n)
删除	O(n)	O(n)
查找(位置)(值)	O(n)	O(n)

注意特殊情况:

顺序表中:

1. 删除最后一个位置,以及在最后一个位置插入元素:==时间复杂度为O(1)==

链表中:

1. 在第一个位置插入,在第一个位置删除,查找第一个位置:时间复杂度为O(1)

---

2.执行插入,删除操作时候,空和满的判断条件:

---

顺序表(last为当前表的长度):

1. 为空的条件: last == 0
2. 满的条件: last == MAXSIZE

---

链表中:

case 1: 带头结点

 为空的条件: L->next ==NULL
 为满的条件:略

case 2: 不带头结点

	为空的条件: L == NULL
    为满的条件:略

在q结点后,执行插入和删除操作的语句

​ 1. 在头结点后插入新节点:

//L为头结点,p为工作指针,s为插入的新节点
s = (Node*)malloc(sizeof(Node));
s->next = L->next;
L->next = s;

2. 在头结点后删除结点:

//L为头结点,p为工作指针
p = L->next;
L ->next = L->next->next;
free(p);

3. 插入新节点:

//,s为插入的新节点
s = (Node*)malloc(sizeof(Node));
s->next = q->next;
q->next = s;

4.删除q结点后的结点:

//p为工作结点
p = q->next;
q->next = q->next->next;
free(p);

结论:

1. 顺序表中,在第i个位置插插入,平均移动n-i+1个元素(提示:i-1不动)
2. 顺序表中,在第i个位置删除,平均移动n-1个元素

栈.队列的操作基本特性,存储结构; 循环队列的出队,入队操作语句;栈和队列执行插入,删除的时间复杂度

1. 栈,队列的操作基本特性:

   栈:先进后出

   队列:先进先出

   ①顺序栈入栈操作:

   Status Push (SqStack *S,ElemType e){
   if(S->top == MAXSIZE-1) // 栈满了
   {
     return error;
   }
   S->top++;
   S->data[S->top] = x;
   return OK;
   }
   

   ②顺序栈出栈操作:

   Status Pop (SqStack *S,ElemType *e){
   if(S->top == -1) // 栈空了
   {
     return error;
   }
     *e = S->data[S->top];
   	S->top--;
   	
   	return OK;
   }
   

   ③链式栈入栈操作:

   Node *Push(Node* top,ElemType e){
     s = (Node*)malloc(sizeof(Node));
     if(s == NULL){
       printf("申请内存失败");
       exit(-1);
     }
     else{
       s->data = x;
       s->next = top;
       top = s;
       return top;
     }
   }
   

   ④链式栈出栈操作:

   Node *Pop(Node* top,ElemType *x){
       if(top == NULL){
       printf("栈空了");
         exit(-1);
     }
     else{
       *x = top->data;
       p = top;
       top = top->next;
      	free(p);
       return top;
     }
   }
   

2. 栈,队列的存储结构:

   都有顺序存储和链式存储

3. 循环队列的出队,入队操作语句:

​ ①出队操作:

Status enterQueue(SqQueue *Q ,ElemeType e)
{
  if((Q->rear+1)%MAXSIZE == Q->front)//队满了
  {
    return error;
  }
  Q->data[Q->rear] = e;
  Q->rear = (Q->rear+1)%MAXSIZE;
  return OK;
}

​ ②出队操作:

Status outQueue(SqQueue *Q ,ElemeType *e)
{
  if(Q->rear == Q->front)//队空了
  {
    return error;
  }
  *e=Q->data[Q->rear];
  Q->front = (Q->front+1)%MAXSIZE;
  return OK;
}

==注意:==元素个数为: (rear-front+MAXSIZE)%MAXSIZE

数组的按行优先、按列优先存储地址的计算，对称矩阵的压缩存储

1. 数组的按行、按列优先存储地址的计算（计算aij的存储地址）

   设：每一行有M个元素，每一列有N个元素

   第一种情况：

   

按行优先存储 ： Loc（aij） = (i-1)*N+(j-1)

按列优先存储： Loc（aij） = (j-1)*M+(i-1)

第二种情况：

按行优先存储 ： Loc（aij） = i*N+j

按列优先存储： Loc（aij） = j*M+i

2. 对称矩阵的压缩存储

解释：

①：要查找aij位置的元素的地址，其实就是第aij的下标：

​ 如果他在上三角矩阵(j>i)：j*(j-1)/2+(i-1)

​ 如果他在上三角矩阵(i<=j)：i*(i-1)/2+(j-1)