这应该是数据结构的题目吧。这题是上课时我同学和我讨论的，当时没用线性表，只是用数组（栈）解决了。现在改用线性表试试，还不是很熟悉。
code：

#include<stdio.h>
#include<stdlib.h>  //或者是 #include<malloc.h> 的头文件
#define N 10

struct Sqlist
{
    int *elem;
    int length;
    int listsize;
}L;

int DeleteK(struct Sqlist *L, int j, int k)
{
    int i;
    for(i = 0; i <= L->length-j-k; i++)     //i=0,而不是i=1,因为第i个是起始元素
        L->elem[i+j-1] = L->elem[j+k+i-1];
    L->length -= k;
    return 0;
}

int main()
{
    int i, j, k;
    L.listsize = N;
    L.elem = (int *)malloc(sizeof(int) * L.listsize); //申请listsize个大小为整型（int）字节的空间

    printf("输入原始线性表：\n");

    for(i = 0; i < N ;i++)
        scanf("%d", &L.elem[i]);

    L.length = L.listsize;

    printf("\n输入起始位置：");
    scanf("%d", &j);
    printf("\n输入要删除元素的个数：");
    scanf("%d", &k);

    DeleteK(&L, j, k);

    for(i = 0; i < N-k; i++)
        printf("%d ", L.elem[i]);

    return 0;
}

#include<stdio.h>
#include<stdlib.h>
#define N 50
struct SeqList
{
	int data[N];
	int length;
};

//初始化
void init_seqlist(struct SeqList *);

//插入
void insert_seqlist(struct SeqList *,int,int); 

//表长度
int length_seqlist(struct SeqList *); 

//删除第i个元素起的k个元素
void delete_seqlist(struct SeqList *,int,int); 
 
//显示结果
void show_seqlist(struct SeqList *); 

void main()
{
	struct SeqList list,*fp;
	int len,i,k;
	fp=&list;
	init_seqlist(fp);
	insert_seqlist(fp,1,10);
	insert_seqlist(fp,2,20);
	insert_seqlist(fp,3,30);
	insert_seqlist(fp,4,40);
	len=length_seqlist(fp); 
	printf("请输入正整数i：");
	scanf("%d",&i);
	printf("请输入正整数k：");
	scanf("%d",&k);
	if(!(i>0 && i<=k && (i+k)<=len+1))
	{
		printf("输入格式错误！\n");
	}else
	{
		delete_seqlist(fp,i,k);
		show_seqlist(fp);
	}
}

void init_seqlist(struct SeqList *fp)
{
	fp->length=0;
}

void insert_seqlist(struct SeqList *fp,int i,int e)
{
	int k;
	for(k=i;k<fp->length+1;k++)
	{
		fp->data[k]=fp->data[k-1];
	}
	fp->data[i-1]=e;
	fp->length++;
}

int length_seqlist(struct SeqList *fp)
{
	return fp->length;
}

void show_seqlist(struct SeqList *fp)
{
	int i;
	if(fp->length==0)
	{
		printf("该表为空表！\n");
	}else
	{
		printf("该表为:");
		for(i=0;i<fp->length-1;i++)
		{
			printf("(%d)->",fp->data[i]);
		}
		printf("(%d)",fp->data[i]);
	}
}

void delete_seqlist(struct SeqList *fp,int i,int k)
{
	int g;
	if(fp->length==0)
	{
		printf("该表为空表，删除失败！\n");
	}else
	{
		for(g=i+k;g<=fp->length;g++)
		{
			fp->data[g-k-1]=fp->data[g-1];
		}
		fp->length-=k;
	}
}

3.对长度为n的顺序表L，编写一个时间复杂度为O(n),空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的数据元素。
方法一：

用k记录顺序表中不等于x的元素个数，边扫描边List边统计k，并将不等于x的元素向前移动k个位置，最后修改List的长度。
/**
 * 删除线性表中所有值为x的数据元素
 * */
