当

当

网

物

流

模

式

调

研

报

告

专业：市场营销

班级：B090403班

组员：B09040305 胡忠丹

B09040307 李帅帅

当当网物流模式调研报告

第一部分 调查情况介绍

一、调查时间 20xx年5月28日至6月2号

二、调查对象 当当网的物流系统

三、调查方法 二手资料法及访问法

四、调查目的 分析当当网物流的优劣势并根据问题提出建议 第二部分 当当网物流系统介绍及分析

一、国内电子商务物流现状

近年来，电子商务的发展，扩大了企业的销售范围，改变了企业传统的销售方式以及消费者的购物方式，使得送货上门等物流服务成为必然，促进了我国物流行业的兴起。但目前，我国的物流水平仍难以满足电子商务的需求。

首先，从发达国家来看，第三方物流的功能是设计、执行以及管理客户供应链中的物流需求，其特点是依据信息和物流专业知识，以最低的成本提供客户需要的物流管理和服务。而现在，我国多数物流企业是在传统体制下物资流通企业基础上发展而来的，企业服务内容多数仍是仓储、运输、搬运，很少有物流企业能够做到提供综合性的物流服务，第三方物流服务的功能尚不能得到很好的发挥。我国的物流企业，无论是物流服务的硬件还是软件与电子商务要求提供的高效率低成本的第三方物流服务还有较大的差距，信息收集、加工、处理、运用能力，物流的专门知识，物流的统筹策划和精细化组织与管理能力都明显不足。 其次，条块分割的物流管理和流通体制制约着物流业的发展。电子商务环境下，物流的专业化分工特点虽然日益明显，但是物流的组织和管理却不断向综合性发展，各种物流方式和物流载体之间的联系越来越紧密。但是，我国目前的物流行业管理仍沿用着计划经济时期的部门分割体制。与物流相关的各部分分别由铁道、交通、民航、内贸等不同政府部门进行管理。依据这种条块管理体制，形成了自上而下的纵向隶属和管理格局，严重制约着在全社会范围内经济合理的对物流进行整体统筹和规划，妨碍着物流的社会化进程。

二、当当网介绍

当当网是北京当当网信息技术有限公司营运的一家中文购物网站，以销售图书、音像制品为主，兼具发展小家电、玩具、网络游戏点卡等其他多种商品的销售，总部设在北京，是全球最大的综合性中文网上购物商城。19xx年11月，当当

网正式开通，20xx年12月8日，当当网首次登陆美国股市，由国内著名出版机构科文公司、美国老虎基金、美国IDG集团、卢森堡剑桥集团、亚洲创业投资基金共同投资成立。目前是全球最大的中文网上图书音像商城，面向全世界中文读者提供30多万种中文图书和音像商品，每天为成千上万的消费者提供方便、快捷的服务，给网上购物者带来极大的方便和实惠。

成立十年来，当当网销售业绩增加了400倍。当当网在线销售的商品包括了家居百货、化妆品、数码、家电、图书、音像、服装及母婴等几十个大类，逾百万种商品，在库图书达到60万种。目前每年有近千万顾客成为当当网新增注册用户，遍及全国32个省、市、自治区和直辖市。每天有上万人在当当网买东西，当当网每月销售商品超过2000万件。

三、当当网物流模式介绍

1、在配送模式上选择了第三方物流的方式。

当当网采用第三方物流的配送模式。当当进行了配送环节的创新。中国没有UPS, FedEx这样覆盖全国乃至全球的物流企业，当当现在的做法是航空、铁路、城际快递、当地快递公司齐上。 当当网目前在仓储和配送方面采用内部人员和外部人员分工合作的形式，仓储和包裹由当当网来完成，配送由100多家合作的快递公司支持，可以用更少的运费到达更多的地方。为了保证可以准时、安全送达产品，当当网会把任务交给那些支付一定押金的快递公司和快递员。尽管管理和协调的难度增加，但却解决了最短时间内送货上门的问题。当当主要是依靠专业快递公司进行配送，与民营快递公司合作，并在一些大城市扩建了自己的仓储中心。并且通过选好配送公司，从而以更快的速度为消费者提供更高的服务。

2、系统支撑下的即时出库。

