顺序表函数库的建立

一、函数库

#include <iostream>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

#define TRUE           1
#define FALSE          0
#define OK             1
#define ERROR          0
#define INFEASIBLE    -1
#define OVERFLOW      -2

#define LIST_INIT_SIZE 100
#define LISTINCREMENT  10

typedef int Status;
typedef int ElemType;

typedef struct {
    ElemType *elem;    //存储空间的首地址
    int length;       //表长
    int listsize;    //表容量 
}SqList;

Status InitList_Sq(SqList &L){ //构造一个空的顺序表L，对它进行初始化
      L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
      if(!L.elem) exit(OVERFLOW);
      L.listsize = LIST_INIT_SIZE;
      L.length = 0;
      return OK;
}

void DestroyList_Sq(SqList &L){ //销毁顺序表L //?
       free(L.elem);
       L.length = 0;
       L.listsize = LIST_INIT_SIZE;
}

void ClearList_Sq(SqList &L){     //清空顺序表L //?
       L.length = 0;
} 

Status ListEmpty_Sq(SqList L){     //判断顺序表L是否为空  //?
      if(L.length == 0)  return TRUE;
      else  return FALSE;
}

int ListLength_Sq(SqList L){    // 判断顺序表L的表长
      return L.length;
}

Status GetElem_Sq(SqList L, int pos, ElemType &e){ //获取指定位置的元素（位置从1开始）
       if(pos < 1 || pos > L.length) return ERROR;
       e = L.elem[pos - 1];
       return OK;
}

int LocateElem_Sq(SqList L, ElemType e, Status(*compare)(ElemType, ElemType)){  // 定位顺序表L中第一个与数值e满足关系compare（）的元素的位置，若不存在，则返回0
    ElemType *p = L.elem;                                                
    int pos = 1;
    while(pos <= L.length && !compare(e, *p)){
        ++p;
        ++pos;
    }
    if(pos > L.length) return 0;
    return pos; 
}
//  重点：函数作为参数  实参作为函数名，形参是一个指针类型的变量，它的基类型为函数原型
Status equal(ElemType e1, ElemType e2){
     if(e1 == e2) return TRUE;
     else return FALSE;
}
// void main(){
//     SqList L;
//     InitList_Sq(L);
//     //......Insert(); //插入元素
//     printf("%d", LocateElem_L(L, 3, equal));
// }

Status PriorElem_Sq(SqList &L, ElemType cur_e, ElemType &pre_e){
        int pos = LocateElem_Sq(L, cur_e, equal);
        if(pos == 1) return ERROR;
        pre_e = L.elem[pos - 2];
        return OK;
}

Status NextElem_Sq(SqList &L, ElemType cur_e, ElemType &next_e){
        int pos = LocateElem_Sq(L, cur_e, equal);
        if(pos == L.length) return ERROR;
        next_e = L.elem[pos];
        return OK;
}

Status ListInsert_Sq(SqList &L, int pos, ElemType e){
    if(pos < 1 || pos > L.length + 1) return ERROR;
    if(L.length >= L.listsize){
        L.elem = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if(!L.elem) exit(OVERFLOW);
        L.listsize += LISTINCREMENT;
    }
    for(ElemType *p = L.elem + L.length - 1; p >= L.elem + pos - 1; --p){
        *(p + 1) = *p;
    }
    ElemType *p = L.elem + pos - 1;
    *p = e;
    ++ L.length;
    return OK;
}

Status ListDelete_Sq(SqList &L, int pos, ElemType &e){
    if(pos < 1 || pos > L.length) return ERROR;
    ElemType *p = L.elem + pos - 1;
    e = *p;
    for(ElemType *p = L.elem + pos; p < L.elem + L.length; ++p){
        *(p - 1) = *p;
    }
    -- L.length;
    return OK;
}

void ListTraverse_Sq(SqList L){  // 此函数只适用于基础数据类型的输出
      for(ElemType *p = L.elem; p < L.elem + L.length; ++p){
         if(p == L.elem) printf("%d", *p);
         else printf(" %d", *p);
      }
}

void ListReverse_Sq(SqList &L){
     int len = L.length;
     for(int i = 0; i < len / 2; ++ i){
        ElemType t = L.elem[i];
        L.elem[i] = L.elem[len - 1 - i];
        L.elem[len - 1 - i] = t;
     }   
}

//拓展部分

Status ListInsert_SortedSq(SqList &L, ElemType e){ // 有序顺序表的插入（PTA作业3 6-2）
    ElemType *p = L.elem, *p_last = L.elem + L.length - 1;
    int pos = 1,len = L.length;
    if(L.length == 0){
       ListInsert_Sq(L, 1, e);
    }else{

        while(p <= p_last && *p <= e){
            ++p;
            ++pos;
        }
        ListInsert_Sq(L, pos, e);
    }
    return OK;
}

Status ConditionalListDelete_Sq(SqList &L, ElemType min, ElemType max){ // 适用于一次性删除多个元素   特点：可以在一次遍历的过程中完成所有指定删除操作
    ElemType *p = L.elem, *p_last = L.elem + L.length - 1;
    int count = 0;
    while(p <= p_last){
        if(*p > min && *p < max){
           ++ count;
        }else{
            *(p - count) = *p;
        }
        ++ p;
    }
    return OK; 
}

