数据结构相关知识点整理

引用类型的参数传递：void fun(int &x) 实参到形参单向值传递，形参回传给实参，实参和形参同步发生改变
算法执行时间=算法所有原操作的执行次数（频度）之和T(n)*原操作所需时间

线性表

元素地址计算方法：LOC(ai)=LOC(a1)+(i-1)*L LOC(ai+1)=LOC(ai)+L

顺序表定义

typedef int elemType;
typedef struct
{
   
  elemType *elem;
  int length;
  int listSize;
}sqList;

求顺序表中指定位置元素的值

int getElem(sqList l, int i, elemType &e)
{
   
  if(i<1||i>l.length)
  return 0;
  e=l.elem[i-1];
  return e;
}

插入数据 T(n)=O(n)

int listInsert(sqList &l, elemType e, int i)
{
   
  int j;
  i--;
  for(j=l.length;j>i;j--)
  l.elem[j]=l.elem[j-1];
  l.elem[i]=e;
  l.length++;
  return 1;
}

删除数据 T(n)=O(n)

int listDelete(sqList &l,int i,elemType &e)
{
   
  int j;
  i--;
  e=l.elem[i];
  for(j=i;j<l.length;j++)
    l.elem[j]=l.elem[j+1];
  l.length--;
  return 1;
}

按值查找

int sqListLocate(sqList l,elemType x)
{
   
  int i=1;
  whilie(i<l.length&&l.elem[i-1]!=x)
  {
   
    i++;
  }
  if(i<=l.length) return i;
  return 0;
}

顺序表的逆置

void reverse(sqList &l)
{
   
 int i;
  for(i=0;i<l.length/2;i++)
  {
   
    swap(l.elem[i],l.elem[l.length-1-i]);
  }
}

有序顺序表的合并 时间复杂度：O(La.length+Lb.length)

void mergeList(sqList la,sqList lb,sqList &lc)
{
   
  int i=0,j=0,k=0;
  initList(lc);
  while(i < la.length && j < lb.length)
  {
   
    if(la.elem[i]<lb.elem[j])
    lc.elem[k++]=la.elem[i];
    else lc.elem[k++]=lb.elem[i];
    while(i<la.length) lc.elem[k++]=la.elem[i++];
    while(j<lb.length) lc.elem[k++]=lb.elem[j++];
    lc.length=k;
  }
}

有序顺序表的并集

if(la.elem[i]==lb.elem[j])
  {
   
    lc.elem[k++]=la.elem[i++];
    j++;
  }

有序顺序表的交集

 if(la.elem[i]==lb.elem[j])
lc.elem[k++]=la.elem[i++];
else if(la.elem[i]<lb.elem[j])
i++;
else j++;

链表

单链表存储类型声明:

typedef struct lNode
{
   
  elemType data;
  struct lNode *next;
}linkList;

单链表结点的类型定义

typedef int elemType;
typedef struct node{
   
  elemType data;
  struct node*next;
}lNode,*linkList;
linkList h,p;

(*p): p指向的结点
指针变量使用之前要分配内存空间

p=(linkList)malloc(sizeof(lNode));
h=null

带头结点的单链表初