要想将每个订单都快速准确地出库配送需要IT系统的强大支撑。商品入库系统自动记录了每件商品的库存位置。在成千上万的订单中，系统自动把仓库中同样的商品、同一区域的商品，分配在一张拣货单上，这张拣货单在系统中生成时，上面所有的商品已经按照路径排列了顺序，拣货员按照顺序拣货在仓库的走的便是优化的路线，不会走回头路。这样大大提高了拣货的效率。

3、仓库的货品摆放系统也会进行优化。

所有的商品在当当的系统中都有销售记录，哪些商品动销率比较高，哪些商品次之，系统都会根据数据进行计算。那些动销率比较高的商品会被摆放在离出口更近的地方。但动销率不是固定不变的，有些季节性产品，比如电风扇、羽绒

服等动销率变化明显的商品，在系统中会设计一些参数，使管理人员到一定时期对其仓储位置是进行调整或者是退货给供应商。另外，一些促销产品，在当当网首页主推的商品的动销率也比较高，也会优先存储于更方便的位置。

4、多个储物分仓和供应商优化管理。

在当当网的系统里，已经将每个仓库覆盖的区域进行了数据统计。一个用户在当当网前台下的订单，在后台，系统会自动分配给最近的仓库。比如，南京的订单就会自动分配给上海仓，而重庆用户的订单则会自动分配给成都仓。另外，当当有一个团队专门管理供货商，在系统里，每个供货商的供货周期及供货能力都有记录，然后再根据每个商品对应的供货商的供货周期设定补货提醒，以达到最优化的库存。

5、减少“腿”的数量，也即提升运送公司在区域内的运送效率。

比如北京川都物流和北京迅强快递都是当当的配送服务供应商，原先这两家公司的盈利能力都不是很强。他们原先都是负责北京全城业务的，站点很多，由于每个站点都要招管理人员、快递员，但每个站点的配送量又不大，效率低，盈利能力差。当当启动大商战略之后，把这两家配送商变成区域配送商。比如，川都物流只专注丰台区，而迅强快递将站点和业务收缩至海淀区。这样一来，配送半径变小了，配送密度加大了，对于配送公司来说，单位包裹成本降低了，而对于当当网来说，单位包裹的配送时间变少。

四、当当网物流模式分析及解决方案

1、优势：

(1)将企业本就有限的资源集中于巩固和扩展自身核心业务之上。

(2)供应商难以满足其小批量、多批次的货物提供，第三方物流可根据情况

在货物配送中进行统筹安排，有效地降低成本;。

(3)减少企业资金投资和资金短缺风险:

(4)第三方物流使企业能够拓展国际业务:

(5)供应链管理思想使第三与物流供需双方形成一种战略联关系，在共赢的基础上，保证企业对变化的客户需求具有敏捷反应的姿态;

(6)第三方物流有利于提升社会效益。

3、当当网在费用上比卓越省。在送货时间上卓越网要比当当网快一点。卓越网拥有了亚马逊先进的管理理念和世纪卓越快递公司的发展，而当当网在这一点上要做着差一点。总体上说还是当当网更好一些。总的来说，当当网在中国的

物流体系建设的比较早，拥有完整的物流配送网络和先进的管理方法。从总体来考虑，当当网在物流系统的建设和应用上要比卓越网好一些，但随着亚马逊先进的管理理念的注入，卓越网的发展也很迅速。他们经营模式不同 淘宝主要是C2C，卓越，当当，凡客诚品主要是B2C；网上商城的商品范围不同 淘宝，卓越，当当是网上综合性的商城，而凡客诚品是比较单一的，主要卖衣服和家具。物流配送不同 卓越，当当，凡客诚品都有自己的物流配送公司，虽然在一定的情况下也会让其他第三方物流公司帮忙，但主要还是靠自己，淘宝是全部靠与第三方物流公司合作。

4、问题

（1）网上订货迟迟送不到，物流配送速度慢

物流环节一直是各大B2C电子商务企业最为重视，也被消费者诟病最为突出的一个环节。在目前几家B2C电子商务网站中，当当网的物流和配送环节受到的影响最为明显，竞争对手如卓越、京东商城这个现象并不突出，据消费者反映，在当当网下订单后，货配送公司迟迟不送货，多次投诉均石沉大海。不仅10天没有收到货物，且一直到最后确定货物丢失，当当网客服方面竟然“一言不发”。当当网在供应链管理方面后劲不足。

