A complete instance of the sequence table functionality implemented by the C language

  • 2020-06-03 07:59:51
  • OfStack

This article illustrates the sequence table function implemented by C language. To share for your reference, specific as follows:

seqlist.h


#ifndef __SEQLIST_H__
#define __SEQLIST_H__
#include<cstdio>
#include<malloc.h>
#include<assert.h>
#define SEQLIST_INIT_SIZE 8
#define INC_SIZE 3 // The size of the space increment 
typedef int ElemType;
typedef struct Seqlist {
  ElemType *base;
  int capacity; // Sequential table capacity 
  int size; // The size of the table 
}Seqlist;
bool Inc(Seqlist *list);// Increase the capacity of the sequence table 
void InitSeqlist(Seqlist *list); // Initializes the sequence table 
void push_back(Seqlist *list, ElemType x); // Inserts elements at the end of the sequence table 
void push_front(Seqlist *list, ElemType x); // Inserts elements at the head of the sequence table 
void show_list(Seqlist *list); // Displays the elements in the sequence table 
void pop_back(Seqlist *list); // Delete the order table last 1 An element 
void pop_front(Seqlist *list); // Delete order table no 1 An element 
void insert_pos(Seqlist *list, int pos, ElemType x);// Inserts data at the selected location of the sequence table 
int find(Seqlist *list, ElemType key); // Look for elements in the sequence table key The subscript 
int length(Seqlist *list);// Find the length of the sequence table 
void delete_pos(Seqlist *list, int pos); // Deletes data elements at a specific location in the sequence table 
void delete_val(Seqlist *list, int key);// Delete the order table value of key Data elements 
void sort(Seqlist *list);// Bubble sort 
void reverse(Seqlist *list);// Reverse the order list 
void clear(Seqlist *list);// Clears all elements in the sequence table 
void destroy(Seqlist *list);// Destroy sequence table 
void merge(Seqlist *lt, Seqlist *la, Seqlist *lb);// Merge two sequential lists 
#endif //__SEQLIST_H__

seqlist.cpp


#include"seqlist.h"
bool Inc(Seqlist *list) {
  ElemType *newbase = (ElemType*)realloc(list, sizeof(ElemType)*(list->capacity + INC_SIZE)); // Reallocate memory space 
  if (newbase == NULL) {
    printf(" The memory space is full, cannot allocate memory space again! \n");
    return false;
  }
  list->base = newbase;
  list->capacity += INC_SIZE;
  return true;
}
void InitSeqlist(Seqlist *list) {
  list->base = (ElemType*)malloc(sizeof(ElemType)*SEQLIST_INIT_SIZE);
  assert(list->base != NULL);
  list->capacity = SEQLIST_INIT_SIZE;
  list->size = 0;
}
void push_back(Seqlist *list, ElemType x) {
  if (list->size >= list->capacity && !Inc(list)) { //Inc(list) Used to determine whether the sequential table size was increased successfully , Only enter if you fail if In the statement 
    printf(" The sequential table is full. You cannot continue inserting new elements at the end of the table! \n");
    return;
  }
  list->base[list->size] = x;
  list->size++;
}
void push_front(Seqlist *list, ElemType x) {
  if (list->size >= list->capacity && !Inc(list)) {
    printf(" The sequential table is full. New elements cannot be inserted in the header anymore! \n");
    return;
  }
  for (int i = list->size;i > 0;i--) {
    list->base[i] = list->base[i - 1];
  }
  list->base[0] = x;
  list->size++;
}
void show_list(Seqlist *list) {
  for (int i = 0;i < list->size;i++) {
    printf("%d ", list->base[i]);
  }
  printf("\n");
}
void pop_back(Seqlist *list) {
  if (list->size == 0) {
    printf(" The sequence table is empty. You can no longer delete elements at the end of the table! \n");
    return;
  }
  list->size--;
}
void pop_front(Seqlist *list) {
  if (list->size == 0) {
    printf(" The sequence table is empty. You can no longer delete elements in the header! \n");
    return;
  }
  for (int i = 0;i < list->size - 1;i++) {
    list->base[i] = list->base[i + 1];
  }
  list->size--;
}
void insert_pos(Seqlist *list, int pos, ElemType x) {
  if (pos<0 || pos>list->size) {
    printf(" The insertion position is not valid. The element cannot be inserted! \n");
    return;
  }
  if (list->size >= list->capacity && !Inc(list)) {
    printf(" The order table is full. New elements cannot be inserted! \n");
    return;
  }
  for (int i = list->size;i > pos;i--) {
    list->base[i] = list->base[i - 1];
  }
  list->base[pos] = x;
  list->size++;
}
int find(Seqlist *list, ElemType key) {
  for (int i = 0;i < list->size;i++) {
    if (list->base[i] == key)
      return i;
  }
  return -1;
}
int length(Seqlist *list) {
  return list->size;
}
void delete_pos(Seqlist *list, int pos) {
  if (pos < 0 || pos >= list->size) {
    printf(" Delete location is not legal, cannot delete the element! \n");
    return;
  }
  for (int i = pos;i < list->size - 1;i++) {
    list->base[i] = list->base[i + 1];
  }
  list->size--;
}
void delete_val(Seqlist *list, int key) {
  int pos = find(list, key);
  if (pos == -1) {
    printf(" This element is not in the sequence table! \n");
    return;
  }
  delete_pos(list, pos);
}
void sort(Seqlist *list) {
  for (int i = 0;i < list->size - 1;i++) {// The number of times a sort occurs (e.g 5 Data need to be compared 4 Trip) 
    for (int j = 0;j < list->size - 1 - i;j++) {// every 1 The number of comparisons in a trip (for example 5 The number is number one 0 Need to compare 4 Times) 
      if (list->base[j] > list->base[j + 1]) {
        ElemType temp = list->base[j];
        list->base[j] = list->base[j + 1];
        list->base[j + 1] = temp;
      }
    }
  }
}
void reverse(Seqlist *list) {
  if (list->size == 0 || list->size == 1) return;
  int low = 0, high = list->size - 1;
  while (low < high) {
    ElemType temp = list->base[low];
    list->base[low] = list->base[high];
    list->base[high] = temp;
    low++;
    high--;
  }
}
void clear(Seqlist *list) {
  list->size = 0;
}
void destroy(Seqlist *list) {
  free(list->base);
  list->base = NULL;
  list->capacity = 0;
  list->size = 0;
}
void merge(Seqlist *lt, Seqlist *la, Seqlist *lb) {
  lt->capacity = la->size + lb->size;
  lt->base = (ElemType*)malloc(sizeof(ElemType)*lt->capacity);
  assert(lt->base != NULL);
  int ia = 0, ib = 0, ic = 0;
  while (ia < la->size&&ib < lb->size) {
    if (la->base[ia] < lb->base[ib]) {
      lt->base[ic++] = la->base[ia++];
    }
    else {
      lt->base[ic++] = lb->base[ib++];
    }
  }
  while (ia < la->size) {
    lt->base[ic++] = la->base[ia++];
  }
  while (ib < lb->size) {
    lt->base[ic++] = lb->base[ib++];
  }
  lt->size = la->size + lb->size;
  show_list(lt);
}

