Question

顺序表和链表的基本操作，用C语言实现！

1、顺序表的应用
(1)．输入一组整型元素序列，建立顺序表。
(2)．实现该顺序表的遍历。
(3)．在该顺序表中顺序查找某一元素,查找成功返回1,否则返回0。
(4)．判断该顺序表中元素是否对称,对称返回1,否则返回0。
(5)．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。
(6)．输入整型元素序列利用有序表插入算法建立一个有序表。
(7)．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。
(8)．编写一个主函数,调试上述算法。
2、链表的应用
(1)．键盘输入一组元素，建立一个无头结点的单向链表（无序）。
(2)．遍历（打印）单向链表。
(3)．把单向链表中元素逆置（不允许申请新的结点空间）。
(4)．在单向链表中删除所有的偶数元素结点。
(5)．对链表排序，排序后链表元素按照非递减方式排列（注意：排序时如果要交换两个结点的顺序，不得通过交换结点的内容，而需要使用改变指针的方式交换结点的位置。建议使用直接插入排序算法）。
(6)．利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。
(7)．利用算法1建立的链表，删除链表中的重复元素。
(8)．利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。
(9)．判断算法1和算法5生成单链表所表示的集合是否相等。
(10)．在主函数中设计一个简单的菜单，分别调试上述算法。

Answer 1

顺序存储的线性表的算法
#include "stdio.h"
#include "stdlib.h"
#define Status int
#define OVERFLOW 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXSIZE 100
typedef int ElemType;
typedef struct list
{ElemType elem[MAXSIZE];
int length;
}SqList;
void InitList(SqList &L){
L.length=0;
}
/*建立顺序表*/
void CreateList(SqList &L)
{
int i;
printf("input the length");
scanf("%d",&L.length);//输入表长
for(i=1;i<=L.length;i++)
scanf("%d",&L.elem[i-1]);//输入元素
}
//顺序表的遍历
void printdata(ElemType e){
printf("%4d",e);
}
void Traverse(SqList L,void (*visit)(ElemType e))
{ int i;
printf("The elements of the lists are:\n");
for(i=1;i<=L.length;i++){
if (i%10==0)printf("\n");//每行显示10个元素
visit(L.elem[i-1]);//输出表中元素
}
printf("\n");
}

//有序顺序表L中插入元素e使序列仍有序
void Insert(SqList &L,ElemType e)
{int i,j;
if (L.length==MAXSIZE)exit(OVERFLOW);//表满,不能插入
for(i=1;i<=L.length&&L.elem[i-1]<=e;i++);//向后查找
for(j=L.length;j>=i;j--)
L.elem[j]=L.elem[j-1];//元素后移
L.elem[i-1]=e;//插入e
L.length=L.length+1;//表长加1
}
//建立递增有序的顺序表
void CreateList_Sorted(SqList &L)
{int i,num;
ElemType e;
L.length=0;
printf("Create a sorted list,Input the length of the list\n");
scanf("%d",&num);
printf("Input the data %d numbers\n",num);
for(i=1;i<=num;i++){
scanf("%d",&e);
Insert(L,e);
}
}
/*Merge two sorted lists*/
void MergeList(SqList La,SqList Lb,SqList &Lc)
{int *pa,*pb,*pc;
if (La.length+Lb.length>MAXSIZE) exit(OVERFLOW);
else
{pa=La.elem;pb=Lb.elem;pc=Lc.elem;
while (pa<La.elem+La.length&&pb<Lb.elem+Lb.length)
*pc++=(*pa<=*pb)?*pa++:*pb++;/*公共部分合并*/
while (pa<La.elem+La.length) *pc++=*pa++;
/*R1表的剩余部分放到R的后部*/
while (pb<Lb.elem+Lb.length) *pc++=*pb++;
/*R2表的剩余部分放到R的后部*/
Lc.length=La.length+Lb.length;/*R表长*/
}
}
//判断元素是否对称，对称返回TRUE 否则返回FALSE
Status Symmetric(SqList L)
{int low,high;
low=0;
high=L.length-1;
while(low<high)
if (L.elem[low]==L.elem[high]){low++;high--;}
else return(FALSE); return(TRUE); }
//顺序表的主函数部分
//#include "seqlist.h"
void main()
{SqList L1,L2,L;
int select;
ElemType e;
do{printf("\n1 insert 2 merge");
printf("\n3 symmetric 0 exit \n");
printf("Please select(0--3)\n");
scanf("%d",&select);
switch(select){
case 1:
InitList(L);
CreateList_Sorted(L);
Traverse(L,printdata);
printf("\nInput the element of inserted\n");
scanf("%d",&e);
Insert(L,e);
Traverse(L,printdata);
break;
case 2:
InitList(L1);
CreateList_Sorted(L1);
Traverse(L1,printdata);
InitList(L2);
CreateList_Sorted(L2);
Traverse(L2,printdata);
InitList(L);
MergeList(L1,L2,L);
Traverse(L,printdata);
break;
case 3:
InitList(L);
CreateList(L);
Traverse(L,printdata);
if (Symmetric(L)) printf("Yes!\n"); else printf("Not\n");
break;
case 0:break;
default:printf("Error! Try again!\n");
}
}while(select);
}