（2）库存管理不当，入库特别慢

许多供货商表示，在入库的时候，当当网的库房管理方面也存在许多的问题，最为突出的问题就是入库特别慢。供货商最头疼的并不是这一点，而是来自当当网的管理，据称供货商如果不能令当当网采购部的工作人员满意，很有可能会出现下单后收货速度慢的问题，在这种情况下供应商们都面临着入库难的问题。除此之外，还有供应商反应，由于当当网的库管人员更迭过快，不同的库管人员上任之后都会采取不同的管理方法，造成许多环节的改变，从而导致入库产品管理混乱的问题。

（3）网上搜索抱怨居多

笔者采访了一部分网友：都声称经过了无数次的网购经验，在当当网订购的书刊，在半个月之后才收到当当网寄来。之后就在也没在当当网购买过商品，最后还是选择了其他平台。“经过一次当当网的购买经历，肯定不会再上当当网”，“当当网这种发货速度实在令我感到不可理喻”几名网购用户说道。

在此笔者不禁问如果仅仅是这样一个物流水平，那为何还要选择网购？网友既然选择网络购物，就是一个省钱和方便的信念。而如今一个星期都不能够给

网友发货，还不如自行去书店购买。试想下在当今互联网发达的情况下，当当网以这种繁琐流程的服务态度还是不足的。

5、当当网的物流解决方案

（1）将库存控制在最低水平，实行零库存运转。 当当网通过与供应商建立良好的合作关系， 实现了对库存的有效控制。 一般情况下， 当当网是在顾客买书下了订单后，才从出版商那里进货。购书者选择自需方式进行支付 书款，而当当网却在图书售出后才向出版商付款，这就使得它的资金周转比传统书店要 顺畅得多。由于保持了低库存，当当的库存周转速度很快。

（2）降低退货比率。 虽然当当网经营的商品种类很多，但由于对商品品种选择适当，价格合理，商品质 量和配送服务等能满足顾客需要，所以保持了很低的退货比率。极低的退货比率小仅减 少了企业的退货成本，也保持了较高的顾客服务水平并取得良好的商业信誉。

（3）根据不同商品类别建立不同的配送中心，提高配送中心作业效率。 当当网的配送中心按商品类别设立，不同的商品由不同的配送中心进行配送。这样 做有利于提高配送中心的专业化作业程度，使作业组织简单化、规范化，既能提高配送 中心作业的效率，又可降低配送中心的管理和运营费用。

第三部分 总结

综上所述，我们可以看出，制约电子商务发展的三大因素中，物流是关键因素，而配送模式决定配送成本及速度，由配送体制本身的时间问题导致了整个 B2C 电子商务市场的现状。

由此，我们提出的相关建议是：对于当当而言，必须要认真分析各种配送模式的优缺点，及自身情况，选择最优的配送模式。比如在自己的销售密集区可以自建配送中心进行配送服务，自己的销售密集区可以自建配送中心进行配送服务，密集程度稍低的区域选择第三方物流配送，在偏远区域用邮政系统。第三方物流配送，在偏远区域用邮政系统。在配送体系上，当当也可以进行一些创新，比如可以通过提供多种配送模式和时间的服务，对不同配送时间要求的顾客收取不同费用，满足顾客不同层次的需要，争取各种需求偏好强烈的顾客。

第二篇：数据结构课程设计排序算法总结

排序算法：

(1) 直接插入排序  (2) 折半插入排序(3) 冒泡排序 (4) 简单选择排序  (5) 快速排序 (6) 堆排序  (7) 归并排序

【算法分析】

（1）直接插入排序；它是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好的序的有序表中，从而得到一个新的、记录数增加1的有序表。

（2）折半插入排序：插入排序的基本操作是在一个有序表中进行查找和插入，我们知道这个查找操作可以利用折半查找来实现，由此进行的插入排序称之为折半插入排序。折半插入排序所需附加存储空间和直接插入相同，从时间上比较，折半插入排序仅减少了关键字间的比较次数，而记录的移动次数不变。

（3）冒泡排序：比较相邻关键字，若为逆序（非递增），则交换，最终将最大的记录放到最后一个记录的位置上，此为第一趟冒泡排序；对前n-1记录重复上操作，确定倒数第二个位置记录；……以此类推，直至的到一个递增的表。

