【第九周】单链有序线性表+后羿采集器

.h
// 单链有序线性表基本操作介面
typedef int ElemType; // 定义线性表元素类型为整数 int. 

typedef struct node { // 定义链结表节点 
  ElemType elem; // 节点数据，整数 
  struct node* next; // 节点的链，递归定义。 
} Node; // 节点型态 

typedef Node* Link; // 节点的链，是节点的指针。

typedef Link List; // 有序线性表是一个节点指针，指向链结表的头节点 (head node)。 

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

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

// 取出线性表的第 i 个元素, 返回该元素的值；
// 若 i 大于线性表的元素个数，返回 -1。
ElemType getElem(List, int);
// 搜寻线性表的元素，返回该元素的位置。若成功，返回该元素的位置；
// 否则，返回 -1。
int search(List, ElemType);  

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

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

// 将线性表清空。
void clear(List *);

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

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


.c
// 单链有序线性表基本操作介面
#include <stdio.h>
#include <stdlib.h>
#include "sorted_list_single_list.h"

// 初始化线性表 L。
void initial(List *L) {
  *L = NULL; // 将线性表的指针设为空值。 
}

// 取得线性表 L 的大小，返回元素个数。 
int getSize(List L) {
  Link link = L; // 节点指针。 
  int size = 0; // 线性表个数初始值设为 0.
    
  while (link!=NULL) {
    link = link->next; // 下一个节点。
    size++; 
  }
  return size; // 线性表 L 的大小。     
}
// 取出线性表的第 i 个元素, 返回该元素的值；
// 若 i 大于线性表的元素个数，返回 -1。
ElemType getElem(List L, int inx) {
  Link current = L; // 节点指针。
  int i; // 循环变量。 
    
  for (i=0; i<inx; i++) 
    if (current==NULL) return -1; // 第 i 个元素不存在。 
    else current = current->next; // 移到下一个元素。 
  return current->elem; // 返回节点的元素值。 
} 

// 搜寻元素 e 在 L 中的位置。若成功，返回 e 的索引；否则，返回 -1。
int search(List L, ElemType e) {
  Link link = L; // 节点指针。
  int position=0; // 元素位置，设定初始值为 0。 
    
  while (link!=NULL) {
    if (link->elem==e) return position; // 搜寻成功，返回元素 e 的位置。 
    else if (link->elem<e) { // 还有其它节点，继续搜寻。 
      link = link->next; // 移到下一个节点。 
      position++; // 位置加 1。 
    }
    else return -1; // 节点的值已超过，搜寻失败。 
  }
  return -1; // 已经超过线性表的最后一个节点，搜寻失败。 
} 

// 将元素 e 插入到 L 适当的位置。插入完成时，返回 e 的位置。
int insert(List *L, ElemType e) {
  Link current = *L; // 指向目前的节点。
  Link previous = NULL; // 指向前一个节点，开始时为空。 
  Link newNode; // 新节点的指针。
  int position = 0; // 目前节点位置。
    
  if (*L==NULL) { // Case 1：线性表是空的。
    newNode = (Link) malloc(sizeof(Node)); // 要求一个新节点的内存。
    newNode->elem = e; // 设定头节点的数据。 
    newNode->next = NULL; // 设定头节点的链。
    *L = newNode; // 线性表指向第一个节点。
    return 0; // 返回头节点位置。 
  }
    
  do { // 检查目前的节点。  if (current->elem>=e) { // Cases 2 & 3: 找到插入位置，插在这个节点之前。 
    newNode = (Link) malloc(sizeof(Node)); // 要求一个新节点的内存。
    newNode->elem = e; // 设定新节点的数据。 
    newNode->next = current; // 设定新节点的链。
    if (previous==NULL) *L = newNode; // Case 2: 插入线性表的头节点。
    else previous->next = newNode; // Case3：修改前一节点的链。 
    return position; // 返回位置。 
    }
    else {
      previous =  current; // 将目前的节点设为前一个节点。 
      current = current->next; // 将下一个节点设为下一步骤的目前节点。 
      position++; // 位置加 1。
    }
  } while (current!=NULL); // 若线性表还有节点，继续。 

  // Case 4：while 循环结束，没有执行返回，移到链结表的最后节点。 
  newNode = (Link) malloc(sizeof(Node)); // 要求一个新节点的内存。
  newNode->elem = e; // 设定新节点的数据。
  newNode->next = NULL; // 最后的节点，将其下一个节点设为空值。
  previous->next = newNode; // 将新增节点放在线性表的最后。
  return position; // 返回位置。
}

// 从 L 删除元素 e。若成功，返回 e 原来的位置；否则，返回 -1。
int delete(List *L, ElemType e) {
  Link current = *L; // 指向目前的节点。
  Link previous; // 指向前一个节点。 
  int position = 0; // 目前节点位置。
    
  while (current!=NULL) { // 当线性表还有节点。
    if (current->elem==e) { // 找到要删除的节点。
      if (position==0) { // 删除的节点是头节点。 
        *L = current->next; // 设定下一个节点为头节点。
        free(current); // 释放删除的节点。
        return position; // 返回删除节点的原来位置。 
      }
      else {
        previous->next = current->next; // 将前一个节点的链指向目前的下一个节点。
        free(current); // 释放删除的节点。
        return position; // 返回删除节点的原来位置。 
      } 
    }
    else if (current->elem<e) {
      previous = current; // 将目前的节点设为前一个节点。 
      current = current->next; // 将下一个节点设为下一步骤的目前节点。 
      position++; // 位置加 1。
    }
    else return -1; // 目前节点数据已超过删除的值；删除失败。
  }
  return -1; // 已经没有节点，删除失败。 
}

// 将线性表 L 清空。
void clear(List *L) {
  Link current; // 指向目前的节点。
    
  while (*L!=NULL) { // 还有节点要清除。
    current = *L; // 目前的节点。 
    *L = current->next; // 剩余的链结表。
    free(current); // 释放目前的节点。 
  }
}

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

// 打印线性表元素。
// 我们增加这个函数，因为它的必要性。
void printlst(List L) {
  List current = L; // 指向目前的节点。
  int position = 0; // 目前节点的位置。 
    
  printf("线性表元素个数：%3d 元素\n", getSize(L));

  while (current!=NULL) { // 还有节点要打印。
    printf("%3d ", current->elem); // 打印节点数据。
    if ((position+1)%20==0) printf("\n"); // 满 20 个元素，打印换行。
    current = current->next; // 移到下一个节点。 
    position++; // 下一个位置。 
  }
  if ((position%20)!=0) printf("\n"); // 若不足 20 个元素，打印一个换行。
  printf("\n"); // 打印一个换行。 
} 


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

// 合并 (merge) 两个线性表 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 (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 (i1<size1) insert(&L, getElem(L1, i1++));
    
  // L2 还有元素，继续复制 L2 的元素。 
  while (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; 
} 

学习思考以上老师代码

自主学习后羿采集器的用法提取数据