【第十周】线性表的链结表表示法+火车浏览器

.h
// 定义循环链结表元素类型为整数。
typedef int ElemType; 

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

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

// 循环双向链结表使用双节点指针，指向头节点和尾节点。
typedef struct {
  Link head; // 头节点指针 
  Link tail; // 尾节点指针
} DList; 

// 初始化循环双向链结表。
void initial(DList *);
// 取得循环双向链结表的元素个数。
int getSize(DList); 

// 取出循环双向链结表的第 i 个元素, 返回该元素的值。
// 若 inx<0, 向左移动；若 inx>0, 向右移动。
// 若 |inx| 大于双向链结表的元素个数，则循环重复计数
ElemType getElem(DList, int);

// 搜寻循环双向链结表的元素。若成功，返回元素位置；否则，返回 -1。
int search(DList, ElemType);  

// 将一个元素插入到循环双向链结表，返回该元素的位置。
int insert(DList *, ElemType); 

// 从循环双向链结表删除一个元素。若成功，返回该元素原来的位置；
// 否则，返回 -1。
int delete(DList *, ElemType); 

// 将循环双向链结表清空。
void clear(DList *);

// 檢查循环双向链结表是否為空表。若是空，返回 1；否则，返回 0。
int is_empty(DList); 

// 打印循环双向链结表元素。
void printlst(DList); 


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

// 初始化双向链结表 L。
void initial(DList *L) {
  L->head = NULL; // 将双向链结表的头节点指针设为空值。
  L->tail = NULL; // 将双向链结表的尾节点指针设为空值。 
}

// 取得双向链结表 L 的元素个数。 
int getSize(DList L) {
  Link current = L.head; // 节点指针。 
  int size = 0; // 线性表个数初始值设为 0.

  if (current==NULL) return size; // 如果线性表为空，则元素个数为 0.
         
  do { // 加一个节点计数。 
    size++; // 个数加 1。 
    current = current->next; // 下一个节点。
  } while (current!=L.head); // 如果不是尾节点，继续搜寻。
  return size; // 线性表 L 的元素个数。     
}

// 取出循环双向链结表的第 i 个元素, 返回该元素的值。
// 若 inx<0, 向左移动；若 inx>0, 向右移动。
// 若 |inx| 大于双向链结表的元素个数，则循环重复计数。 
ElemType getElem(DList L, int inx) {
  Link current = L.head; // 头节点指针。
  int i; // 循环变量。 
    
  if (current==NULL) return -1; // 如果线性表为空，则无此元素。
    
  // 循环线性表，如果 inx>size, 会重复 L 的头节点。
  for (i=0; i<abs(inx); i++)
    if (inx>0) current = current->next; // 往右移到下一个元素。 
    else current = current->prev; // 往左移到前一个元素。
  return current->elem; // 返回节点的元素值。 
} 

// 搜寻循环双向链结表的元素。若成功，返回元素位置；否则，返回 -1。
int search(DList L, ElemType e) {
  Link current = L.head; // 头节点指针。  int position=0; // 元素位置，设定初始值为 0。
    
  if (current==NULL) return -1; // 如果循环双向链结表为空，则无此元素。
    
  do { // 循环双向链结表不是空的，至少做一次。 
    if (current->elem==e) return position; // 搜寻成功，返回元素 e 的位置。 
    else if (current->elem<e) { // 还有其它节点，继续搜寻。
      position++; // 位置加 1。  
      current = current->next; // 移到下一个节点。 
    }
    else return -1; // 节点的值已超过，搜寻失败。 
  } while (current!=L.head); // 若回到头节点，则停止循环。 
  return -1; // 已经超过循环双向链结表的最后一个节点，搜寻失败。 
} 

// 将一个元素插入到循环双向链结表，返回该元素的位置。
int insert(DList *L, ElemType e) {
  Link current = L->head; // 指向头节点。
  Link previous = L->tail; // 指向尾节点。 
  Link newNode; // 新节点的指针。
  int size = getSize(*L); // 循环双向链结表的元素个数。 
  int position=0; // 目前节点位置。
  
  if (current==NULL) { // Case 1：当循环双向链结表为空时。 
    newNode = (Link) malloc(sizeof(Node)); // 要求一个新节点的内存。
    newNode->elem = e; // 复制节点的数据。
    newNode->prev = newNode; // 循环双向链结表只有一个节点，prev 指向自己。
    newNode->next = newNode; // 循环双向链结表只有一个节点，next 指向自己。
    L->head = newNode; // 设定循环双向链结表只头节点。 
    L->tail = newNode; // 设定循环双向链结表只尾节点。 
    return position; // 头节点的位置为 0。
  }
  
  for (position=0; position<size; position++) { // 寻找插入位置。
    if (current->elem>=e) break; // 找到第一个元素大于或等于 e 的节点。
    previous = current; // 下一个 previous。 
    current = current->next; // 下一个 current。      
  } 
  // Cases 2, 3 & 4: 插入一个节点的 current 之前。
  newNode = (Link) malloc(sizeof(Node)); // 要求一个新节点的内存。
  newNode->elem = e; // 复制目前节点的数据。 
  newNode->prev = previous; // 设定新节点的的 prev 指针。
  previous->next = newNode; // 将前一节点的 next 指针指向新节点。 
  newNode->next = current; // 设定新节点的 next 指针。
   current->prev = newNode; // 将现节点的 prev 指针指向新节点。
  if (position==0) L->head = newNode; // Case 2：更新头节点。
  else if (position==size) L->tail = newNode; // Case 4: 更新尾节点。
  return position; // 返回位置。
}