void deleteXElem(SqList *List, ElemType x)
{
    int k = 0; //用于记录值不等于x的元素的个数

    for(int i = 0; i < List->length; i++)
    {
        if(List->data[i] != x)
        {
            List->data[k] = List->data[i];
            k ++;
        }
    }
    List->length = k;
}

方法二：

用k记录顺序表中等于x的元素个数，边扫描边List边统计k，并将不等于x的元素向前移动k个位置，最后修改List的长度。
/**
 * 删除线性表中所有值为x的数据元素
 * */
void deleteXElem2(SqList *List , ElemType x)
{
    int k = 0; //记录值为x的元素的个数
    for(int i = 0; i < List->length; i++)
    {
        if(List->data[i] == x)
        {
            k++;
        }
        else
        {
            List->data[i-k] = List->data[i];
        }
    }

    List->length = List->length - k;
}

（2）单链表的操作
① 输入一组整型元素序列，使用尾插法建立一个带有头结点的单链表。
② 实现该线性表的遍历。
③ 在该单链表的第i个元素前插入一个整数。
④ 删除该单链表中的第i个元素，其值通过参数将其返回。
⑤ 建立两个按值递增有序的单链表，将他们合并成一个按值递减有序的单链表。要求利用原来的存储空间
#include<stdio.h>
#include<stdlib.h>
typedef struct LNode{
int data;
struct LNode *next;
}LNode,*LinkList;
void InitList(LinkList &L){
//建链表 
LinkList p,pre;
int x;
L=pre=(LinkList)malloc(sizeof(LNode));
scanf("%d",&x);
while(x>0){
p=(LinkList)malloc(sizeof(LNode));
p->data=x;
pre->next=p;
pre=p;
scanf("%d",&x);
}
pre->next=NULL;
}
void Output(LinkList L){
//遍历 
LinkList p;
        p=L->next;//临时指针指向首结点的地址
        while(p!=NULL)
        {
            printf("%5d",p->data);
            p=p->next;
        }
        printf("\n");
}
void GetElem(LinkList L,int i,int &e){
//查找   i为链表长度 
LinkList p;
int j;
p=L->next; j=1;
while(p&&j<i){
p=p->next; j++;
}
if(!p||j>i)
return;
e=p->data;
} 
void ListInsert(LinkList &L,int i,int e){
//插入    i为插入位置 
LNode *p,*s;
int j;
p=L; j=0;
while(p&&j<i-1){
p=p->next; j++; 
}
if(!p||j>i-1){
return; 

}
s=(LinkList)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
}
void ListDelete(LinkList &L,int i,int &e){
//删除
LinkList p,q;
int j=0;
p=L;
while(p->next&&j<i-1){
p=p->next; j++;
}
if(!p->next||j>i-1){
return;
}
q=p->next;
e=q->data;
p->next=q->next;
free(q); 
 
}
void Merge(LinkList La,LinkList Lb,LinkList &Lc){
//按值递增合并 
LinkList pa,pb,pc;
pa = La->next; pb = Lb->next;
Lc = pc = La;
while(pa&&pb)
if(pa->data <= pb->data){
pc->next = pa;pc = pa;pa = pa->next;
}
else { 
pc->next = pb;pc = pb;pb = pb->next; 
}
pc->next = pa?pa:pb;
free(Lb);
}
void Reverse(LinkList &L){
//就地逆置 
LinkList p,q;
    p = L->next;             
    L->next = NULL;          
    while(p != NULL){     
        q = p->next;         
        p->next = L->next;   
        L->next = p;
        p = q;               
    }
}
int main(){
LinkList La,Lb,Lc;
int i,e,j,k;
InitList(La);
printf("输入要插入的位置和数：");
scanf("%d%d",&i,&e);
ListInsert(La,i,e);
Output(La);
printf("要删除第几个数：");
scanf("%d",&j); 
ListDelete(La,j,k);
printf("删除的数为：%d\n",k);
Output(La);
printf("再建立一个；\n");
InitList(Lb);
Merge(La,Lb,Lc);
Reverse(Lc);
Output(Lc);
}