顺序表的插入删除归并排序最值操作C++实现代码

本程序包括：
数组静态分配建立顺序表；顺序表的插入、删除操作；顺序表的排序；顺序表的查找最大值；顺序表的归并操作，基本涵盖了顺序表的所有基本操作。
这个程序都是最简化的版本，日后可以拓展功能，比如可以从键盘键入数据来初始化顺序表等等。
介绍顺序表的文章很多，我只提供代码，文章中作了详细的注释，相信看过一点数据结构的都能看懂``。

#include <iostream>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 50
using namespace std;

typedef int Status;
typedef int Elemtype;

/**********线表结构体**************/
typedef struct
{
  Elemtype data[MAXSIZE];
  int length;
}SqList;



/**********顺序表的初始化**************/
int InitList(SqList &L,int a[],int n)//用数组对顺序表初始化
{
    L.length = 0;                    //对length初始化
    if(n < 0 || n > MAXSIZE)         //初始化的数组非法或者超出线表最大的长度
        return ERROR;
    for(int i = 0;i < n;i++)
    {
          L.data[i] = a[i];
          L.length++;                //每增加一个data，length的长度要相应的增加一位
    }
    return OK;
}


/**********遍历输出顺序表中的data**************/
void DisplayList(SqList L)           //显示线表的data
{
    for(int i = 0;i < L.length;i++)
        cout<<L.data[i]<<" ";
    cout<<endl;
}

/**********顺序表的插入操作**************/
int List_Insert(SqList &L,int i,int e)//L为线表的引用型，因为要改变顺序表，i为插入的位置，e为插入的元素
{
    if(i<1||i>L.length+1||i==MAXSIZE)//插入的位置小于1或插入的额位置在最后一个位置的还要后面或插入的范围超出了数组的长度
    return 0;
    cout<<"在第"<<i<<"个位置插入："<<e<<endl;
    if(i<=L.length)
   {
        for (int j=L.length-1;j>=i-1;j--)
            L.data[j+1]=L.data[j];
   }
    L.data[i-1]=e;
    L.length++;
    return 1;
}


/**********顺序表删除操作**************/
int List_Dlete(SqList &L,int i)
{
    if(L.length==0)
        return ERROR;               //顺序表为空，异常
    if(i<0||i>L.length)
        return ERROR;               //不在可删除的范围，异常
    int e = L.data[i-1];
    if(i<L.length)                  //删除位置在顺序表内部
        {
        for(int j = i-1;j<L.length-1;j++)
            L.data[j]=L.data[j+1];
        }                           //后一个覆盖前一个
    L.length--;
    cout<<"删除了第"<<i<<"个元素，其值是："<<e<<endl;
    return OK;
}



/**********遍历输出最大值**************/
void List_MAX(SqList L)//不需要引用型，因为不改变顺序表本身，查找出最大值输出即可
{
    int max = L.data[0];//假设顺序表第一个元素最大，并把这个值赋给max这个整型变量
    int maxIdx = 0;     //在这里我们定义一个maxIdx，用来输出最大值的下标，用maxIdx+1作为最大值在顺序表中的位置
    for(int i = 0;i<L.length;i++)
       {
            if(max < L.data[i])
                {
                    max =L.data[i];
                    maxIdx = i;
                }
       }
    cout<<"最大值为:"<<max<<"\t"
        <<"最大值在顺序表第"
        <<maxIdx+1<<"位。"<<endl;
}

/**********顺序表排序 **************/
void List_Seq(SqList &L)     //简单的冒泡排序算法
{
    int temp;
    for (int j = 0;j<L.length;j++)
    {
        for(int i = 0;i < L.length-1;i++)
        {
            if(L.data[i] > L.data[i+1])
            {
                temp = L.data[i+1];
                L.data[i+1] = L.data[i];
                L.data[i] = temp;
            }
        }
    }
}

/*这段是一个排序的错误的代码，我注释掉了，可以看一下我第一次写的时候的天真操作
void List_Max(SqList &L)
{
    int temp;          //定义一个交换中间变量
    for(i = 0;i < L.length;i++)
        {
            if(L.data[i] > L.data[i+1])
            {
                temp = L.data[i+1];
                L.data[i] = L.data[i+1];
                L.data[i+1] = temp;
            }
        }
}

我自己搞了个例子就给推翻了我的想法：

                      1 5 3 2 7 6
           第一次循环 1 5 3 2 7 6
                    二1 3 5 2 7 6
                    三1 3 2 5 7 6
                    四1 3 2 5 7 6
                    五1 3 2 5 6 7
*/


/**********顺序表的归并操作**************/
void List_Merge(SqList L1,SqList L2,SqList &L3)
{

    List_Seq(L1);
    List_Seq(L2);
    int i = 0,j = 0,k = 0 ;//i ,j ,k分别用来标记顺序表L,J和新的顺序表
    while(i < L1.length && j < L2.length)//不能超出最短的顺序表。第一部分：在两个顺序表长度相等的范围内
    {
        if(L1.data[i] < L2.data[j])
           L3.data[k++] = L1.data[i++];//   相当于：M.data[k]=L,data[i]; k++; i++;
        else
            L3.data[k++]=L2.data[j++];
    }
    while(i<L1.length)//第二部分：较长的顺序表多出来的一部分
        L3.data[k++] = L1.data[i++];
    while(j<L2.length)
        L3.data[k++] = L2.data[j++];
    L3.length = k;
    DisplayList(L3);
}

/*
这是我归并操作的算法的思路，注释掉。
L1: 1  5  8  4  3
L2: 2 10  7  4  6        9  8
先分别排序：
1  3  4  5  8
2  4  6  7  8  9  10
归并：
1  2  3  4  4  5  6  7  8  8  9  1

*/


int main()
{
    SqList S,D,F;
    int num1[6]={5,7,1,3,4,9};
    int num2[4]={1,6,2,4};
    InitList(D,num2,4);
    InitList(S,num1,6);//初始化顺序表
    cout<<"线表中的初始data为:"<<endl;
    DisplayList(S);//输出顺序S表中的data

    List_Insert(S,2,8);//对S这个线性表在第2个位置上插入8
    cout<<"New data:"<<" "<<endl;
    DisplayList(S);//输出插入新元素后的顺序表中的data
    List_Dlete(S,3);
    cout<<"New data:"<<" "<<endl;
    DisplayList(S);
    List_MAX(S);//找最大值
    InitList(D,num2,4);
    List_Seq(S);//排序
    cout<<"New data sequence:"<<endl;
    DisplayList(S);
    cout<<"归并后的顺序表中的data："<<endl;
    List_Merge(S,D,F);//归并
    return 0;

}