// 从循环双向链结表删除一个元素。若成功，返回该元素原来的位置；
// 否则，返回 -1。
int delete(DList *L, ElemType e) {
  Link current = L->head; // 指向头节点。
  Link previous = L->tail; // 指向尾节点。 
  int position = 0; // 目前节点位置。
    
  if (current==NULL) return -1; // 若循环双向链结表为空，删除失败。
    
  do { // 当循环双向链结表还有节点。
    if (current->elem==e) { // 找到要删除的节点。
      if (position==0) { // 删除的节点是头节点。
        if (current->next==current) { // 循环双向链结表只有一个节点。 
          L->head = NULL; // 将头节点清空。 
          L->tail = NULL; // 将尾节点清空。
        }
        else {
          previous->next = current->next; // 修改前一个节点的 next 指针。
          current->next->prev = previous; // 修改下一个节点的 prev 指针。 
          L->head = current->next; // 更新头节点。 
        } 
        free(current); // 释放删除的节点。
        return position; // 返回删除节点的原来位置。 
      }
      else {
        if (current->next==L->head) // 删除的是尾节点。
          L->tail = previous; // 更新尾节点。 
        previous->next = current->next; // 修改前一个节点的 next 指针。 
        current->next->prev = previous; // 修改下一个节点的 prev 指针。
        free(current); // 释放删除的节点。
        return position; // 返回删除节点的原来位置。 
      } 
    }
    else if (current->elem<e) { // 检查下一个节点。 
      previous = current; // 将目前的节点设为前一个节点。 
      current = current->next; // 将下一个节点设为下一步骤的目前节点。 
      position++; // 位置加 1。
    }
    else return -1; // 目前节点数据已超过删除的值；删除失败。
  } while (current!=L->head); // 若还没回到头节点，继续检查。

  return -1; // current 回到头节点，删除失败。
}

// 将循环双向链结表清空。
void clear(DList *L) {
  Link current = L->head; // 指向目前的节点。
  Link previous; // 前一个节点。 
    
  while (current->next!=L->head) { // 不是尾节点。
    previous = current; // 目前的节点。 
    current = current->next; // 下一个节点。
    free(previous); // 释放目前的节点。 
  }
  free(current); // 释放尾节点。
  L->head = NULL; // 将循环双向链结表的头节点设为空。 
  L->tail = NULL; // 将循环双向链结表设尾节点设为空。 
}

// 檢查循环双向链结表是否為空表。若是空，返回 1；否则，返回 0。
int is_empty(DList L) {
  return L.head==NULL; // 若 L 的头节点为空，返回 1，否则，返回 0。 
} 

// 打印循环双向链结表元素。
void printlst(DList L) {
  Link current = L.head; // 指向目前的节点。
  int position = 0; // 目前节点的位置。 
    
  printf("线性表元素个数：%3d 元素\n", getSize(L));

  if (current!=NULL) { // 循环双向链结表不是空的，开始打印。 
    while (current->next!=L.head) { // 还有节点要打印。
      printf("%3d ", current->elem); // 打印节点数据。
      if ((position+1)%20==0) printf("\n"); // 满 20 个元素，打印换行。
      current = current->next; // 移到下一个节点。 
      position++; // 下一个位置。 
    }  
    printf("%3d \n", current->elem); // 打印尾节点数据和换行。 
  }
  printf("\n"); // 打印一个换行。 
} 


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

// 合并 (merge) 两个循环线性表 L1 和 L2。
// 返回合并后的循环线性表。 
DList merge_list(DList L1, DList L2) {
  DList 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 的元素。
// 返回移除后的循环双向链结表。 
DList remove_list(DList L1, DList L2) {
  DList 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) {
  DList 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; 
} 

学习思考以上老师代码

自主学习火车浏览器的使用方法