main.cpp


#include"seqlist.h"
void main() {
  Seqlist list;
  InitSeqlist(&list);
  ElemType item;
  int pos;
  int select = 1;
  while (select) {
    printf("*******************************************\n");
    printf("*[1] push_back    [2] push_front  *\n");
    printf("*[3] show_list    [4] pop_back   *\n");
    printf("*[5] pop_front    [6] insert_pos  *\n");
    printf("*[7] find       [8] length    *\n");
    printf("*[9] delete_pos    [10] delete_value *\n");
    printf("*[11] sort       [12] reverse    *\n");
    printf("*[13] clear      [14] merge     *\n");
    printf("*[0] quit_system             *\n");
    printf("*******************************************\n");
    printf(" Please select: >>");
    scanf("%d", &select);
    if (select == 0) break;
    switch (select) {
    case 1:
      printf(" Please enter the data you want to insert ( -1 The end) :>");
      while (scanf("%d", &item), item != -1) {// First the input item As long as item Is not equal to -1 And then we go through the loop 
        push_back(&list, item);
      }
      break;
    case 2:
      printf(" Please enter the data you want to insert ( -1 The end) :>");
      while (scanf("%d", &item), item != -1) {
        push_front(&list, item);
      }
      break;
    case 3:
      show_list(&list);
      break;
    case 4:
      pop_back(&list);
      break;
    case 5:
      pop_front(&list);
      break;
    case 6:
      printf(" Please enter the data to insert :>");
      scanf("%d", &item);
      printf(" Please enter the position to insert :>");
      scanf("%d", &pos);
      insert_pos(&list, pos, item);
      break;
    case 7:
      printf(" Enter the data you are looking for :>");
      scanf("%d", &item);
      pos = find(&list, item);
      if (pos == -1)
        printf(" The data element you are looking for is not in the order table! \n");
      else
        printf(" The subscript position of the searched data element in the sequence table is %d\n", pos);
      break;
    case 8:
      printf(" The length of the sequence table is %d\n", length(&list));
      break;
    case 9:
      printf(" Enter the subscript location in the sequence table where you want to delete the data :>");
      scanf("%d", &pos);
      delete_pos(&list, pos);
      break;
    case 10:
      printf(" Please enter the value of the data to delete :>");
      scanf("%d", &item);
      delete_val(&list, item);
      break;
    case 11:
      sort(&list);
      break;
    case 12:
      reverse(&list);
      break;
    case 13:
      clear(&list);
      break;
    case 14:
      Seqlist mylist, yourlist;
      ElemType item1, item2;
      InitSeqlist(&mylist);
      InitSeqlist(&yourlist);
      printf(" Please enter the sequence table 1 Element values ( -1 The end) :>");
      while (scanf("%d", &item1), item1 != -1) {
        push_back(&mylist, item1);
      }
      printf(" Please enter the sequence table 2 Element values ( -1 The end) :>");
      while (scanf("%d", &item2), item2 != -1) {
        push_back(&yourlist, item2);
      }
      merge(&list, &mylist, &yourlist);
      destroy(&mylist);
      destroy(&yourlist);
      break;
    default:
      printf(" Wrong choice of input! Please enter again! \n");
      break;
    }
  }
  destroy(&list);
}

I hope that this article has been helpful in C programming.


Related articles: