数据结构常用算法

void Union(List &La, List Lb) {  // 算法2.1

  // 将所有在线性表Lb中但不在La中的数据元素插入到La中

  int La_len,Lb_len,i;

  ElemType e;

  La_len = ListLength(La);          // 求线性表的长度 

  Lb_len = ListLength(Lb);

  for (i=1; i<=Lb_len; i++) {

    GetElem(Lb, i, e);              // 取Lb中第i个数据元素赋给e

    if (!LocateElem(La, e, equal))  // La中不存在和e相同的数据元素

      ListInsert(La, ++La_len, e);  // 插入

  }

} // union

void MergeList(List La, List Lb, List &Lc) {  // 算法2.2

  // 已知线性表La和Lb中的元素按值非递减排列。

  // 归并La和Lb得到新的线性表Lc，Lc的元素也按值非递减排列。

  int La_len, Lb_len;

  ElemType ai, bj; 

  int i=1, j=1, k=0;

  InitList(Lc);

  La_len = ListLength(La);   

  Lb_len = ListLength(Lb);

  while ((i <= La_len) && (j <= Lb_len)) {  // La和Lb均非空

    GetElem(La, i, ai);

    GetElem(Lb, j, bj);

    if (ai <= bj) {

      ListInsert(Lc, ++k, ai);

      ++i;

    } else {

      ListInsert(Lc, ++k, bj);

      ++j;

    }

  }

  while (i <= La_len) {

    GetElem(La, i++, ai);  ListInsert(Lc, ++k, ai);

  }

  while (j <= Lb_len) {

    GetElem(Lb, j++, bj);  ListInsert(Lc, ++k, bj);

  }

} // MergeList

Status InitList_Sq(SqList &L) {  // 算法2.3

  // 构造一个空的线性表L。

  L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));

  if (!L.elem) return OK;        // 存储分配失败

  L.length = 0;                  // 空表长度为0

  L.listsize = LIST_INIT_SIZE;   // 初始存储容量

  return OK;

} // InitList_Sq

Status ListInsert_Sq(SqList &L, int i, ElemType e) {  // 算法2.4

  // 在顺序线性表L的第i个元素之前插入新的元素e，

  // i的合法值为1≤i≤ListLength_Sq(L)+1

  ElemType *p;

  if (i < 1 || i > L.length+1) return ERROR;  // i值不合法

  if (L.length >= L.listsize) {   // 当前存储空间已满，增加容量

    ElemType *newbase = (ElemType *)realloc(L.elem,

                  (L.listsize+LISTINCREMENT)*sizeof (ElemType));

    if (!newbase) return ERROR;   // 存储分配失败

    L.elem = newbase;             // 新基址

    L.listsize += LISTINCREMENT;  // 增加存储容量

  }

  ElemType *q = &(L.elem[i-1]);   // q为插入位置

  for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p;

                                  // 插入位置及之后的元素右移

  *q = e;       // 插入e

  ++L.length;   // 表长增1

  return OK;

} // ListInsert_Sq

Status ListDelete_Sq(SqList &L, int i, ElemType &e) {  // 算法2.5

  // 在顺序线性表L中删除第i个元素，并用e返回其值。

  // i的合法值为1≤i≤ListLength_Sq(L)。

  ElemType *p, *q;

  if (i<1 || i>L.length) return ERROR;  // i值不合法

  p = &(L.elem[i-1]);                   // p为被删除元素的位置

  e = *p;                               // 被删除元素的值赋给e

  q = L.elem+L.length-1;                // 表尾元素的位置

  for (++p; p<=q; ++p) *(p-1) = *p;     // 被删除元素之后的元素左移

  --L.length;                           // 表长减1

  return OK;

} // ListDelete_Sq

int LocateElem_Sq(SqList L, ElemType e,

        Status (*compare)(ElemType, ElemType)) {  // 算法2.6

  // 在顺序线性表L中查找第1个值与e满足compare()的元素的位序。

  // 若找到，则返回其在L中的位序，否则返回0。

  int i;

  ElemType *p;

  i = 1;        // i的初值为第1个元素的位序

  p = L.elem;   // p的初值为第1个元素的存储位置

  while (i <= L.length && !(*compare)(*p++, e))

    ++i;

  if (i <= L.length) return i;

  else return 0;

} // LocateElem_Sq

void MergeList_Sq(SqList La, SqList Lb, SqList &Lc) {  // 算法2.7

  // 已知顺序线性表La和Lb的元素按值非递减排列。

  // 归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列。

  ElemType *pa,*pb,*pc,*pa_last,*pb_last;

  pa = La.elem;  pb = Lb.elem;

  Lc.listsize = Lc.length = La.length+Lb.length;

  pc = Lc.elem = (ElemType *)malloc(Lc.listsize*sizeof(ElemType));

  if (!Lc.elem)

    exit(OVERFLOW);   // 存储分配失败

  pa_last = La.elem+La.length-1;

  pb_last = Lb.elem+Lb.length-1;

  while (pa <= pa_last && pb <= pb_last) {  // 归并

    if (*pa <= *pb) *pc++ = *pa++;

    else *pc++ = *pb++;

  }

  while (pa <= pa_last) *pc++ = *pa++;      // 插入La的剩余元素

  while (pb <= pb_last) *pc++ = *pb++;      // 插入Lb的剩余元素

} // MergeList

Status GetElem_L(LinkList &L,int i, ElemType &e) {// 算法2.8

// L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR

LinkList p;

p = L->next;int j = 1;// 初始化，p指向第一个结点，j为计数器

while (p && j<i) {// 顺指针向后查找，直到p指向第i个元素或p为空

p = p->next;++j;

}

if ( !p || j>i ) return ERROR;// 第i个元素不存在

e = p->data;// 取第i个元素

return OK;} // GetElem_L

Status ListInsert_L(LinkList &L, int i, ElemType e) {// 算法2.9

// 在带头结点的单链线性表L的第i个元素之前插入元素e

LinkList p,s;

p = L;

int j = 0;

while (p && j < i-1) {// 寻找第i-1个结点

p = p->next;

++j;

}

if (!p || j > i-1) return ERROR;// i小于1或者大于表长

s = (LinkList)malloc(sizeof(LNode));// 生成新结点

s->data = e;s->next = p->next;// 插入L中

p->next = s;

return OK;

} // LinstInsert_L

Status ListDelete_L(LinkList &L, int i, ElemType &e) {// 算法2.10

// 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值

LinkList p,q;

p = L;int j = 0;

while (p->next && j < i-1) {// 寻找第i个结点，并令p指向其前趋

p = p->next;++j;

}

if (!(p->next) || j > i-1) return ERROR;// 删除位置不合理

q = p->next;

p->next = q->next;// 删除并释放结点

e = q->data;

free(q);

return OK;

} // ListDelete_L