一：线性表：顺序表之数组和指针的初始化操作

新的问题：

1：首先是 对于 n==0 时 的空表的创建问题；
2：node 位序是 从1 开始的；即元素位置；
3：下面是结构体的问题与知识问题：

首先是结构体的定义：
struct 结构体名字 {  成员  };
总结1：定义结构体时关键字是struct，不可省略
总结2：创建结构体变量时，关键字struct可以省略
总结3：结构体变量使用操作符"."访问成员

首先是一些常量的定义：

对于一些常量的定义，可以到函数使用时，返回值可以用设定的符号进行返回，这样有利于后面主函数进行判断是否初始操作成功，防止异常的发生。

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

#define TRUE 1
#define FALSE 0 // 可以方便定义
#define OK 1
#define ERROR -1
#define OVERFLOW -2
#define MaxSize 100		//线性表存储空间的初始分配量

定义线性顺序表的结构体 ：

第一个是使用数组直接用 int elem[MaxSize];

typedef struct {
    int elem[MaxSize];
    int length;
}SqList;

第二个是使用指针基地址 int *elem ；

typedef struct {				
	int *elem;				//存储空间基址
	int length;				//当前长度
	int listsize;			//当前分配的存储容量（
}SqList;

构造一个空的线性表L

第一个是使用数组直接用elem[MaxSize];

int Init_SqList(SqList  &L){
    L.length=0; //数组已经自动分配好
    return OK;
}

第二个是使用指针 int *elem ；

int Init_SqList(SqList &L) {
	L.elem = (int *)malloc(MaxSize* sizeof(int));
	if (!L.elem)
		exit(OVERFLOW);			//存储分配失败
	L.length = 0;			//空表长度为0
	L.listsize = MaxSize;
	return OK;
}

销毁线性表L

对于销毁线性表要看是否存在

int Destroy_SqList(SqList &L) {
	if (!L.elem)
		exit(OVERFLOW);
	free(L.elem);				//释放申请到的空间
	L.elem = NULL;
	L.length = 0;
	L.listsize = 0;
	return OK;
}

将L重置为空表

int Clear_SqList(SqList &L) {
	L.length = 0;
	return OK;
}

用e返回L中第i个数据元素的值

首先判断 i 这个是否超出范围i。这里的&e 是直接引用改变main函数里面的值（必须要在main函数里面进行先定义 int e；

int GetElem_SqList(SqList L, int i, int &e) {
	if (i < 1 || i > L.length)
		return ERROR;
	e = L.elem[i - 1];
	return OK;
}

在L中第i个位置之前插入新的数据元素e，L的长度加1

