王道数据结构顺序表的代码实现：
讲道理，实现才有意思。
#include<stdio.h>
#include<stdlib.h>
//静态分配
#define MaxSize 50
typedef int ElemType;
//typedef struct{
// ElemType data[MaxSize];
// int length;
//}SqList;
//动态分配
#define InitSize 100
typedef struct{
ElemType *data;
int length;
}SqList;
void show();
bool ListInsert(SqList &L, int i, int e){
//本算法实现将元素e插入到顺序表中L中第i个位置
int j;
if( i<1||i>L.length+1 ){
printf("输入位置不合法！\n");
return false;
}
if(L.length>=InitSize ) {
printf("没有足够空间！\n");
return false;
}
for( j=L.length; j>=i; j-- )
L.data[j] = L.data[j-1];
L.data[i-1]=e;
L.length++;
return true;
}
bool ListDelete(SqList &L, int i){
int j;
if( i<1|| i>L.length ){
printf("输入位置不合法");
return false;
}
for( j=i; j<L.length; j++ )
L.data[j-1]=L.data[j];
L.length--;
return true;
}
int LocateElem(SqList &L, int e){
int i;
for( i=0; i<=L.length; i++ )
if( L.data[i]==e)
return i+1;
return 0;
}
void PrintList(SqList L){
for(int i=0;i<L.length; i++ ){
printf("%d ",L.data[i]);
}
printf("\n");
}
SqList MakeEmpty()
{
SqList L;
printf("输入连续的数字，中间空格分开，-1作为结束：");
int i=0, n;
L.data = (int *)malloc(InitSize*sizeof(int));
L.length=-1;
while(1){
scanf("%d", &n);
if(n==-1)
break;
L.data[i] = n;
L.length++;
i++;
// printf("length=%d\n",L.length);
}
L.length++;
L.data[i] = 0;
if(L.length>=0)
printf("创建成功！\n");
return L;
}
bool ListDeleteMin(SqList &L){ //删除最小节点 P18页综合应用题第 1 题 。
int i, t=0, k;
if( L.length>0 ){
k=L.data[0];
printf("k=%d\n",k);
for( i=1; i<L.length; i++ )
if( k > L.data[i] ){
k=L.data[i];
t=i;
}
L.data[t]=L.data[L.length-1];//由于代码中本人特意为length多加了一个位置，所以减一。
printf("L.data[%d]=%d\n", t, L.data[t]);
L.data[L.length-1] = 0;
L.length--;
return true;
} else
return false;
}
void ReSqList(SqList &L){ // P18页综合应用题第 2 题 。
int i=0, k=L.length-1, t=0;
for( i=0; i<(L.length-1)/2; i++, k-- )
{
t = L.data[i];
L.data[i] = L.data[k];
L.data[k] = t;
}
}
void ValueDelete(SqList &L, int e){ // P18页综合应用题第 3 题 。
int i=0, k=0, j=0;
for( i=0; i<L.length-1; i++ )
if( e == L.data[i] ){
for( j=i; j<L.length; j++ )
L.data[j] = L.data[j+1];
L.length--;
}
}
bool DeleteSqListZ(SqList &L, int e, int u){ // P18页综合应用题第 4 题 。
int i=0, t=0, j=0;
if( u>e )
{
for( i=e-1, j=u; j<L.length ;i++ ,j++ ,t++ ){
L.data[i] = L.data[j];
// printf("L.data[i=%d]=%d,L.data[u=%d]=%d\n",i, L.data[i],j, L.data[j] ) ;
}
for(i=0; i<u-e+1; i++ )
L.length--;
return true;
}
if(u<e)
return false;
}
bool ValueListDelete(SqList &L, int e, int u){ // P18页综合应用题第 5 题 。
int j, K;
for( K=0; K<L.length; K++ )
if( L.data[K]>=e && L.data[K]<=u ){
printf("L.data[K=%d]=%d\n", K, L.data[K]);
for( j=K; j<L.length; j++ )
L.data[j]=L.data[j+1];
L.length--;
K--;//最重要的一步，回头重新检查移位后的所有数字
}
return true;
}
bool Same_Delete(SqList &L){ // P18页综合应用题第 6 题 。
if(L.length==0)
return false;
int i, j;
for(i=0, j=1; j<L.length; j++ )
if(L.data[i]!=L.data[j])
L.data[++i] = L.data[j];
L.length=i+1;
return true;
}
bool Merge(SqList &A, SqList &B, SqList &C) // P18页综合应用题第 7 题 。
{
if(A.length+B.length>C.length)
return false;
int i=0, j=0, k=0;
while(i<A.length&&j<B.length){
if(A.data[i]<=B.data[j])
C.data[k++]=A.data[i++];
else
C.data[k++]=B.data[j++];
}
while(i<A.length)
C.data[k++] = A.data[i++];
while(i<B.length)
C.data[k++] = B.data[j++];
C.length = k;
return true;
}
void Reverse(SqList &A, int left, int right, int arraySize){ // P18页综合应用题第 8 题 。(1)
//逆转(aleft, aleft+2..., aright)为(aright,aright-1,...,aleft)
if(left>=right||right>=arraySize)
return ;
int mid=(left+right)/2;
for( int i=0; i<=mid-left; i++ ){
int temp = A.data[left+i];
A.data[left+i]=A.data[right-i];
A.data[right-i] = temp;
}
}
void Exchange(SqList &A, int m, int n, int arraySize){ // P18页综合应用题第 8 题 。(2)
Reverse( A, 0, m+n-1, arraySize );
Reverse( A, 0, n-1, arraySize );
Reverse( A, n, m+n-1, arraySize );
} //1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 -1
void ValueExchange(SqList &A, int e){ // P18页综合应用题第 9 题 方法 1
if(A.length==0)
return ;
int i, j=0, t , k=0, u;
for( i=0; i<A.length-1; i++ ){
if( A.data[i]==e ){
t = A.data[i];
A.data[i]=A.data[A.length-1];
A.data[A.length-1] = t;
j=1;
}else if(A.data[i]>e)
break;
}
if( e>A.data[A.length-1] ){
A.data[A.length]=e;
A.length++;
return ;
}
if(j==0 ) {
for( k = A.length; k>i; k-- )
A.data[k] = A.data[k-1];
A.data[i]=e;
A.length++;
}
}
void SearchExchangeInsert(SqList A, int e){ // P18页综合应用题第 9 题 方法 2
int low=0, high=A.length-2, mid, t, i;
printf("L=%d\n", A.length-2);
while(low<=high){
mid = (low+high)/2;
if(A.data[mid]==e) break;
else if(A.data[mid]<e) low=mid+1;
else high=mid-1;
}
if(A.data[mid]==e&&mid!=A.length-2){
t = A.data[mid];
A.data[mid] = A.data[mid+1];
A.data[mid+1]=t;
}
if(low>high){
for( i=A.length-2; i<high;i--)
A.data[i+1]=A.data[i];
A.data[i+1]=e;
}
}
int main(){
show();
bool ret, blu;
int i, j ,n ,e, u, arraySize;
SqList L, A, C, B, D, E, F, Q;
while(1){
scanf("%d", &n);
if(n==1)
L = MakeEmpty();
if( n==2 ){
printf("输入需要查找的数字：");
scanf("%d", &e);
j = LocateElem(L, e);
if(j==0)
printf("查找失败！");
else
printf("查找的数字在第%d位上\n", j);
}
if(n==3){
printf("输入需要插入的位置和字符，中间用空格分开");
scanf("%d %d", &i, &e);
ret = ListInsert(L, i, e);
if(ret)printf("插入成功！\n");
else printf("插入失败！\n");
}
if(n==4){
printf("输入删除的位置：");
scanf("%d", &e);
blu = ListDelete(L, e);
if(blu)printf("删除成功！\n");
else printf("删除失败！\n");
}
if(n==5){
scanf("%d", &e);
SearchExchangeInsert(L, e);
}
if(n==6)
PrintList(L);
if( n==7 ){
int a=ListDeleteMin(L);
if(a)printf("删除最小节点成功！");
}
if( n==8 ){
ReSqList(L);
}
if( n==9 ){
printf("输入需要删除的值");
scanf("%d", &e );
ValueDelete(L, e);
}
if(n==10){
printf("输入需要删除的区域起始和终结位置");
scanf("%d %d" , &e, &u);
ret = DeleteSqListZ(L, e, u);
if(ret)printf("删除成功！");
}
if(n==11){
printf("输入需要删除的值域起始和终结位置");
scanf("%d %d" , &e, &u);
ret = ValueListDelete(L, e, u);
if(ret)printf("删除成功！\n");
}
if(n==12){
ret=Same_Delete(L);
if(ret) printf("删除成功！\n");
}
if(n==13)
{
A = MakeEmpty();
B = MakeEmpty();
C.length=A.length+B.length;
for( i=0; i<=C.length; i++ )
C.data[i]=0;
ret = Merge( A ,B ,C );
if(ret)printf( "合并成功！\n" );
else printf("合并失败！\n新的顺序表为：");
PrintList(C);
}
if(n==14){
printf("输入数列大小！\n");
scanf("%d %d %d", &arraySize, &e, &u);
Q = MakeEmpty();
Exchange( Q, e, u, arraySize );
printf("得到的新序列为：");
PrintList( Q );
}
if( n==15 ){
scanf("%d", &e);
ValueExchange(L, e);
}
}
system("pause");
return 0;
}
void show()
{
printf("\n");
printf(" |_____________顺序表_____________|\n");
printf(" | 1.输 入 数 字 |\n");
printf(" | 2.查 找 数 字 |\n");
printf(" | 3.插 入 数 字 |\n");
printf(" | 4.删 除 数 字 |\n");
printf(" | 5.二分法 查找 |\n");
printf(" | 6.查 询 显 示 |\n");
printf(" | 7.删除最小节点 |\n");
printf(" | 8.顺序表逆转 |\n");
printf(" | 9.按值删除 |\n");
printf(" | 10.按区间删除 |\n");
printf(" | 11.按值域删除 |\n");
printf(" | 12.删除相同值 |\n");
printf(" | 13.合并两个顺序表 |\n");
printf(" | 14.置换顺序表位置 |\n");
printf(" | 15.按值增加置换表 |\n");
printf(" | 00.退 出 系 统 |\n");
printf(" |________________________________|\n");
printf("\n请选择菜单序号：");
} 
单链表
#include<stdio.h>
#include<stdlib.h>
typedef struct LNode{
int data;
struct LNode *next;
}LNode, *LinkList;
void show();
LinkList List_HeadInsert(LinkList &L){ //头插法 带头结点的
int n;
L = (LinkList)malloc(sizeof(LNode));//创建空列表
LNode *s;
L->next = NULL;
scanf("%d",&n);
while(n!=9999){
s = (LNode*)malloc(sizeof(LNode));
s->data = n;
s->next = L->next;
L->next = s;
scanf("%d",&n);
}
return L;
}
LinkList List_TailInsert(LinkList &L){ //尾插法
int x;
L = (LinkList)malloc(sizeof(LNode));
LNode *s, *r=L;
scanf("%d", &x);
while(x!=9999){
s = (LNode*)malloc(sizeof(LNode));
s->data = x;
r->next = s;
r = s;
scanf("%d", &x);
}
r->next = NULL;
return L;
}
LNode *GetElem(LinkList L, int i) //根据位置找元素
{
int j=1;
LNode *p=L->next;//头指针赋给P
if(i==0)
return L;
if(i<1)
return NULL;
while(p&&j<i){
p=p->next;
j++;
}
return p;//返回第i个结点的指针，若i大于表长则返回NULL
}
int LocateElem(LinkList L, int e) //数值位置找元素
{
LNode *p = L->next;
int i=0;
while(p!=NULL&&p->data!=e)
{
p=p->next; i++;
}
if(p==NULL)
i=0;
return i;
}
void Insert(LinkList L, LNode *s, int i){ //插入元素 n=5
LNode *p;
p=GetElem(L, i-1);
s->next = p->next;
p->next = s;
/*-----------------------------------
temp = p->data;
p->data = s->data;
s->data = temp;
------------------------------------- 转为后插法 */
}
void ListDelete( LinkList L, int i ){ //删除元素 n=6
LNode *p, *q;
p=GetElem(L, i-1);
q=p->next;
//p->data = p->next->data; //和后继结点交换数据域
p->next = q->next;
free(q);
}
void Del_X_3(LinkList &L/*加'&'符号，用来引导地址*/, int x) // 综合题第一题,不带头结点
{
LNode *p;
if(L==NULL)
return;
if(L->data==x){
p=L;
L=L->next;
free(p);
Del_X_3(L, x);
}else
Del_X_3(L->next, x);
}
void Del_X_2(LinkList &L/*加'&'符号，用来引导地址*/, int x) //综合提第二题 ①
{
LNode *p=L->next, *pre=L, *q;
while(p!=NULL){
if(p->data==x){
q=p;
p=p->next;
pre->next=p;
free(q);
}else{
pre=p;
p=p->next;
}//else
}//while
}
void Del_X_1(LinkList &L/*加'&'符号，用来引导地址*/, int x) //综合提第二题 ②
{
LNode *p=L->next, *r=L, *q;//r指向尾指针，其初始值为头结点
while(p!=NULL){
if(p->data!=x){
r->next = p;
r=p;
p=p->next;
}else{
q=p;
p=p->next;
free(q);
}
} //while
r->next = NULL;
}
void Print(LinkList L) //综合提第三题 反向输出链表
{
if(L->next!=NULL) Print(L->next);
if(L!=NULL) printf("%d ", L->data);
}
void Del_Min( LinkList L ) //综合题第四题 删除最小值
{
LNode *pre=L, *p=pre->next;
LNode *minpre = pre, *minp=p;
while( p!=NULL ){
if( p->data < minp->data ){
minp=p;
minpre=pre;
}
pre=p;
p=p->next;
}
minpre->next = minp->next;
free(minp);
}
void Reverse_1(LinkList L) //综合题第五题 ①
{
LNode *p, *r;
p=L->next;
L->next=NULL;
while(p!=NULL){
r=p->next;
p->next=L->next;
L->next=p;
p=r;
}
}
void Reverse_2(LinkList L) //综合题第五题 ②
{
LNode *pre, *p=L->next, *r=p->next;
p->next=NULL;
while(r!=NULL){
pre=p;
p=r;
r=r->next;
p->next=pre;
}
L->next=p;
}
void Sort(LinkList L) //综合题第六题 链表排序
{
LNode *p=L->next, *pre;
LNode *r=p->next;
p->next=NULL;
p=r;
while(p!=NULL){
r=p->next;
pre=L;
while(pre->next!=NULL&&pre->next->data<p->data)
pre=pre->next;
p->next=pre->next;
pre->next=p;
p=r;
}
}
void Del_deter(LinkList &L, int a, int b ) //综合题第七题 删除值域
{
LNode *p=L->next, *pre=L;
while(p!=NULL){
if(p->data>a&&p->data<b){
pre->next=p->next;
free(p);
p=pre->next;
}else {
pre=p;
p=p->next;
}
}
}
void Min_Delete(LinkList &head) //综合题第九题
{
LNode *pre, *p, *u;
while(head->next!=NULL){
pre=head;
p=pre->next;
while(p->next!=NULL){
if( p->next->data < pre->next->data )
pre=p;
p=p->next;
}
printf("%d ", pre->next->data );
u=pre->next;
pre->next=u->next;
free(u);
} //while
free(head);
}
void Div_List( LinkList &L )
{
LNode *pre=L, *p=pre->next, *O, *D;
D = (LinkList)malloc(sizeof(LNode));
O = (LinkList)malloc(sizeof(LNode));
LNode *ro, *ra, *s1=D, *s2=O;
while( p!=NULL ){
if(p->data%2==0){
ro=(LNode*)malloc(sizeof(LNode));
ro->data=p->data;
s1->next=ro;
s1=ro;
}else{
ra=(LNode*)malloc(sizeof(LNode));
ra->data=p->data;
s2->next=ra;
s2=ra;
}
p=p->next;
}
s1->next=NULL;
s2->next=NULL;
while(O->next!=NULL){
O=O->next;
printf("%d ",O->data);
}
printf("\n");
while(D->next!=NULL){
D=D->next;
printf("%d ",D->data);
}
}
LinkList DisCreat_1(LinkList A) //综合题第十题
{
int i=0;
LNode *B=(LinkList)malloc(sizeof(LNode)), *p;
B->next=NULL;
LNode *ra=A,*rb=B;
p=A->next;
A->next=NULL;
while(p!=NULL){
i++;
if(i%2==0){
rb->next=p;
rb=p;
}else{
ra->next=p;
ra=p;
}
p=p->next;
}
ra->next=NULL;
rb->next=NULL;
return B;
}
LinkList DIsCreat_2(LinkList &A) //综合题第十一题
{
LinkList B=(LinkList)malloc(sizeof(LNode)); //创建B表头
B->next=NULL;
LNode *p=A->next, *q;
LNode *ra=A;
while(p!=NULL){
ra->next=p;
ra=p;
p=p->next;
if(p!=NULL)
q=p->next;
p->next=B->next;
B->next=p;
p=q;
}
ra->next=NULL;
while(B!=NULL){
B=B->next;
printf("%d ", B->data);
}
return B;
}
void Del_same(LinkList L) //综合题十二题 ①
{
LNode *pre=L->next, *p=L->next, *s=p->next, *d;
while(s!=NULL){
while(s!=NULL){
if(p->data==s->data){
d=s;
s=s->next;
pre->next=s;
free(d);
s=pre;
}else{
pre=pre->next;
s=s->next;
}
}
p=p->next;
pre=p;
s=pre->next;
}
}
void Del_Same(LinkList L) //综合题十二题 ②
{
LNode *p=L->next, *q;
if(p==NULL)
return ;
while(p->next!=NULL){
q=p->next;
if(p->data==q->data){
p->next=q->next;
}else
p=p->next;
}
}
LinkList Merger(LinkList A, LinkList B) //综合题第十三题
{
LNode *preA=A, *preB=B, *pa=A->next, *pb=B->next, *L;
L = (LinkList)malloc(sizeof(LNode));
L->next=NULL;
while(preA->next!=NULL&&preB->next!=NULL){
if(pa->data<pb->data){
preA->next=pa->next;
pa->next=L->next;
L->next=pa;
pa=preA->next;
}else{
preB->next=pb->next;
pb->next=L->next;
L->next=pb;
pb=preB->next;
}
}
while(preA->next!=NULL){
preA->next=pa->next;
pa->next=L->next;
L->next=pa;
pa=preA->next;
}
while(preB->next!=NULL){
preB->next=pb->next;
pb->next=L->next;
L->next=pb;
pb=preB->next;
}
free(preA);
free(preB);
free(pa);
free(pb);
return L;
}
void MergeList(LinkList &La, LinkList &Lb) //
{
LNode *r, *pa=La->next, *pb=Lb->next;
La->next=NULL;
while(pa&&pb)
if( pa->data <= pb->data ){
r=pa->next;
pa->next=La->next;
La->next=pa;
pa=r;
}else{
r=pb->next;
pb->next=La->next;
La->next=pb;
pb=r;
}
if(pa)
pb=pa;
while(pb){
r=pb->next;
pb->next=La->next;
La->next=pb;
pb=r;
}
while(La->next!=NULL){
La=La->next;
printf("%d ",La->data);
}
free(Lb);
}
void Same_Merge(LinkList A, LinkList B) //综合题第14题
{
LNode *p=A->next, *q=B->next, *r, *s;
LinkList C=(LinkList)malloc(sizeof(LNode));
r=C;
while( q!=NULL&&p!=NULL ){
if(p->data<q->data)
p=p->next;
else if(p->data>q->data)
q=q->next;
else{
s=(LNode*)malloc(sizeof(LNode));
s->data=p->data;
r->next=s;
r=s;
p=p->next;
q=q->next;
}
}
r->next=NULL;
while(C->next!=NULL){
C=C->next;
printf("%d ", C->data);
}
}
LinkList Intersection_Merge(LinkList A, LinkList B) //综合题第15题
{
LNode *pa=A->next, *pb=B->next, *pc=A, *u;
while( pa&&pb ){
if( pa->data == pb->data ){
pc->next=pa;
pc=pa;
pa=pa->next;
u=pb;
pb=pb->next;
free(u);
} else if( pa->data<pb->data ){
u=pa;
pa=pa->next;
free(u);
} else{
u=pb;
pb=pb->next;
free(u);
}
}
while(pa){
u=pa;
pa=pa->next;
free(u);
}
while(pb){
u=pb;
pb=pb->next;
free(u);
}
pc->next=NULL;
free(B);
return A;
}
int Pattern(LinkList A, LinkList B) //综合题第十六题
{
LNode *p=A, *pre=p, *q=B;
while(p&&q)
if(p->data==q->data){
p=p->next;
q=q->next;
}else{
pre=pre->next;
p=pre;
q=B;
}
if(q==NULL)
return 1;
else
return 0;
}
int Search_k(LinkList L, int k){ //综合题第21题
LNode *p=L->next, *q=L->next;
int count=0;
while(p!=NULL){
if(count<k)
count++;
else
q=q->next;
p=p->next;
}
if(count<k)
return 0;
else{
printf("%d\n",q->data);
return 1;
}
}
void reverse_new(LinkList L ){ //综合题25题
LNode *p, *q, *r, *s;
p=q=L;
while( q->next != NULL )//寻找中间节点
{
p=p->next;
q=q->next;
if(q->next!=NULL) q=q->next;
}
q=p->next;
p->next=NULL;
while(q!=NULL){
r=q->next;
q->next=p->next;
p->next=q;
q=r;
}
s=L->next;
q=p->next;
p->next=NULL;
while(q!=NULL)
{
r=q->next;
q->next=s->next;
s->next=q;
s=q->next;
q=r;
}
}
int main(){
int x, i, n, a, b;
LNode *L, *A, *B, *s, *p;
show();
printf("输入菜单序号：");
scanf("%d", &n);
while(n!=0){
if( n==1 ){
printf("输入数字序列 ，以9999结束:");
L = List_HeadInsert(L);
}
if( n==2 ){
printf("输入数字序列 ，以9999结束:");
L = List_TailInsert(L);
}
if( n==3 ){
printf("\n输入查找的序号：");
scanf("%d", &x);
B = GetElem(L, x);
printf("序号%d的数字为%d\n",x, B->data);
}
if( n==4 ){
scanf("%d", &x);
i = LocateElem(L, x);
if(i!=0)
printf("元素%d在第%d个位置.\n",x, i+1);
if(i==0)
printf("元素不在链表中。\n");
}
if( n==5 ){
printf("输入插入的位置，元素：\n");
scanf("%d %d", &i, &x);
s = (LNode*)malloc(sizeof(LNode));
s->data = x;
Insert(L, s, i);
}
if( n==6 ){
printf("输入要删除的结点位置：");
scanf("%d", &x);
ListDelete(L, x);
}
if( n==7 ){
LNode *u=L;
while(u->next!=NULL){
u=u->next;
printf("%d ", u->data);
}
}
if( n==8 ){ //不带头结点
printf("输入要删除的元素：");
scanf("%d", &x);
Del_X_3(L, x);
}
if( n==9 ){
printf("输入要删除的元素：");
scanf("%d", &x);
Del_X_2(L,x);
}
if( n==10 ){
printf("输入要删除的元素：");
scanf("%d", &x);
Del_X_1(L,x);
}
if( n==11 ){
Print(L);
}
if( n==12 ){
Del_Min(L);
}
if( n==13 ){
//Reverse_1(L);//第二种方法
Reverse_2(L);
}
if( n==14 ){
Sort(L);
}
if( n==15 ){
printf("输入两个固定值");
scanf("%d %d", &a, &b);
Del_deter( L, a, b );
}
if( n==16 ){
Min_Delete(L);
}
if( n==17 ){
Div_List( L );
}
if( n==18 ){
B = DisCreat_1(L);
while(B->next!=NULL){
B=B->next;
printf("%d ", B->data);
} printf("\n");
while(L->next!=NULL){
L=L->next;
printf("%d ",L->data);
}
}
if( n==19 ){
B=DIsCreat_2(L);
printf("aaaa\n");
}
if( n==20 ){
Del_same(L);
}
if( n==21 ){
Del_Same(L);
}
if( n==22 ){
printf("请输入第一行数列：");
A=List_TailInsert(L);
printf("请输入第二行数列：");
B=List_TailInsert(L);
L = Merger(A, B);
printf("合并后链表：");
while(L->next!=NULL){
L=L->next;
printf("%d ",L->data);
}
}
if( n==23 ){
printf("请输入第一行数列：");
A=List_TailInsert(L);
printf("请输入第二行数列：");
B=List_TailInsert(L);
MergeList(A, B);
}
if( n==24 ){
printf("请输入第一行数列：");
A=List_TailInsert(L);
printf("请输入第二行数列：");
B=List_TailInsert(L);
Same_Merge(A, B);
}
if( n==25 ){
printf("请输入第一行数列：");
A=List_TailInsert(L);
printf("请输入第二行数列：");
B=List_TailInsert(L);
L=Intersection_Merge(A , B);
printf("合并后链表：");
while(L->next!=NULL){
L=L->next;
printf("%d ",L->data);
}
}
if( n==26 ){
printf("请输入第一行数列：");
A=List_TailInsert(L);
printf("请输入第二行数列：");
B=List_TailInsert(L);
x=Pattern(A,B);
if(x)
printf("1\n");
else
printf("0\n");
}
if( n==27 ){
printf("输入需要输出的倒数位数：");
scanf("%d", &x);
i = Search_k(L, x);
printf("%d", i);
}
if( n==28 ){
reverse_new(L);
}
printf("\n输入菜单序号：");
scanf("%d", &n);
}
return 0;
}
void show(){
printf("\n");
printf(" |------------------------------链表---------------------------|\n");
printf(" | 0.退出 22.倒序合并 ① |\n");
printf(" | 1.头插法建立链表 23.倒序合并 ② |\n");
printf(" | 2.尾插法建立链表 24.交集合并(新链) |\n");
printf(" | 3.序号查找 25.交集合并(旧链) |\n");
printf(" | 4.元素查找 26.判断 |\n");
printf(" | 5.插入元素 27.查找(倒数) |\n");
printf(" | 6.删除元素 28.重新排列 |\n");
printf(" | 7.显示元素 |\n");
printf(" | 8.删除指定值(递归) N |\n"); //8.不带头结点
printf(" | 9.删除指定值 Y① |\n"); //带头结点
printf(" | 10.删除指定值 Y② |\n"); //带头结点
printf(" | 11.反向输出链表 |\n"); //带头结点
printf(" | 12.删除最小值 |\n"); //带头结点
printf(" | 13.逆转链表 |\n"); //带头结点
printf(" | 14.链表排序 |\n"); //带头结点
printf(" | 15.删除值域 |\n"); //带头结点
printf(" | 16.递增输出删除 |\n"); //带头结点
printf(" | 17.奇偶数分链 |\n"); //带头结点
printf(" | 18.奇偶序号分链 |\n"); //带头结点
printf(" | 19.正倒序分链 |\n"); //带头结点
printf(" | 20.删除相同元素 ① |\n"); //带头结点
printf(" | 21.删除相同元素 ② |\n"); //带头结点
printf(" |-------------------------------------------------------------|\n");
}
栈：
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50
typedef int Elemtype;
typedef struct {
Elemtype data[MaxSize];
int top;
}SqStack;
void show();
void InitStack(SqStack &S){
S.top=-1; //初始化顶置栈针
}
bool StackEmpty(SqStack S){
if( S.top==-1 ) //栈空
return true;
else //不空
return false;
}
bool Push(SqStack &S, Elemtype x){
if( S.top==MaxSize-1 ) //栈满
return false;
S.data[++S.top]=x;//指针先加一
return true;
}
int Pop(SqStack &S) {
if( S.top==-1 )
return false;
return (S.data[S.top--]);
}
bool GetTop(SqStack S, Elemtype &x ){
if( S.top==-1 )
return false;
x=S.data[S.top];
return true;
}
int main(){
SqStack S;
int n, i, x;
InitStack(S); //初始化栈针
bool T=StackEmpty(S);
show();
while(1){
printf("选择功能，输入0时退出：");
scanf("%d", &n);
if( n==0 )
break;
switch(n){
case 1: {
printf("输入数字，以-1结束: ");
scanf("%d", &x);
while(T&&x!=-1 ){
Push(S, x);
scanf("%d", &x);
}
}break;
case 2: {
printf("栈列为：");
while( StackEmpty(S)==false ){
printf("%d ", Pop(S));
}
printf("\n");
}break;
}
}
}
void show() //显示堆栈菜单
{
printf("\n\n");
printf(" 堆栈显示系统 \n");
printf(" |-----------------------------|\n");
printf(" | 1-----进 栈 |\n");
printf(" | 2-----出 栈 |\n");
printf(" | 3-----显 示 |\n");
printf(" | 4-----数 字 转 换 |\n");
printf(" | 0-----返 回 |\n");
printf(" |-----------------------------|\n");
printf("\n");
}
这是用顺序表实现的栈，链表也可以。
_________________________________________________________________________________________________
这个是老链表了，我是用浙大的数据结构课本内容学着写的。
#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 100
typedef struct SNode *PtrToSNode;
typedef int Position;
struct SNode
{
int *date;
int Top;
int MaxSize;
};
typedef PtrToSNode Stack;
void show();
Stack CreatStack(int MaxSize);
bool isfull(Stack S);
bool Push(Stack S, int X );
bool isempty(Stack S);
int Pop(Stack S);
void Transfer(Stack S, int date );
int main()
{
int i, date=0, n=0;
Stack S = (Stack)malloc(sizeof(struct SNode));
show();
while(1)
{
printf("请选择菜单序号输入：");
scanf("%d", &n);
if( n==0 )
break;
switch(n)
{
case 1:
{
S = CreatStack(MAXSIZE);
i = 0;
printf("输入数字，输入0时退出：");
while(1)
{
scanf("%d", &date);
if(date == 0 || i>MAXSIZE)
break;
Push(S, date);
i++;
}
}
break;
case 2:
printf("出栈数字为：%d\n\n", Pop(S));
break;
case 3:
{
printf("当前堆栈顺序为:");
while(true)
{
printf("%d", Pop(S));
if( S->Top == -1 )
break;
}
printf("\n\n");
}
break;
case 4:
{
printf("请输入一个十进制的正整数:");
scanf("%d" , &date);
S = CreatStack(MAXSIZE);
Transfer(S, date);
}
break;
}
}
}
Stack CreatStack(int MaxSize)
{
Stack S = (Stack)malloc(sizeof(struct SNode));
S->date = ( int * )malloc(MaxSize*sizeof(int));
S->Top = -1;
S->MaxSize = MaxSize;
return S;
}
bool isfull(Stack S)//查看是否栈满
{
return ( S->Top == S->MaxSize-1 );
}
bool Push( Stack S, int X )//入栈操作
{
if(isfull(S))
{
printf("堆栈满");
return false;
}
else
{
S->date[++(S->Top)] = X;
return true;
}
}
bool isempty(Stack S)
{
return (S->Top==-1);
}
int Pop(Stack S)//出栈操作
{
if(isempty(S))
{
printf("堆栈空");
return false;
}
else
{
return (S->date[(S->Top)--]);
}
}
void Transfer(Stack S, int date )
{
printf("\n %d二进制为: ",date);
Position u=date, k=0;
while(u)
{
k = u%2;
u = u/2;
Push(S, k);
}
while(1)
{
printf("%d", Pop(S));
if( S->Top==-1 )
break;
}
printf("\n\n");
}
void show() //显示堆栈菜单
{
printf("\n\n");
printf(" 堆栈显示系统 \n");
printf(" |-----------------------------|\n");
printf(" | 1-----进 栈 |\n");
printf(" | 2-----出 栈 |\n");
printf(" | 3-----显 示 |\n");
printf(" | 4-----数 字 转 换 |\n");
printf(" | 0-----返 回 |\n");
printf(" |-----------------------------|\n");
printf("\n");
}
____________________________________________________________________________________________________
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50
typedef int ElemType;
typedef struct{
ElemType data[MaxSize];
int front,rear;
}SqQueue;
void InitQueue(SqQueue &Q){
Q.rear=Q.front=0; //初始化队首队尾
}
bool isEmpty( SqQueue Q ){ //判断队列为空
if( Q.rear == Q.front ) return true;
else return false;
}
bool EnQueue( SqQueue &Q, ElemType x){
if( (Q.rear+1)%MaxSize==Q.front ) return false;//队满则报错
Q.data[Q.rear]=x;
Q.rear=(Q.rear+1)%MaxSize; //队尾指针加一取模
return true;
}
bool DeQueue(SqQueue &Q){ //出队
if( Q.rear==Q.front ) return false; //队空则报错
// x=Q.data[Q.front];
Q.front=(Q.front+1)%MaxSize; //队头指针加一
return true;
}
int main(){
SqQueue Q;
int n, x, i;
InitQueue(Q);
bool T=isEmpty(Q);
printf("输入队列，以-1结束: ");
while(T){
scanf("%d", &x);
if(x==-1) break;
EnQueue(Q,x);
}
while( !isEmpty(Q) ){
printf("%d ", Q.data[Q.front]);
DeQueue(Q);
}
return 0;
}
——————————————————————————————————————————————————————
队列的链表实现
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LinkNode{
ElemType data;
struct LinkNode *next;
LinkNode *front, *rear;
}LinkNode,LinkQueue;
void InitQueue( LinkQueue &Q ){ //初始化
Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));//建立头结点
Q.front->next=NULL; //初始为空
}
bool IsEmpty(LinkQueue Q){ //判断队空
if(Q.front==Q.rear) return true;
else return false;
}
bool EnQueue(LinkQueue &Q, ElemType x){ //入队
LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
s->data=x;
s->next=NULL;
Q.rear->next=s;
Q.rear=s;
}
bool DeQueue(LinkNode &Q){ //出队
if(Q.front==Q.rear) return false;
LinkNode *p= Q.front->next;
printf("%d ",p->data);
Q.front->next=p->next;
if( Q.rear==p )
Q.rear=Q.front; //若原队列只有一个节点，删除后变空
free(p);
return true;
}
int main(){
LinkQueue Q;
int x=0, n;
InitQueue(Q);
bool T=IsEmpty(Q);
printf("输入队列，以-1结束:");
while(T){
scanf("%d", &x);
if(x==-1)break;
EnQueue(Q, x);
}
printf("\n队列为：");
while(!IsEmpty(Q)){
DeQueue(Q);
}
return 0;
}
一边刷课本习题一边更新。
192
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