/*单向链表的有关操作示例*/
/*类型定义及头文件部分,文件名为sllink.h*/
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;//元素实际类型
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList; //定义结点、指针类型名
//头插法建立无序链表
void CreateList(LinkList &L){
LinkList p;
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("头插法建立链表，以0结束\n");
scanf("%d",&e);
while(e){
p=(LinkList)malloc(sizeof(LNode));
p->data=e;
p->next=L->next;
L->next=p;
scanf("%d",&e);
}
}
/*非递减有序单向链表L插入元素e序列仍有序*/
void Insert_Sort(LinkList &L,ElemType e){
LinkList p,s;
s=(LinkList)malloc(sizeof(LNode));
s->data=e;
p=L;
while(p->next&&p->next->data<=e)
p=p->next;/*查找插入位置*/
s->next=p->next; /*插入语句*p结点后插入*s结点*/
p->next=s;
}
/*建立递增有序的单向链表*/
void Create_Sort(LinkList &L){
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("建立有序表，输入任意个整型数据以0结束\n");
scanf("%d",&e);
while(e){
Insert_Sort(L,e);
scanf("%d",&e);
}
}
/*单向链表的遍历*/
void Traverse(LinkList L){
LinkList p;
printf("遍历链表");
for(p=L->next;p;p=p->next)
printf("%5d",p->data);
printf("\n");
}
/*在单向链表删除元素e*/
void Delete(LinkList &L,ElemType e){
LinkList p,q;
p=L;
q=L->next;
while(q&& q->data!=e){//查找元素的删除位置
p=q;
q=q->next;
}
if(!q) printf("\nnot deleted");/*未找到元素e*/
else {p->next=q->next;/*找到删除*/
free(q);}
}
/*单向链表的逆置*/
void exch(LinkList &L){
LinkList p,s;
p=L->next;
L->next=NULL;
while(p){
s=p;
p=p->next;
s->next=L->next;
L->next=s;
}
}
/*两个非递减有序单向链表合并后仍为非递减序列*/
void MergeIncrease(LinkList La,LinkList Lb,LinkList &Lc){
LinkList p,q,s,rear;
p=La->next;
q=Lb->next;
Lc=rear=La;
free(Lb);
while(p&&q){
if (p->data<q->data) {s=p;p=p->next; }
else {s=q;q=q->next; }
rear->next=s;/*较小元素插入表尾*/
rear=rear->next;
}
if (p) rear->next=p; else rear->next=q;
}

