【第八周】线性表

.h
#define MAXSIZE 100 // 有序线性表元素上限，可以是任何正整数

typedef int ElemType; // 定义线性表元素类型为整数 int. 

typedef struct {
  ElemType elem[MAXSIZE]; // 整数型的固定数组，且元素介于 0 与 99 之间。 
  int size; // 有序线性表的元素个数，0 至 MAXSIZE；初始值为 0。
} List;

// 初始化线性表，将 size 设为 0。
void initial(List *);

// 取得线性表的大小。
int getSize(List); 

// 依照位置取出线性表的元素, 若 0<=i<size，返回该元素的值，否则，返回 -1。
ElemType getElem(List, int);

// 搜寻线性表的元素，返回该元素的位置。若成功，返回该元素的位置；
// 否则，返回 -1。
int search(List, ElemType);  
//  将一个元素插入到线性表适当的位置。若成功，返回该元素的位置；
// 否则，返回 -1。
int insert(List *, ElemType); 

// 从线性表删除一个元素。若成功，返回该元素原来的位置；否则，返回 -1。
int delete(List *, ElemType); 

// 将线性表清空，即是将 size 设为 0。
void clear(List *);

// 檢查线性表是否為空表。若是空，返回 1；否则，返回 0。
int is_empty(List); 

// 打印线性表元素.
// 我们增加这个函数，因为它的必要性。
void printlst(List); 


.c
#include <stdio.h>
#include "sorted_list_array_fixed.h"

// 初始化线性表 L，将 size 设为 0。
void initial(List *L) {
  L->size = 0; // 线性表初始状态为空。 
}

// 线性表 L 的大小。 
int getSize(List L) {
  return L.size; // 线性表 L 的大小。 
} 

// 从 L 取出位置 i 的元素 e, 若 0<=i<size 返回 e；
// 否则，返回值 -1。 
ElemType getElem(List L, int i) {
  if (i>=0 && i<L.size) return L.elem[i]; // 若 0<=i<size，返回 e。
  else return -1; // 否则，返回值 -1。
} 

// 搜寻元素 e 在 L 中的位置。若成功，返回 e 的索引；否则，返回 -1。
int search(List L, ElemType e) {
  int i; // 循环变量。
	
  for (i=0; i<L.size; i++)
    if (L.elem[i]==e) return i; // 搜寻成功。 
  return -1; // 搜寻失败。 
} 

//  将元素 e 插入到 L 适当的位置。若成功，返回 e 的位置；否则，返回 -1。
int insert(List *L, ElemType e) {
  int i, j; // 循环变量。
	
  for (i=0; i<L->size; i++)
    if (L->elem[i]>=e) break; // 找到插入元素的位置。
		 
  // 假如 i<size, 则是已找到插入的位置；否则，插入到线性表最后的位置。	 
  if (L->size==MAXSIZE) return -1; // 线性表已满，不能再插入元素。
	
  // 将元素 i 与之后的元素往后移一个位置。 	
  for (j=L->size-1; j>=i; j--) L->elem[j+1] = L->elem[j]; 
  L->elem[i] = e; // 将元素 e 插入 i 的位置。
  
  L->size++; // 更新线性表的元素个数。   return i; // 返回元素 e 插入的位置。 
} 

// 从 L 删除元素 e。若成功，返回 e 原来的位置；否则，返回 -1。
int delete(List *L, ElemType e) {
  int i, j; // 循环变量。
	 
  for (i=0; i<L->size; i++)
    if (L->elem[i]==e) break; // 找到删除元素的位置。
    else if (L->elem[i]>e) return -1; // 元素 e 不是线性表 L 的元素，删除失败。
		 
  // 假如 i==size, 元素 e 不是线性表 L 的元素，删除失败。 
  if (i==L->size) return -1; // 删除失败。
	
  // 将元素 i 之后的元素往前移一个位置。 
  for (j=i; j<L->size; j++) L->elem[j] = L->elem[j+1]; 
  
  L->size--; // 更新线性表的元素个数。 
  return i; // 返回删除元素 e 的位置。
}

// 将线性表 L 清空，即是将 size 设为 0。
void clear(List *L) {
  L->size = 0; // 重设元素个数为 0。 
}

// 檢查线性表 L 是否為空表。若是空，返回 1；否则，返回 0。
int is_empty(List L) {
  return L.size==0; // 若个数为 0，则为空，否则，不是空。 
} 

// 打印线性表元素.
// 我们增加这个函数，因为它的必要性。
void printlst(List L) {
  int i; // 循环变量。

  printf("线性表元素个数：%3d 元素\n", L.size);	
  for (i=0; i<L.size; i++) {
    printf("%3d ", L.elem[i]); // 打印第 i 个元素。 
    if ((i+1)%20==0) printf("\n"); // 每行 20 个元素。 
  }
  if ((i%20)!=0) printf("\n"); // 若不足 20 个元素，打印一个换行。
  printf("\n"); // 打印一个换行。 
} 


