顺序表的相关算法--c语言版

//－－－－－ 顺序表的存储结构－－－－－
//静态分配
#define MAXSIZE 100             //顺序表可能达到的最大长度
typedef struct {
	ElemType data[MAXSIZE];
	int length;             //当前长度
} SqList;                   //顺序表的结构类型为SqList

 //动态分配
 #define InitSize 100 //表长度的初始定义
 typedef struct {
	ElemType *data;//指示动态分配数组的指针
	int MaxSize;//数组的最大容量
	int length;//当前个数
} SeqList;//动态分配数组顺序表的类型定义  
//初始动态分配，sizeof(ElemType)每个数据元素所占用存储空间的大小
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);
free(L.data);

//在新建顺序表、插入一个数据、删除数据等改变顺序表的操作时
bool Listinsert(SeqList &L, ElemType e) {}
//在查找操作时，没有改变表
void LocateELem(SeqList L, ElemType e) {}

对给定的顺序表L进行重新组织，使所有小于给定值k的元素均在大于等于k的元素之前，不要求排序。

void receatList(SeqList &L,ElemType k) {
	int i=0;
	int j=L.length;
	while(i<j) {
		while(i<j&&L.elem[i]<k)
			i++;
		while(i<j&&L.elem[j]>=k)
			j--;
		if(i<j) {
			temp=L.elem[i];
			L.elem[i]=L.elem[j];
			L.elem[j]=temp;
			i++;
			j--;
		}
	}
}

有序线性表L存在着相同的元素，找出重复出现次数最多的数据元素并统计其重复次数，由参数返回。

int max_sum(Seqlist L) {
	int max=0,sum=1,i;
	for(i=1; i<L.length-1; i++) {
		if(L.data[i]==L.data[i-1]) {
			sum++;
		} else {
			if(sum>max) {
				max=sum;
				sum=1;
			}
		}
	}
	return max,sum;
}

有序线性表两个数求和等于x的个数

int sum(SeqList L,Elemtype x){
	int count=0;
	for(int i=0;i<L.length;i++){
		for(int j=i+1;j<L.length;j++){
			if(L.data[i]+L.data[j]==x){
				count++;
			}
		}
	}
	return count;
}

从有序顺序表中删除所有值重复的元素，使表中所有元素的值均不同。

void delete_same(SeqList &L) {
    int i,j;
    for(i=0,j=1; j<L.length; j++) {
        if(L.data[i]!=L.data[j]) {
            L.data[++i]==L.data[j]
        }
    }
    L.length=i+1;
}

删除线性表L中元素值等于给定值x的所有元素（表中可能有相同的元素）。

void delete_x(SeqList &L,Elemtype x){
	int i,k = 0;
	for(i = 0; i < L.length;i++){
	    if(L.data[i] != x){    //不相等的元素，把它放入新表
	        L.data[k] = L.data[i];
	        k++;
	    }
	}
	L.length = k;  //表长置为k
}

将顺序表中的所有元素逆置，空间复杂度为O（1）。

void reverse(Seqlist &L) {
    ElemType temp;
    for(int i=0; i<L.length/2; i++) {
        temp=L.data[0];
        L.data[i]=L.data[L.length-i-1];
        L.data[L.length-i-1]=temp;
    }
}

将两个有序的顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。

void merge(SeqList A,SeqList B,SeqList &C) {
    int i=0,j=0,k=0;
    while(i<A.length&&j<B.length) {
        if(A.data[i]<=B.data[j])
            C.data[k++]=A.data[i++];
        else
            C.data[k++]=B.data[j++];
    }
    while(i<A.length)
        C.data[k++]=A.data[i++];
    while(j<B.length)
        C.data[k++]=B.data[j++];
    C.length=k;
}