/*主函数部分,文件名为sllink.c*/
//#include "sllink.h"
void main(){
LinkList La,Lb,Lc;
ElemType e;
int select;
do{
printf(" 1 建立无序表，再删除指定元素\n");
printf(" 2 建立递增有序表，再逆置\n");
printf(" 3 建立两个递增有序表，将它们和并为一个仍递增表\n");
printf(" 0 退出，请输入选项(0-3)\n");
scanf("%d",&select);
switch(select){
case 0:
break;
case 1:
CreateList(La);
Traverse(La);
printf("输入需删除的元素\n");
scanf("%d",&e);
Delete(La,e);
Traverse(La);
break;
case 2:
Create_Sort(La);
Traverse(La);
exch(La);
printf("The list that is exchaged\n");
Traverse(La);
break;
case 3:
Create_Sort(La);Traverse(La);
Create_Sort(Lb);Traverse(Lb);
MergeIncrease(La,Lb,Lc);Traverse(Lc);
break;
default:
printf("输入选项错误，请重新输入！\n");
}

}while(select);
}
这些内容不知道能不能帮助到你。

Answer 2

你照下面的这个 去写。下面的这个是顺序表的基本操作，链表和这个差不多。
#include"1.h"
void main()
{
char a[5]={'a','b','c','d','e'};
int n=5;
char f='f',b='a',e;
SqList sq;

InitList(sq); //初始化表

CreateList(sq,a,n); //传入数据

DispList(sq); //输出表

printf("sq.length=%d\n",ListLength(sq)); //输出表长

if(ListEmpty(sq)) //判断是否为空表
printf("sq是空表\n");
else
printf("sq不是空表\n");

printf("a在第%d位\n",LocateElem(sq,b)); //按元素值查找

ListInsElem(sq,f,4); //在第4个位置上插入f元素
DispList(sq); //输出表
printf("\n");
DelElem(sq,3,e); //删除第三个元素
DispList(sq); //输出表
}

这是头文件
1.h

#include<stdio.h>
const MaxSize=100;
typedef struct SqList
{
char elem[MaxSize];
int length;
}SqList,*PSqList;
SqList sq;
void InitList(SqList &sq) //初始化线性表
{
sq.length=0;
}
void CreateList(SqList &sq,char a[],int n) //建立表
{
int i;
for(i=0;i<n;i++)
sq.elem[i]=a[i];
sq.length=n;
}

int ListLength(SqList sq) //求表长
{
return(sq.length);
}
char GetElem(SqList sq,int i) //求第i个元素
{
if(i<1||i>sq.length)
return 0;
return sq.elem[i-1];
}
int LocateElem(SqList sq,char x) //按元素值查找
{
int i=0;
while(i<sq.length&&sq.elem[i]!=x)
i++;
if(i>sq.length)
return 0;
else return i+1;
}
int ListInsElem(SqList &sq,char x,int i) //插入元素在第i个位置
{
int j;
if(i<1||i>sq.length+1)return 0;
for(j=sq.length;j>=i;j--)
sq.elem[j]=sq.elem[j-1];
sq.elem[i-1]=x;
sq.length++;
return 1;
}
int DelElem(SqList &sq,int i,char &e) //删除第i个元素
{
int j;
if (i<1||i>sq.length)return 0;
e=sq.elem[i];
for(j=i;j<sq.length;j++)
sq.elem[j-1]=sq.elem[j];
sq.length--;
return 1;
}
int ListEmpty(SqList &sq) //判断表是否为空
{
return(sq.length==0);
}
void DispList(SqList sq) //输出表
{
int i;
if(ListEmpty(sq))return;
for(i=0;i<sq.length;i++)
printf("%c\t",sq.elem[i]);
}

Answer 3

其实这些算法并不复杂。具体操作比较繁琐而已，有兴趣可以参考下面的程序。有什么其他想法，帮你修改下就是。

Answer 4

做任务，打扰勿怪

Answer 5

删除和查找基本操作问题补充：需要详细源码！ 其实这些算法并不复杂。具体操作比较繁琐而已，有兴趣可以参考下面的程序。有什么其他想法，帮你修改下就是

追问

详细代码！