(4)简单选择排序：通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i（1<=i<=n）个记录交换之。

(5)快速排序:它是对冒泡排序的一种改进，基本思想是，通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

(6)堆排序:             使记录序列按关键字非递减有序排列，在堆排序的算法中先建一个“大顶堆”，即先选得一个关键字为最大的记录并与序列中最后一个记录交换，然后对序列中前n-1记录进行筛选，重新将它调整为一个“大顶堆”，如此反复直至排序结束。

(7)归并排序:归并的含义是将两个或两个以上的有序表组合成一个新的有序表。假设初始序列含有n个记录，则可看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2或1的有序子序列；再两两归并，……，如此重复，直至得到一个长度为n的有序序列为止，这种排序称为2-路归并排序。

【算法实现】

（1）直接插入排序：

void InsertSort(SqList &L){

    for(i=2;i<=L.length ;i++)

        if(L.elem[i]<L.elem[i-1])

        {

            L.elem[0]=L.elem [i];                             //复制为哨兵

            L.elem [i]=L.elem [i-1];

            for(j=i-2;L.elem [j]>L.elem[0];j--)

                L.elem [j+1]=L.elem [j];

            L.elem [j+1]=L.elem[0];

        }

}

（2）折半插入排序：

void BInsertSort(SqList &L){

//对顺序表L作折半插入排序

    for(i=2;i<=L.length ;i++){

        L.elem[0]=L.elem [i];

        low=1;  high=i-1;

        while(low<=high){

            m=(low+high)/2;

            if(L.elem [0]>L.elem [m])   low=m+1;

            else   high=m-1;

        }

        for(j=i-1;j>=high+1;j--)

            L.elem [j+1]=L.elem [j];

        L.elem [high+1]=L.elem[0];

    }

}

（3）冒泡排序：

void BubbleSort(SqList &L){

        for(i=L.length;i>=2;i--)                 

        for(j=1;j<i;j++)

            if(L.elem[j]>L.elem [j+1])

                L.elem [j]?L.elem [j+1];

}

(4)简单选择排序：

void SelectSort(SqList &L){

   for(int i=1;i<=L.length-1 ;i++){

       j=SelectMinKey(L,i);             //在L.elem[i..L.length]中选择最小记录

       if(i!=j)   L.elem [i]?L.elem [index];

   }

}

(5)快速排序:

int Partition(SqList &L,int low,int high){

//将L.elem[low...high]一分为二

pivot=L.elem[low]; 

while(low<high){

while(low<high&&L.elem[high]>=pivot)  high--;

           L.elem[low] ?L.elem[high];

     while(low<high&&L.elem[high]<=pivot)  low++;

L.elem[low] ?L.elem[high];

}

return low;

}

void QSort(SqList &L,int low,int high){

//对顺序表L中的子序列L.elem[low...high]进行快速排序

if(low<high){

pivot=Partition(L,low,high);

QSort(L,low,pivot-1);

QSort(L,pivot+1,high);

}

}             

void QuickSort(SqList &L) {

//对顺序表L作快速排序

QSort(L,1,L.length);

}

(6)堆排序:  

void HeapAdjust(SqList &L,int s,int m){

   L.elem[0]=L.elem[s];

   for(j=2*s;j<=m;j*=2){

       if(j<m&&L.elem[j]<L.elem[j+1])  j++;

       if(!(L.elem[0]<L.elem[j]))    break;

       L.elem[s]=L.elem[j];

       s=j;

   }

   L.elem[s]=L.elem[0];

}

void HeapSort(SqList &L){

   for(i=L.length/2;i>0;i--)

       HeapAdjust(L,i,L.length);

   for(i=L.length;i>1;i--){

       LL.elem[1] ? L.elem[i];

       HeapAdjust(L,1,i-1);

}

}

(7)归并排序:

void Merge(SqList L,SqList &L1,int i,int m,int n){

//将有序的L[i..m]和L[m+1..n]归并为有序的L1[i..n]

    for(j=m+1,k=i;i<=m&&j<=n;++k)

        if(L.elem[i]<L.elem[j])    L1.elem[k]=L.elem[i++];

else          L1.elem[k]=L.elem[j++];

    if(i<=m)   L1[k..n] =L[i..m];

    if(j<=n)   L1[k..n] =L[j..n];

}

