/***********************************線性表順序存儲結構的ADT定義(數組實現)**********************************************
ADT List
{
數據對象：D＝{ ai | ai ∈ElemSet, i=1,2,...,n, n≥0 }
數據關系：R1＝{ <ai-1 ,ai >|ai-1 ,ai∈D, i=2,...,n }
基本操作：
（1）線性表的初始化操作
InitList（&L,n）
操作結果：將L初始化為空表,申請空間的大小為n。
（2）線性表元素輸入操作
ListInput(&L)
初始條件：線性表L已存在 。
操作結果：線性表中的部分元素或全部元素已被賦值。
（3）線性表的置空操作
ClearList(&L)
初始條件：線性表L已存在且不為空 。
操作結果：將表L置為空表。
（4）線性表的判空操作
ListIsEmpty(&L)
初始條件：線性表L已存在。
操作結果：如果L為空表則返回1，否則返回0。
（5）獲取線性表元素個數的操作
ListLength（L）
初始條件：線性表L已存在。
操作結果：如果L為空表則返回0，否則返回表中的元素個數。
（6）獲取線性表第i個元素的操作（用元素的位序查找元素的值）
GetItem(L,i,&e)
初始條件：表L已存在且不為空，1<=i<=ListLength(L)。
操作結果：用e返回L中第i個元素的值。
（7）確定線性表元素位置的操作 （用元素的值確定元素位置）
LocateElem(L,e)
初始條件：表L已存在且不為空，e為合法元素值。
操作結果：如果L中存在元素e，則將“當前指針”指向第一個這樣的元素e所在位置並返回真，否則返回假。
（8）線性表插入元素操作
ListInsert(&L,i,e)
初始條件：表L已存在且不為空，e為合法元素值且1≤i≤ListLength(L)+1。
操作結果：在L中第i個位置之前插入新的數據元素e，L的長度加1。
（9）輸出線性表元素操作
PrintList(&L)
初始條件：線性表L已存在且不為空。
操作結果：線性表L中的所有元素已輸出。
（10）銷毀線性表操作
DestroyList(&L)
初始條件：線性表L已存在。
操作結果：將L銷毀。
}ADT List
****************************************************************************************************/
//*******************************************引入頭文件*********************************************
#include <stdio.h>
#include <stdlib.h> //使用了malloc、realloc、free函數
//******************************************自定義符號常量*******************************************
#define LIST_INIT_SIZE 100 //線性表存儲空間的初始分配量
#define LISTINCREMENT 10 //線性表存儲空間的分配增量
#define OVERFLOW -2 //內存溢出錯誤常量
#define ILLEGAL -1 //非法操作錯誤常量
#define OK 1 //表示操作正確的常量
#define ERROR 0 //表示操作錯誤的常量
//******************************************自定義數據類型********************************************
typedef int Status;
typedef float ElemType;
typedef struct{
ElemType *elem; //線性表存儲空間初始分配量
int length; //當前長度
int listsize; //當前分配的存儲容量（以sizeof(ElemType)為單位）
}SqList;
//******************************************線性表的主要操作******************************************
//1.--------------------線性表的初始化操作----------------------------
/*
函數：InitList_Sq
參數：SqList &L 線性表引用
int n 線性表最多能存儲n個元素
返回值：狀態碼，OK表示操作成功
作用：構造一個空線性表L
*/
Status InitList_Sq(SqList &L, int n) {
//申請線性表的內存空間，申請n個元素大小的內存空間
L.elem = (ElemType *)malloc(n * sizeof(ElemType));
//判斷內存是否分配成功
if(!L.elem){ //if(!L.elem) <=> if(L.elem == NULL)
printf("內存申請失敗！\n");
exit(OVERFLOW); //若內存分配失敗，則退出程序
}//if
printf("內存申請成功！\n");
//設置線性表的各個參數
L.length = 0; //設置線性表的長度為0
L.listsize = n; //設置線性表的空間大小為100個元素所占空間的大小
printf("線性表創建成功！\n");
//操作成功后返回OK
return OK;
}//InitList_Sq
//2.----------------------輸入線性表元素的操作-------------------
/*
函數：ListInput_Sq
參數：SqList &L 線性表引用
返回值：狀態碼，OK表示操作成功
作用：初始化線性表L中的元素
*/
Status ListInput_Sq(SqList &L){
//i聲明在這里不是好的寫法，應該將i寫在for循環中，有利於縮短i的作用域，及早回收其內存空間。
//但是由於C語言不兼容這種寫法，考慮到兼容性所以將i寫在外面。（C++支持這種寫法）
int n, i; //n代表元素的個數,i用作循環變量
//從鍵盤接收元素的個數，用戶輸入正確后退出此循環
while(1){ //while(1)是一個死循環，除非在循環體內執行break語句，否則永遠無法退出循環
//先確定元素的個數
printf("您想輸入幾個元素，請輸入個數，最多不可以超過:%d\n", L.listsize);
scanf("%d",&n);
if(n < 1 || n > 100) {
//如果發生非法操作，就提醒用戶重新輸入
printf("您的輸入非法，請重新輸入！！！\n");
}//if
else {
break;
}//else
}//while
//使用鍵盤輸入的方式初始化每一個元素
printf("請輸入線性表L的元素，中間用空格隔開，最多不可以超過100個元素\n");
for(i = 0; i < n; i++){
scanf("%f", &L.elem[i]);
}//for
L.length = n;
printf("該線性表初始化操作已完成！\n");
}//ListInput_Sq
//3.------------------判斷線性表是否為空-------------------
/*
函數：ListIsEmpty_Sq
參數：SqList &L 線性表引用
返回值：如果線性表是空表返回1，否則返回0
作用：判斷線性表是否為空表
*/
Status ListIsEmpty_Sq(SqList &L){
//length記錄了順序表中有效元素的個數
if (L.length == 0){
printf("該線性表是空表！");
return 1;
}//if
else {
return 0;
}//else
} //ListIsEmpty_Sq
//4.-----------------------------線性表中插入元素的操作-----------------------------------
/*
函數：ListInsert_Sq
參數：SqList &L 線性表引用
int i 插入位置，1 <= i <= length.Sq(L) + 1
ElemType e 待插入元素
返回值：狀態碼，OK表示操作成功，ERROR表示操作失敗
作用：在順序線性表L中第i個位置之前插入新元素e
*/
Status ListInsert_Sq(SqList &L, int i, ElemType e) {
//p和q都是工作指針，newbase是在插入的時候內存不夠用才會用到的接收新分配的內存地址的指針變量
ElemType *p, *q, *newbase;
//判斷參數i的值是否合法
if(i < 1 || i > L.length + 1) {
return ERROR; //i的值不合法，返回錯誤
}//if
//插入操作之前需要先檢查存儲空間是否夠用，若不夠用就需要擴容
if(L.length >= L.listsize) { //當前存儲已滿，需要擴容
//realloc函數第一個參數是已經分配了的那部分存儲空間的首地址，
//第二個參數是重新分配的內存的大小，這個參數的值一般情況下
//會比已經分配的內存空間大一些或者小一些，但是需要注意的是
//如果新的大小小於原內存大小，可能會導致數據丟失。
//realloc函數的工作原理： 先判斷當前的指針是否有足夠的連續空間，
//如果有，擴大mem_address指向的地址，並且將mem_address返回，
//如果空間不夠，先按照newsize指定的大小分配空間，將原有數據
//從頭到尾拷貝到新分配的內存區域，而后釋放原來mem_address所指內存區域
//（注意：原來指針是自動釋放，不需要使用free），
//同時返回新分配的內存區域的首地址。即重新分配存儲器塊的地址。
//realloc函數的特點：如果我們只擴大不縮小，原先已分配內存的保存的數據不會丟失
//這部分數據會被realloc函數轉移到新的內存空間中，我們不需要
//手工寫拷貝數據的代碼，也不需要手工釋放第一個參數指示的已分配內存空間。
//我們只需要接收返回值，就能得到新的內存空間的首地址
//使用realloc函數為線性表重新分配內存空間
newbase = (ElemType *)realloc(L.elem,
(LIST_INIT_SIZE + L.listsize) * sizeof(ElemType));
//判斷內存空間是否分配成功
if(!newbase){ //if(!newbase) <=> if(newbase == NULL)
printf("內存申請失敗！\n");
//若內存分配失敗，則后續操作就沒有意義了，此時應退出程序
exit(OVERFLOW);
}//if
printf("內存申請成功！\n");
L.elem = newbase; //將線性表新基址賦給elem
L.listsize += LISTINCREMENT; //增加存儲容量
}//if
//找到插入位置
q = &(L.elem[i - 1]); //q指示了插入位置
//將插入位置及之后的元素后移
for(p = &(L.elem[L.length - 1]); p >= q; --p) {
*(p + 1) = *p;
}//for
//將e插入到q指示的插入位置
*q = e;
//插入元素e后表長應該增加1
++L.length;
//操作成功
return OK;
}//ListInsert_Sq
//5.----------------------線性表中刪除元素的操作----------------------------
/*
函數：ListDelete_Sq
參數：SqList &L 線性表引用
int i 刪除位置，1 <= i <= length.Sq(L)
ElemType &e 帶回被刪除元素
返回值：狀態碼，OK表示操作成功，ERROR表示操作失敗
作用：在順序線性表L中刪除第i個元素，並返回被刪除元素
*/
Status ListDelete_Sq(SqList &L, int i, ElemType &e){
//p和q是工作指針（工作指針就是起到臨時保存指針變量的作用）
ElemType *p, *q;
//因為無法從空表中刪除一個元素，所以要判斷線性表是否為空
//if(ListIsEmpty_Sq(L)) <=> if(ListIsEmpty_Sq(L) != 0)
if(ListIsEmpty_Sq(L)) {
return ERROR;
}//if
//判斷刪除位置的參數i的值是否合法
if(i < 1 || i > L.length) {
return ERROR; //i的值不合法，返回錯誤
}//if
//找到刪除位置，p指示了被刪除元素的位置
p = &(L.elem[i - 1]);
//保存將被刪除的元素
e = *p;
//找到表尾元素的位置，q指示了表尾元素的位置
q = L.elem + L.length - 1;
//從被刪除元素之后開始到表尾元素位置，將被刪除元素之后的所有元素前移一位
//當此循環結束時，被刪除元素被其緊隨其后的元素覆蓋了，也就是刪除了
for(++p; p <= q; ++p) {
*(p-1) = *p;
}//for
//刪除操作執行后表長應該減1
--L.length;
//操作成功
return OK;
} //ListDelete_Sq
//6.-------------------線性表中查找元素的操作-------------------------------
/*說明：函數指針：函數在編譯時被分配的入口地址,用函數名表示。
函數指針指向的是程序代碼存儲區。
函數指針變量定義形式：數據類型 (*指針變量名)( ); 如 int (*p)();
舉個例子：（一定看清形參和實參如何傳遞的！）
#include <stdio.h>
int main(){
int max(int, int), min(int, int), add(int, int);
void process(int, int, int (*fun)(int, int));
int a, b;
printf("enter a and b:");
scanf("%d,%d", &a, &b);
process(a, b, max);
process(a, b, min);
process(a, b, add);
}//main
process(int x, int y, int (*fun)(int, int)){
int result;
result = (*fun)(x, y);
printf("%d\n",result);
}//process
max(int x, int y) {
printf(“max=”);
return(x > y ? x : y);
}//max
min(int x, int y){
printf(“min=”);
return(x < y ? x : y);
}//min
add(int x, int y){
printf(“sum=”);
return(x + y);
}
*/
/*
函數：compare
參數：ElemType x 待比較的第一個元素
ElemType y 待比較的第二個元素
返回值：如果元素x和y的值相等，返回1，否則返回0
作用：比較兩個元素是否相等
*/
int compare(ElemType x, ElemType y){
return x == y;
}//compare
/*
函數：ListDelete_Sq
參數：SqList &L 線性表引用
ElemType e 查找值為e的元素
Status (*compare)(ElemType,ElemType) 函數指針，指向比較元素是否相同的函數
返回值：查找到元素在線性表中的位置，若沒有找到，返回0
作用：在順序線性表L中查找第一個值e滿足compare()的元素在線性表中的位置
*/
int LocateElem_Sq(SqList &L, ElemType e, Status (*compare)(ElemType,ElemType)){
//工作指針p
ElemType *p;
//查找操作首先要判斷線性表是否為空，對空表執行查找操作沒有意義
//if(ListIsEmpty_Sq(L)) <=> if(ListIsEmpty_Sq(L) != 0)
if(ListIsEmpty_Sq(L)) {
return ERROR;
}//if
//設置查找的起始位置
int i = 1; //i的初值為第一個元素的位序
p = L.elem; //p的初值為第一個元素的存儲位置
//以compare函數返回值為基准在線性表中查找元素e
while(i <= L.length && !(*compare)(*p++, e)) {
++i;
}//while
//如果找到了元素e的位置則返回其所在位置i
if(i <= L.length) {
return i;
}//if
else { //如果沒找到則返回0
return 0;
}//else
} //LocateElem_Sq
//7. ------------------線性表中合並元素的操作----------------
/*
函數：MergeList_Sq
參數：SqList La 被合並的線性表a
SqList Lb 被合並的線性表b
SqList &Lc 合並后得到的線性表c
返回值：狀態碼，操作成功返回OK，操作失敗返回ERROR
作用：已知順序線性表La和Lb的元素按值非遞減排列。
歸並La和Lb得到新的順序線性表Lc，Lc的元素也按值非遞減排列。
*/
Status MergeList_Sq(SqList La, SqList Lb, SqList &Lc) {
//工作指針pa, pb, pc分別保存了線性表a、b、c存儲元素內存空間的首地址
//指針pa_last指向線性表a的表尾元素, pb_last指向線性表b表尾元素
ElemType *pa, *pb, *pc, *pa_last, *pb_last;
//合並操作要求線性表a和線性表b不能為空
//if(ListIsEmpty_Sq(La)) <=> if(ListIsEmpty_Sq(La) != 0)
if(ListIsEmpty_Sq(La)) {
return ERROR;
}//if
//if(ListIsEmpty_Sq(Lb)) <=> if(ListIsEmpty_Sq(Lb) != 0)
if(ListIsEmpty_Sq(Lb)) {
return ERROR;
}//if
//工作指針pa, pb保存了線性表a、b存儲元素內存空間的首地址
pa = La.elem;
pb = Lb.elem;
//合並后的線性表c表長等於被合並的線性表a和b的表長之和
Lc.listsize = Lc.length = La.length + Lb.length;
//確定線性表c的長度之后為其申請內存空間，大小等於a和b兩表之和
pc = Lc.elem = (ElemType *)malloc(Lc.listsize * sizeof(ElemType));
//檢查內存分配是否成功
if(!Lc.elem){ //if(!Lc.elem) <=> if(Lc.elem == NULL)
printf("內存申請失敗！");
exit(OVERFLOW); //若內存分配失敗，則退出程序
}//if
//計算出線性表a和b的表尾元素所在位置，分別賦給對應的指針變量pa_last和pb_last
pa_last = La.elem + La.length - 1;
pb_last = Lb.elem + Lb.length - 1;
//合並pa和pb到pc
//首先將線性表a和b中較短的一個完全合並到pc，另一個只合並一部分
while (pa <= pa_last && pb <= pb_last) { //循環終止條件：指示線性表a或b的工作指針有一個走到表尾
//比較線性表a和b相同位置的元素，取較小的插入到表c末尾
if (*pa <= *pb) {
*pc++ = *pa++;
}//if
else {
*pc++ = *pb++;
}//else
}//while
//看看線性表a和b中的所有元素是否都處理完了，若沒有，處理剩余元素
//如果線性表a沒有處理完，由於線性表a的剩余元素已經有序，直接將它們插入表c就可以了
while (pa <= pa_last) {
*pc++ = *pa++; // 插入La的剩余元素
}//while
//如果線性表b沒有處理完，由於線性表b的剩余元素已經有序，直接將它們插入表c就可以了
while (pb <= pb_last) {
*pc++ = *pb++; // 插入Lb的剩余元素
}//while
//操作成功
return OK;
} // MergeList_Sq
//8.-----------------------線性表的銷毀操作--------------------
/*
函數：DestoryList_Sq
參數：SqList &L 被銷毀的線性表
返回值：狀態碼，操作成功返回OK，操作失敗返回ERROR
作用：銷毀線性表並釋放內存空間
*/
void DestoryList_Sq(SqList &L) {
free(L.elem);
L.elem = NULL;
printf("內存空間釋放成功!\n");
} //DestoryList_Sq
//9.-----------------------線性表的排序操作-------------------
/*
函數：SortList_Sq
參數：SqList &L 被排序的線性表
返回值：狀態碼，操作成功返回OK，操作失敗返回ERROR
作用：對線性表中的元素進行排序，使其降序排列
*/
Status SortList_Sq(SqList &L) {
//將線性表中的元素排序，使用冒泡法，現在沒有學過排序的內容，
//此段代碼我當時也是從網上找的，看不懂的話先忽略它
/*傳統冒泡排序中每一趟排序操作只能找到一個最大值或最小值,
我們考慮利用在每趟排序中進行正向和反向兩遍冒泡的方法
一次可以得到兩個最終值(最大者和最小者),從而使排序趟數幾乎減少了一半*/
//檢查線性表是否為空表，對空表進行排序操作沒有意義
//if(ListIsEmpty_Sq(L)) <=> if(ListIsEmpty_Sq(L) != 0)
if(ListIsEmpty_Sq(L)) {
return ERROR;
}//if
//設置變量的初始值
int low = 0;
int high = L.length-1;
int tmp, j;
while (low < high) {
//正向冒泡,找到最大者
for (j = low; j < high; ++j) {
if (L.elem[j] > L.elem[j + 1]) {
tmp = L.elem[j];
L.elem[j] = L.elem[j + 1];
L.elem[j + 1] = tmp;
}//if
}//for
//修改high值, 前移一位
--high;
//反向冒泡,找到最小者
for (j = high; j > low; --j) {
if (L.elem[j] < L.elem[j - 1]) {
tmp = L.elem[j];
L.elem[j] = L.elem[j - 1];
L.elem[j - 1] = tmp;
}//if
}//for
//修改low值,后移一位
++low;
}
} //SortList_Sq
//10.----------------------線性表的輸出操作------------------
/*
函數：Print
參數：ElemType e 被訪問的元素
返回值：狀態碼，操作成功返回OK，操作失敗返回ERROR
作用：訪問元素e的函數，通過修改該函數可以修改元素訪問方式，
該函數使用時需要配合遍歷函數一起使用。
*/
Status Print(ElemType e){ // 元素訪問函數
//指定元素的訪問方式是控制台打印輸出
printf("%6.2f ", e);
//操作成功
return OK;
}//Print
/*
函數：ListTraverse_Sq
參數：SqList L 順序表L
Status(* visit)(ElemType) 函數指針，指向元素訪問函數。
返回值：狀態碼，操作成功返回OK，操作失敗返回ERROR
作用：調用元素訪問函數完成線性表的遍歷，所謂遍歷就是逐一訪問線性表中的每個元素。
*/
Status ListTraverse_Sq(SqList L, Status(* visit)(ElemType)){
//i聲明在這里不是好的寫法，應該將i寫在for循環中，有利於縮短i的作用域，及早回收其內存空間。
//但是由於C語言不兼容這種寫法，考慮到兼容性所以將i寫在外面。（C++支持這種寫法）
int i;
//調用元素訪問函數逐個訪問線性表中的每個元素
for(i = 0; i < L.length; ++i){
//if(!visit(L.elem[i])) <=> if(visit(L.elem[i]) != ERROR)
if(!visit(L.elem[i])) {
return ERROR; //如果訪問某個元素失敗則退出
}//if
}//for
//便利完成后打印空行，作用是在控制台輸出時能夠區分開不同的輸出
//使輸出清楚美觀
printf("\n");
return OK;
}//ListTraverse_Sq
//***************************************主函數********************************************
int main(int argc, char *argv[]){
SqList L1, L2, L3; //聲明三個線性表
int i; //i代表元素的位序
ElemType e; //e用於傳入和保存元素的值
printf("*******************************線性順序表測試程序*******************************\n");
//---------------------------------測試初始化功能----------------------------------
printf("---------------------------------測試初始化功能---------------------------------\n");
printf("->初始化線性表L1\n");
InitList_Sq(L1, LIST_INIT_SIZE); //初始化線性表1
ListInput_Sq(L1); //為L1中的元素賦值
printf("恭喜您，線性表L1初始化並賦值完畢！\n\n");
printf("->初始化線性表L2\n");
InitList_Sq(L2, LIST_INIT_SIZE); //初始化線性表2
ListInput_Sq(L2); //為L2中的元素賦值
printf("恭喜您，線性表L2初始化並賦值完畢！\n\n");
//-----------------------------測試輸出功能---------------------------------------
printf("----------------------------------測試輸出功能----------------------------------\n");
printf("初始化操作之后L1、L2的元素為：\n");
printf("->輸出線性表L1的所有元素：\n");
ListTraverse_Sq(L1, Print); //在執行其他操作之前先輸出一遍所有元素，以供參考
printf("->輸出線性表L2的所有元素：\n");
ListTraverse_Sq(L2, Print);
//-----------------------------測試插入功能---------------------------------------
printf("\n----------------------------------測試插入功能----------------------------------\n");
printf("->現在為L1插入元素\n"); //為線性表L1插入一個元素
printf("您想在線性表L1的哪個位置之前插入值？\n");
scanf("%d", &i);
printf("您想在線性表L1的該位置之前插入的值為多少？\n");
scanf("%f", &e);
ListInsert_Sq(L1,i,e);
printf("執行插入操作后線性表L1的所有元素為：\n"); //輸出執行操作后的線性表，以便與原始結果對比
ListTraverse_Sq(L1,Print);
printf("->現在為L2插入元素\n");
printf("您想在線性表L2的哪個位置之前插入值？\n"); //為線性表L2插入一個元素
scanf("%d", &i);
printf("您想在線性表L2的該位置之前插入的值為多少？\n");
scanf("%f", &e);
ListInsert_Sq(L2, i, e);
printf("執行插入操作后線性表L2的所有元素為：\n"); //輸出執行操作后的線性表，以便與原始結果對比
ListTraverse_Sq(L2, Print);
printf("\n插入操作執行完畢！\n\n");
//-----------------------------測試刪除功能---------------------------------------
printf("----------------------------------測試刪除功能----------------------------------\n");
printf("->現在在L1中刪除元素\n"); //在L1中刪除一個元素
printf("您想在線性表L1的哪個位置之前刪除值？\n");
scanf("%d", &i);
ListDelete_Sq(L1, i, e);
printf("被刪除的元素為%f\n", e);
printf("執行刪除操作后線性表L1的所有元素為：\n"); //輸出執行操作后的線性表，以便與原始結果對比
ListTraverse_Sq(L1, Print);
printf("->現在在L2中刪除元素\n"); //在L2中刪除一個元素
printf("您想在線性表L2的哪個位置之前刪除值？\n");
scanf("%d", &i);
ListDelete_Sq(L2, i, e);
printf("被刪除的元素為%f\n", e);
printf("執行刪除操作后線性表L2的所有元素為：\n"); //輸出執行操作后的線性表，以便與原始結果對比
ListTraverse_Sq(L2, Print);
printf("\n刪除操作執行完畢！\n\n");
//-----------------------------測試查找功能---------------------------------------
printf("----------------------------------測試查找功能----------------------------------\n");
printf("您想在線性表L1中查找的值為：\n");
scanf("%f", &e);
i = LocateElem_Sq(L1, e, compare);
if(i == 0){
printf("對不起，沒有找到您輸入的元素！\n");
}//if
else {
printf("恭喜，找到啦！您想要的元素在表中的位序為%d\n",i);
}//else
printf("您想在線性表L2中查找的值為：\n");
scanf("%f", &e);
i = LocateElem_Sq(L2, e, compare);
if(i == 0) {
printf("對不起，沒有找到您輸入的元素！\n");
}//if
else {
printf("恭喜，找到啦！您想要的元素在表中的位序為%d\n", i);
}//else
printf("\n查找操作執行完畢！\n\n");
//---------------------------------測試排序功能---------------------------------------
printf("----------------------------------測試排序功能----------------------------------\n");
printf("排序前 L1、L2的元素為：\n");
printf("->線性表L1的所有元素：\n");
ListTraverse_Sq(L1, Print); //在執行操作之前先輸出一遍所有元素，以供參考
printf("->線性表L2的所有元素：\n");
ListTraverse_Sq(L2, Print);
SortList_Sq(L1); //分別對L1和L2進行排序
SortList_Sq(L2);
printf("排序后 L1、L2的元素為：\n");
printf("->線性表L1的所有元素：\n");
ListTraverse_Sq(L1, Print); //執行操作之后再輸出一遍所有元素
printf("->線性表L2的所有元素：\n");
ListTraverse_Sq(L2, Print);
printf("\n排序操作執行完畢！\n\n");
//-----------------------------測試歸並(合並)功能---------------------------------------
printf("----------------------------------測試歸並功能----------------------------------\n");
printf("->初始化線性表L3\n");
InitList_Sq(L3, L1.listsize + L2.listsize); //初始化線性表3，空間大小為L1與L2的和，但不給元素賦值
printf("線性表L3初始化成功！開始歸並操作\n\n");
MergeList_Sq(L1, L2, L3);
printf("->線性表L3的所有元素：\n");
ListTraverse_Sq(L3, Print);
printf("歸並操作執行完畢！\n\n");
//--------------------------------測試銷毀功能------------------------------------------
printf("----------------------------------測試銷毀功能----------------------------------\n");
printf("->銷毀線性表L1：");
DestoryList_Sq(L1);
printf("->銷毀線性表L2：");
DestoryList_Sq(L2);
printf("->銷毀線性表L3：");
DestoryList_Sq(L3);
printf("銷毀操作執行完畢！\n\n");
printf("所有操作執行完畢，測試成功！\n");
return 0;
}
/* --------------------------------- 運行結果 ------------------------------
*******************************線性順序表測試程序*******************************
---------------------------------測試初始化功能---------------------------------
->初始化線性表L1
內存申請成功！
線性表創建成功！
您想輸入幾個元素，請輸入個數，最多不可以超過:100
5
請輸入線性表L的元素，中間用空格隔開，最多不可以超過100個元素
1 45 7 89 6
該線性表初始化操作已完成！
恭喜您，線性表L1初始化並賦值完畢！
->初始化線性表L2
內存申請成功！
線性表創建成功！
您想輸入幾個元素，請輸入個數，最多不可以超過:100
10
請輸入線性表L的元素，中間用空格隔開，最多不可以超過100個元素
45 75 24 16 23 45 89 62 51 44
該線性表初始化操作已完成！
恭喜您，線性表L2初始化並賦值完畢！
----------------------------------測試輸出功能----------------------------------
初始化操作之后L1、L2的元素為：
->輸出線性表L1的所有元素：
1.00 45.00 7.00 89.00 6.00
->輸出線性表L2的所有元素：
45.00 75.00 24.00 16.00 23.00 45.00 89.00 62.00 51.00 44.00
----------------------------------測試插入功能----------------------------------
->現在為L1插入元素
您想在線性表L1的哪個位置之前插入值？
2
您想在線性表L1的該位置之前插入的值為多少？
55
執行插入操作后線性表L1的所有元素為：
1.00 55.00 45.00 7.00 89.00 6.00
->現在為L2插入元素
您想在線性表L2的哪個位置之前插入值？
6
您想在線性表L2的該位置之前插入的值為多少？
33
執行插入操作后線性表L2的所有元素為：
45.00 75.00 24.00 16.00 23.00 33.00 45.00 89.00 62.00 51.00 44.00
插入操作執行完畢！
----------------------------------測試刪除功能----------------------------------
->現在在L1中刪除元素
您想在線性表L1的哪個位置之前刪除值？
4
被刪除的元素為7.000000
執行刪除操作后線性表L1的所有元素為：
1.00 55.00 45.00 89.00 6.00
->現在在L2中刪除元素
您想在線性表L2的哪個位置之前刪除值？
2
被刪除的元素為75.000000
執行刪除操作后線性表L2的所有元素為：
45.00 24.00 16.00 23.00 33.00 45.00 89.00 62.00 51.00 44.00
刪除操作執行完畢！
----------------------------------測試查找功能----------------------------------
您想在線性表L1中查找的值為：
55
恭喜，找到啦！您想要的元素在表中的位序為2
您想在線性表L2中查找的值為：
99
對不起，沒有找到您輸入的元素！
查找操作執行完畢！
----------------------------------測試排序功能----------------------------------
排序前 L1、L2的元素為：
->線性表L1的所有元素：
1.00 55.00 45.00 89.00 6.00
->線性表L2的所有元素：
45.00 24.00 16.00 23.00 33.00 45.00 89.00 62.00 51.00 44.00
排序后 L1、L2的元素為：
->線性表L1的所有元素：
1.00 6.00 45.00 55.00 89.00
->線性表L2的所有元素：
16.00 23.00 24.00 33.00 44.00 45.00 45.00 51.00 62.00 89.00
排序操作執行完畢！
----------------------------------測試歸並功能----------------------------------
->初始化線性表L3
內存申請成功！
線性表創建成功！
線性表L3初始化成功！開始歸並操作
->線性表L3的所有元素：
1.00 6.00 16.00 23.00 24.00 33.00 44.00 45.00 45.00 45.00 51.00 55.00 62.00 89.00 89.00
歸並操作執行完畢！
----------------------------------測試銷毀功能----------------------------------
->銷毀線性表L1：內存空間釋放成功!
->銷毀線性表L2：內存空間釋放成功!
->銷毀線性表L3：內存空間釋放成功!
銷毀操作執行完畢！
所有操作執行完畢，測試成功！
--------------------------------
Process exited with return value 0
Press any key to continue . . .
*/
線性順序表動態內存分配(C語言實現)
免責聲明！
本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。