数据结构系列文章（二）：顺序表

顺序表的抽象数据类型与基本操作

顺序表的数据结构定义

#include <iostream>
using namespace std;
const int list_init_size = 20;
const int list_inc = 10;
typedef int list_elem_type;
struct seq_list
{
    list_elem_type * elem;       // 动态数组就是一个指针
    int list_length, list_size;
};

构造一个顺序表相当于建立一个数组，由于这个数组所需的内存空间是未知的，因此数组长度无法固定下来，因此可以利用一个动态数组或者vector<type_elem>。在常量定义时，需要分配顺序表的初始内存空间以及内存增量步长，以防止初始内存空间不足。对于顺序表，需要定义分配的内存空间数目(list_size)和表的长度(list_length)，也就是元素个数。

算法1：顺序表的初始化操作，构造空顺序表

bool seq_list_init(seq_list &L)
{
    L.elem = new list_elem_type[list_init_size];
    if(! L.elem)     
    	return false;
    L.lsit_length = 0;
    L.list_size = list_init_size;
    return true;
}

算法2：创建顺序表，并存入若干元素

bool seq_list_create(seq_list &L, int n, list_elem_type a[])    // 在原有的基础上扩充表的存储空间
{
    L.elem = new list_elem_type[n + list_init_size];
    if(! L.elem)    
    	return false;
    for(int i=0; i<n; i++)      
    	L.elem[i] = a[i];
    L.list_length = n;
    L.lsit_size = n + list_init_size;
    return true;
}

算法3：顺序表的插入元素操作，并保持其他元素的相对次序不变

bool seq_list_insert(seq_list &L, int n, list_elem_type a)
{
    if(n<1 || n>L.length+1)     
    	return false;
    for(int i=L.list_length; i>n; i--)      
    	L.elem[i+1] = L.elem[i];
    L.elem[n-1] = a;
    L.list_length ++;
    return true;
}

算法4：顺序表的删除元素操作，并返回该元素

bool seq_list_delete(seq_list &L, int n, list_elem_type &a)
{
    if(n<1 || n>L.list_length)      
    	return false;
    a = L.elem[n-1];
    for(int i=n-1; i<L.list_length-1; i++)    
    	L.elemn[i] = L.elem[i+1];
    L.list_length --;
    return true;
}

算法5：顺序表的遍历操作

void visit(list_elem_type a)
{   
	cout<<a<<endl;  
}
void seq_list_traverse(seq_list L, void visit(list_elem_type))
{
    for (int i=0; i<L.list_length; i++)
    {
        visit(L.elem[i]);
    }
}

算法6：在递增有序表中插入元素，并保持顺序表的有序性

void seq_list_insert(seq_list &L, list_elem_type a)
{
    int i = 0;
    while(L.elem[i]<a && i<=L.list_length-1)      
    	i++;
    seq_list_insert(L, i+1, a);
}

算法7：顺序表的元素逆置操作

void seq_list_inverse(seq_list &L)
{
    seq_list L0;
    for(int i=0; i<L.list_length; i++)      
    	L0.elem[i] = L.elem[i+L.list_length];
    L = L0;
}

算法8：顺序表的查找操作，若存在，则返回其位序

bool seq_list_exist(seq_list &L, list_elem_type a)
{
    for(int i=0; i<L.list_length; i++)
    {
        if(L.elem[i]==a)    
        	return true;
    }
    return false;
}
int seq_list_search(seq_list &L, list_elem_type a)
{
    if(seq_list_exit(L, a))
    {
        int i = 0;
        while(L.elem[i]!=a && i<L.list_length)     
        	i++;
        return i;
    }
    else    
    	return 0;
}

算法9：按照字典序比较两个顺序表的大小

char seq_list_compare(seq_list La, seq_list Lb)
{
    for(int i=0; i<La.list_length && i<Lb.list_length; i++)
    {
        if(La.elem[i] > Lb.elem[i])     return '>';
        if(La.elem[i] < Lb.elem[i])     return '<';
    }
    if(La.list_length == Lb.list_length)    return '=';
    else if(La.list_length > Lb.list_length)    return '>';
    else return '<';
}

算法10：求两个集合的并集

void seq_list_union(seq_list &La, seq_list Lb)
{
    for(int i=0; i<Lb.list_length; i++)
    {
        elem = Lb.elem[i];
        if(seq_list_search(La, elem)==0)    
        	seq_list_insert(La, elem);
    }
}

算法11：归并非递减顺序表

算法12：作业题2.09

题目描述：删除顺序表中大于x的元素。例如，线性表$L=(3,7,1,5,9,6,4),x=5$。执行算法后， $L=(3,1,5,4)$。

算法设计：双指针法

void seq_list_del_above(seq_list &L, list_elem_type a)
{
    int i, j;
    for(i=0, j=0; i<L.list_length; i++)
    {
        if(L.elem[i]<=a)
        {
            L.elem[j] = L.elem[i];
            j++;
        }
    }
    L.list_length = j;
}