main.c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "sorted_list_array_fixed.h"

// 合并 (merge) 两个线性表 L1 和 L2。
// 若两个表的总元素超过线性表的上限，舍弃超出的 L1 与 L2 元素。
// 返回合并后的线性表。 
List merge_list(List L1, List L2) {
  List L; // 合并的线性表。   
  int size1=getSize(L1), size2=getSize(L2); // 线性表 L1，和 L2 的大小。  
  ElemType e1, e2; // 线性表 L1 和 L2 的元素。 
  int i1=0, i2=0; // 线性表 L1 和 L2 的索引。
	
  initial(&L); // 初始化 L。 
	
  // i1<L1.size: l1 还有元素待合并。
  // i2<L2.size: l2 还有元素待合并。 
  while (getSize(L)<MAXSIZE && i1<size1 && i2<size2) {
    e1 = getElem(L1, i1); // 取得 L1 的元素。
    e2 = getElem(L2, i2); // 取得 L2 的元素。
    // 将 L1 和 L2 较小的元素放到 L 中，并移到下一个元素的位置。 
    if (e1<=e2) {insert(&L, e1); i1++;}
    else {insert(&L, e2); i2++;}
	}
	
  // L1 还有元素，若还有空的位置继续复制 L1 的元素。
  while (getSize(L)<MAXSIZE && i1<size1) insert(&L, getElem(L1, i1++)); 
	
  // L2 还有元素，若还有空的位置继续复制 L2 的元素。    
  while (getSize(L)<MAXSIZE && i2<size2) insert(&L, getElem(L2, i2++));
	
  return L; // 返回合并后的线性表。  
} 

// 合自 L1 中移除 (remove) 所有 L2 的元素。
// 返回移除后的线性表。 
List remove_list(List L1, List L2) {
  List L; // 移除的线性表。   
  int size1=getSize(L1), size2=getSize(L2); // 线性表 L1，和 L2 的大小。  
  ElemType e1, e2; // 线性表 L1 和 L2 的元素。 
  int i1=0, i2=0; // 线性表 L1 和 L2 的索引。
	
  initial(&L); // 初始化 L。	
  // i1<size1: l1 还有元素待移除。
  // i2<size2: l2 还有元素待移除。 
  while (i1<size1 && i2<size2) {
    e1 = getElem(L1, i1); // 取得 L1 的元素。
    e2 = getElem(L2, i2); // 取得 L2 的元素。 
    // 若 L1 和 L2 的元素相同，移除 L1 的元素，不储存。 
    if (e1==e2) i1++;
    // 若 L1 的元素小于 L2 的元素，将 L1 的元素放到 L 中。  
    else if (e1<e2) {insert(&L, e1); i1++;}
    // 若 L1 的元素大于 L2 的元素，检查下一个 L2 的元素。 
    else i2++;
  } 
	
  // L2 已经没有元素；但是，L1 还有元素，继续将 L1 的元素放到 L 中。
  while (i1<size1) insert(&L, getElem(L1, i1++));
	
  return L; // 返回移除后的线性表。   
} 

int main(void) {
  List L, L1, L2; // 声明线性表。
  int leng1, leng2; // 两个线性表的长度。 
  int i; // 循环变量。 
	
  initial(&L1); // 初始化 L1。
  initial(&L2); // 初始化 L2。
	
  srand(time(NULL)); // 随机数生成器的种子。
	
  // 输入线性表 L1 的元素个数。 
  do {
    printf("输入线性表 L1 的元素个数 (1 与 100 (含)之间)：");
    scanf("%d", &leng1);
  } while (leng1<0 || leng1>100);
	
  // 输入线性表 L2 的元素个数。 
  do {
    printf("输入线性表 L2 的元素个数 (1 与 100 (含)之间)：");
    scanf("%d", &leng2);
  } while (leng2<0 || leng2>100); 
  printf("-------------------------------------------\n");
	
  // 随机产生 L1 的元素。  for (i=0; i<leng1; i++) insert(&L1, rand() % 100); // 插入 L1 的元素。
  printf("线性表 L1：\n"); 
  printlst(L1); // 打印线性表 L1。 
	
  // 随机产生 L2 的元素。 
  for (i=0; i<leng2; i++) insert(&L2, rand() % 100); // 插入 L2 的元素。 
  printf("线性表 L2：\n"); 
  printlst(L2); // 打印线性表 L2。
	
  L = merge_list(L1, L2); // 合并 L1 和 L2。 
  printf("合并 L1 和 L2 的线性表：\n"); 
  printlst(L); // 打印合并的线性表。
	
  L = remove_list(L1, L2); // 从 L1 移除 L2。 
  printf("从 L1 移除 L2 的线性表：\n"); 
  printlst(L); // 打印移除的线性表。
	
  return 0; 
} 

　　学习思考老师上课代码