void MSort(SqList L,SqList &L1,int s,int t){

//将L[s..t]归并排序为L1[s..t]。

    if(s==t)   L1.elem[s]=L.elem[s];

    else{

        m=(s+t)/2;

        MSort(L,L2,s,m);

        MSort(L,L2,m+1,t);

        Merge(L2,L1,s,m,t);

    }

}

void MergeSort(SqList &L){

//对顺序表L作归并排序

    MSort(L,L,1,L.length);

}

【源代码】

见.cpp文件。

【算法分析】

【总结】

简单排序中直接插入排序最好，快速排序最快，当文件为正序，直接插入排序和冒泡排序均最佳。

排序算法的选择：

1.      若n（待排序的记录数）较小，可采用直接插入排序或选择排序。

当记录规模较小时，直接插入排序较好：否则因为选择移动的记录数少于直接插入，应选选择排序。

2.      若文件初始状态基本有序（正序），则应选用直接插入排序、冒泡排序或快速排序。

3.      若n较大，则应采用时间复杂度为O(nlgn)的排序算法：快速排序、堆排序极品归并排序。

当待排序的关键字是随机分布时，快速排序的平均时间最短；堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的；

若要求排序稳定，则可选用归并排序。

源代码：

#include<stdio.h>

#include<stdlib.h>

typedef struct                                               //顺序表存储结构

{

int * elem;

int length;

}SqList;

int main(void)

{

SqList L;

SqList L1;

void InsertSort(SqList &L);                              //直接插入排序

void BInsertSort(SqList &L);                             //折半插入排序

void BubbleSort(SqList &L);                              //冒泡排序

void SelectSort(SqList &L);                              //简单选择排序

    void QuickSort(SqList &L);                               //快速排序

void QSort(SqList &L,int low,int high);

int Partition(SqList &L,int low,int high);

void HeapSort(SqList &L);                                //堆排序

void HeapAdjust(SqList &L,int s,int m);

    void MergeSort(SqList &L);                               //归并排序

void MSort(SqList L,SqList &L1,int s,int t);

void Merge(SqList L,SqList &L1,int i,int m,int n);

int n;

int * p;

printf("请输入顺序表的长度：");

scanf("%d",&n);

if((p=(int *)malloc((n+1)*sizeof(int)))==0)              //动态分配顺序表存储空间

    {

        printf("Not able to allocate memory.\n");

        exit(1);

}

L.elem=p;

L.length=n;

    if((p=(int *)malloc((n+1)*sizeof(int)))==0)              //动态分配顺序表存储空间

    {

        printf("Not able to allocate memory.\n");

        exit(1);

}

L1.elem=p;

L1.length=n;

printf("请输入%d个整数：\n",n);                          //输入一组待排序的数据

for(int i=1;i<=L.length;i++)

        scanf("%d",&L.elem[i]);

printf("选择排序算法：\n");

printf("1 直接插入排序\n");

    printf("2 折半插入排序\n");

    printf("3 冒泡排序\n");

    printf("4 简单选择排序\n"); 

printf("5 快速排序\n");

    printf("6 堆排序\n");                

    printf("7 归并排序\n");

  

int change=0;

scanf("%d",&change);

   

    switch(change)

{

        case 1: InsertSort(L);break;

        case 2: BInsertSort(L);break;

        case 3: BubbleSort(L);break;

        case 4: SelectSort(L);break;

        case 5: QuickSort(L);break;

        case 6: HeapSort(L);break;

        case 7: MergeSort(L);break;

        default:break;

}

printf("排序后为：");

    for(i=1;i<=L.length;i++)

        printf("%6d",L.elem[i]);

printf("\n");

return 0;

}

void InsertSort(SqList &L)

{

int i=0,j=0;

for(i=2;i<=L.length ;i++)

        if(L.elem[i]<L.elem[i-1])

        {

               L.elem[0]=L.elem [i];                             //复制为哨兵

            L.elem [i]=L.elem [i-1];

               for(j=i-2;L.elem [j]>L.elem[0];j--)

                      L.elem [j+1]=L.elem [j];

               L.elem [j+1]=L.elem[0];

        }

}

void BInsertSort(SqList &L)