void Union_Sq(SqList &La, SqList Lb){   // 集合操作  A U B
    ElemType e;
    int La_Len = La.length, Lb_Len = Lb.length;
    for(int i = 0; i < Lb_Len; i++){
         GetElem_Sq(Lb, i + 1, e);
         if(!LocateElem_Sq(La, e, equal)){
            ListInsert_Sq(La, La_Len, e);
            ++ La_Len;
         }
    }
}

void MergeList1_SortedSq(SqList La, SqList Lb, SqList &Lc){  // 调用自写基础函数实现版  可含重复元素
    int La_Length = La.length, Lb_Length = Lb.length;
    ElemType a, b;
    InitList_Sq(Lc);
    int i = 1, j = 1, k = 1;
    while(i <= La_Length && j <= Lb_Length){
        GetElem_Sq(La, i, a), GetElem_Sq(Lb, j, b);
        if(a < b){
            ListInsert_Sq(Lc, ++ k, a);
            ++ i;
        }else{
            ListInsert_Sq(Lc, ++ k, b);
            ++ j;
        }
    }
    while(i <= La_Length){
        GetElem_Sq(La, ++ i, a);
        ListInsert_Sq(Lc, ++ k, a);
    }
    while(j <= Lb_Length){
        GetElem_Sq(Lb, ++ j, b);
        ListInsert_Sq(Lc, ++ k, b);
    }
}

void MergeList2_SortedSq(SqList La, SqList Lb, SqList &Lc){  // 自己实现版  可含重复元素
    InitList_Sq(Lc);
    ElemType *pa = La.elem, *pb = Lb.elem, *pc = Lc.elem;
    ElemType *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;
           ++ pa;
           ++ pc;
        }else{
            *pc = *pb;
            ++ pb;
            ++ pc;
        }
    }
    while(pa <= pa_last){
        *pc = *pa;
        ++ pa;
        ++ pc;
    }
    while(pb <= pb_last){
        *pc = *pb;
        ++ pb;
        ++ pc;
    }
}

void Sub_SortedSq(SqList &La, SqList Lb){ // A - B
    ElemType *pa = La.elem, *pa_last = La.elem + La.length - 1, *pb = Lb.elem, *pb_last = Lb.elem + Lb.length - 1;
    int pos = 1;
    while(pa <= pa_last){
        if(*pa < *pb) {
           ++ pa;
           ++ pos;
        }
        else if(*pa == *pb) {
           ListDelete_Sq(La, pos, *pa);
           ++ pb;
        }else{
           ++ pb;
        }
    }
    if(La.length == 0) printf("0");
    ListTraverse_Sq(La);
}

// 复现函数库出现的错误
// 1.开辟空间和空间扩容时没有强制类型转换
// 2.扩容时空间首地址写错（错写为结构体L）

二、利用函数库解决的问题

1. 最长连续递增子序列（未完待续）

给定一个顺序存储的线性表，请设计一个算法查找该线性表中最长的连续递增子序列。例如，(1,9,2,5,7,3,4,6,8,0)中最长的递增子序列为(3,4,6,8)。

输入第1行给出正整数n（≤105）；第2行给出n个整数，其间以空格分隔。

在一行中输出第一次出现的最长连续递增子序列，数字之间用空格分隔，序列结尾不能有多余空格。

输入样例：

15
1 9 2 5 7 3 4 6 8 0 11 15 17 17 10

输出样例： 

3 4 6 8

#include <iostream>
#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

#define  TRUE            1
#define  FALSE           0
#define  OK              1
#define  ERROR           0
#define  INFEASIBLE     -1
#define  OVERFLOW       -2

#define LIST_INIT_SIZE   100
#define LISTINCREMENT    10

typedef int ElemType;
typedef int Status;

typedef struct {
    ElemType *elem;
    int length;
    int listsize;
}SqList;

typedef struct {
    int begin;
    int end;
    int maxl;
}CIS;

Status InitList_Sq(SqList &L){ //构造一个空的顺序表L，对它进行初始化
      L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
      if(!L.elem) exit(OVERFLOW);
      L.listsize = LIST_INIT_SIZE;
      L.length = 0;
      return OK;
}

Status ListInsert_Sq(SqList &L, int pos, ElemType e){
    if(pos < 1 || pos > L.length + 1) return ERROR;
    if(L.length >= L.listsize){
        L.elem = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if(!L.elem) exit(OVERFLOW);
        L.listsize += LISTINCREMENT;
    }
    for(ElemType *p = L.elem + L.length - 1; p >= L.elem + pos - 1; --p){
        *(p + 1) = *p;
    }
    ElemType *p = L.elem + pos - 1;
    *p = e;
    ++ L.length;
    return OK;
}

int main(){
    int n;
    cin >> n;
    SqList L;
    CIS l;
    InitList_Sq(L);
    for(int i = 1; i <= n; ++i){
        ElemType e;
        scanf("%d", &e);
        ListInsert_Sq(L, i, e);
    }
    l.begin = 0;
    l.end = 0;
    l.maxl = 1;
    int begin_i = 0, end_j = 0;
    while(end_j < L.length - 1){
        if(L.elem[end_j + 1] > L.elem[end_j]){
            ++ end_j;
        }
        else{
            begin_i = end_j + 1;
            end_j = begin_i;
        }
        int maxll = end_j - begin_i + 1;
        if(maxll > l.maxl) {
           l.maxl = maxll;
           l.begin = begin_i;
           l.end = end_j;
        }
    }
    for(int i = l.begin; i <= l.end; ++i){
        if(i == l.begin) printf("%d", L.elem[i]);
        else printf(" %d", L.elem[i]);
    }
    return 0;
}