int ListInsert_Sq(Sqlist &L, int i, typedef e) {
	if (i < 1 || i > L.length + 1)
		return ERROR;
	if (L.length >= L.listsize) {
		//若空间不够则增加之
		newsize=L.listsize+LISTINCREMENT;
		newbase=(ElemType *)realloc(L.elem,newsize*sizeof(ElemType));
        if(!newbase) exit(OVERFLOW); //扩展失败
        L.elem=newbase; 
        L.listsize+=LISTINCREMENT;
        //L.listsize=newsize
	}
	ElemType *q = &(L.elem[i - 1]);			//q为插入位置
	for(ElemType *p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;						//插入位置及之后的元素右移
	*q = e;									//插入e
	++L.length;								//表长增1
	return OK;
}

for(int j=L.length-1;j>=i-1;j--){
    L.elem[j+1]=L.elem[j];
}
L.elem[i-1]=e;
L.length++;
return OK;

删除L的第i个数据元素，并用e返回其值，L的长度减1

int ListDelete_Sq(Sqlist &L, int i, typedef &e) {
	if (i < 1 || i > L.length)
		return ERROR;
	ElemType *q = &(L.elem[i - 1]);			//q为被删除元素的位置
	e = *q;
	ElemType *p = &(L.elem[L.length - 1]);	//表尾元素位置
	for(++q; p >= q; ++q)
		*(q - 1) = *q;						//被删除元素之后的元素左移
	--L.length;								//表长减1
	return OK;
}

输出

数组的形式

int visit(ElemType e) {
	printf("%d ", e);
	return OK;
}
int ListTraverse(Sqlist L, int (*visit)(ElemType)) {
	int i = 1;
	while(i <= L.length) {
		if (visit(L.elem[i - 1]))
			i ++;
		else
			return ERROR;
	}
	printf("\n");
	return OK;
}

指针的形式的输出

Status listinprint(Sqlist L){
	int *p,*q;
	if(L.length == 0) return error;
	else
	{
		q = L.elem + L.length - 1;
		for(p = L.elem; p<=q ; ++p)
		printf("%d ",*p); 
	}
	printf("\n\n");
	return ok;
}

得到最大值

Status getmax_sq(Sqlist L,int i,elemtype &e)//最大值
{
    if(L.length==0||i<1||i>L.length)
        return ERROR;
    elemtype *last;
    e=*L.elem;
    last=L.elem+L.length-1;
    while(L.elem!=last)
    {
        if(*L.elem>e)
            e=*(L.elem);
        L.elem++;
    }
    return OK;
}
int GET_Max(SqList L, int i,int &e){
     if(L.length==0||i<1||i>L.length)
        return ERROR;
    int max =0;
    for(int j=0;j<L.length-1;j++){
        if(max<L.a[j])max=L.a[j];
    }
    e=max;
    return OK;
}

得到最小值

Status getmini_sq(Sqlist L,int i,elemtype &e)//最小值
{
    if(L.length==0||i<1||i>L.length)
        return ERROR;
    elemtype *last;
    e=*L.elem;
    last=L.elem+L.length-1;
    while(L.elem!=last)
    {
        if(*L.elem<e)
            e=*(L.elem);
        L.elem++;
    }
    return OK;
}
//找到最小值
int GET_Lea(SqList L, int i,int &e){
     if(L.length==0||i<1||i>L.length)
        return ERROR;
    int lea =0;
    for(int j=0;j<L.length-1;j++){
        if(lea>L.a[j])lea=L.a[j];
    }
    e=lea;
    return OK;
}

表元素逆置

void listreverse_sq(Sqlist &L)//表元素逆置
{
    int i=0,j=L.length-1;
    elemtype temp=0;
    while(i<j)
    {
        temp=L.elem[i];
        L.elem[i]=L.elem[j];
        L.elem[j]=temp;
        i++;
        j--;
    }
}

排序.

void listsort_sq(Sqlist &L)//起泡法排序
{
    elemtype t=0;
    for(int i=0; i<L.length-1; i++)
        for(int j=0; j<L.length-1-i; j++)
            if(L.elem[j]>L.elem[j+1])
            {
                t=L.elem[j];
                L.elem[j]=L.elem[j+1];
                L.elem[j+1]=t;
            }
}

合并

//合并表,并且去掉重复的元素
void Add_List(SqList  &L1,SqList L2){
    bool temp=false;
    for(int i=0;i<=L2.length-1;i++){
        for(int j=0;j<=L1.length-1;j++){
            if(L2.a[i]==L1.a[j]){
                temp=true;
                break;
            }
        }
        if(temp){
            continue;
        }else{
            L1.length++;
            L1.a[L1.length-1]=L2.a[i];
        }
    }
}

void mergelist_sq(Sqlist La,Sqlist Lb,Sqlist &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++;
    while(pb<=pb_last)
        *pc++=*pb++;
}

合并

void MergeList(Sqlist &la, Sqlist &lb, Sqlist &lc){
	sort(la.elem,la.elem + la.length);			 		//直接调用库函数进行排序 
	sort(lb.elem,lb.elem + lb.length);
	int i,j,k,lena,lenb,ai,bj;
	i = j = 1;
	k = 0;
	while((i<=la.length)&&(j<=lb.length)){
		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.length){
		GetElem(la,i++,ai);
		listinsert(lc,++k,ai);
	}
	while(j <= lb.length){
		GetElem(lb,j++,bj);
		listinsert(lc,++k,bj);
	}
}