{

    int i=0,j=0,low=0,high=0,m=0;

for(i=2;i<=L.length ;i++)

{

        L.elem[0]=L.elem [i];

        low=1;

        high=i-1;

        while(low<=high)

        {

               m=(low+high)/2;

               if(L.elem [0]>L.elem [m])

                      low=m+1;

               else

                      high=m-1;

        }

        for(j=i-1;j>=high+1;j--)

               L.elem [j+1]=L.elem [j];

        L.elem [high+1]=L.elem[0];

}

}

void BubbleSort(SqList &L)

{

int i=0,j=0;

for(i=L.length;i>=2;i--)                 

        for(j=1;j<i;j++)

        {

               if(L.elem[j]>L.elem [j+1])

               {

                      L.elem[0]=L.elem [j];

                      L.elem [j]=L.elem [j+1];

                      L.elem [j+1]=L.elem[0];

               }

        }

}

void SelectSort(SqList &L)

{

int index=0;

for(int i=1;i<=L.length-1 ;i++)

{

        index=i;

        for(int j=i+1;j<=L.length ;j++)

               if(L.elem [j]<L.elem [index])

                  index=j;

        if(i!=index)                                               

        {

               L.elem[0]=L.elem [i];

               L.elem [i]=L.elem [index];

               L.elem [index]=L.elem[0];

        }

}

}

//快排

int Partition(SqList &L,int low,int high)

{

//将L.elem[low...high]一分为二

int pivot=0;                                       //用子表第一个记录作枢轴

pivot=L.elem[low]; 

while(low<high)

{

        while(low<high&&L.elem[high]>=pivot)

               high--;

        L.elem[0]=L.elem[low];

        L.elem[low]=L.elem[high];

        L.elem[high]=L.elem[0];

        while(low<high&&L.elem[high]<=pivot)

               low++;

        L.elem[0]=L.elem[low];

        L.elem[low]=L.elem[high];

        L.elem[high]=L.elem[0];

}

return low;

}

void QSort(SqList &L,int low,int high)

{

//对顺序表L中的子序列L.elem[low...high]进行快速排序

int pivot=0;

if(low<high)

{

        pivot=Partition(L,low,high);

        QSort(L,low,pivot-1);

        QSort(L,pivot+1,high);

}

}

void QuickSort(SqList &L)

{

QSort(L,1,L.length);

}

//堆排

void HeapAdjust(SqList &L,int s,int m)

{

int j=0;

L.elem[0]=L.elem[s];

for(j=2*s;j<=m;j*=2)

{

        if(j<m&&L.elem[j]<L.elem[j+1])

               j++;

        if(!(L.elem[0]<L.elem[j]))

               break;

        L.elem[s]=L.elem[j];

        s=j;

}

L.elem[s]=L.elem[0];

}

void HeapSort(SqList &L)

{

int i=0;

for(i=L.length/2;i>0;i--)

        HeapAdjust(L,i,L.length);

    for(i=L.length;i>1;i--)

{

        L.elem[0]=L.elem[1];

        L.elem[1]=L.elem[i];

        L.elem[i]=L.elem[0];

        HeapAdjust(L,1,i-1);

}

}

//归并

void Merge(SqList L,SqList &L1,int i,int m,int n)

{

int j=0,k=0,p=0,q=0;

    for(j=m+1,k=i;i<=m&&j<=n;++k)

{

        if(L.elem[i]<L.elem[j])

               L1.elem[k]=L.elem[i++];

        else

               L1.elem[k]=L.elem[j++];

}

if(i<=m)

        for(p=k,q=i;q<=m;p++,q++)

               L1.elem[p]=L.elem[q];

if(j<=n)

        for(p=k,q=j;q<=n;p++,q++)

            L1.elem[p]=L.elem[q];

}

void MSort(SqList L,SqList &L1,int s,int t)

{

SqList L2;

int * p;

    if((p=(int *)malloc((t-s+1)*sizeof(int)))==0)              //动态分配顺序表存储空间

    {

        printf("Not able to allocate memory.\n");

        exit(1);

}

L2.elem=p;

L2.length=t-s+1;

int m=0;

if(s==t)

        L1.elem[s]=L.elem[s];

else

{

        m=(s+t)/2;

        MSort(L,L2,s,m);

        MSort(L,L2,m+1,t);

        Merge(L2,L1,s,m,t);

}

}

void MergeSort(SqList &L)

{

MSort(L,L,1,L.length);

}