数据结构教程(第三版)课后答案

数据结构教程(第三版)课后答案


2024年1月4日发(作者:)

数据结构教程(第三版)课后答案

/*文件名:*/

#include

#include

#define MaxSize 50

typedef char ElemType; typedef struct

{

ElemType elem[MaxSize];

int length;

} SqList;

void InitList(SqList *&L) {

L=(SqList *)malloc(sizeof(SqList));

L->length=0;

}

void DestroyList(SqList *L) {

free(L);

}

int ListEmpty(SqList *L) {

return(L->length==0); }

int ListLength(SqList *L) {

return(L->length);

}

void DispList(SqList *L) {

int i;

if (ListEmpty(L)) return;

for (i=0;ilength;i++)

printf("%c",L->elem[i]);

printf("n");

}

int GetElem(SqList *L,int i,ElemType &e)

{

if (i<1 || i>L->length)

return 0;

e=L->elem[i-1];

return 1;

}

int LocateElem(SqList *L, ElemType e)

{

int i=0;

while (ilength && L->elem[i]!=e) i++;

if (i>=L->length)

return 0;

else

return i+1;

}

int ListInsert(SqList *&L,int i,ElemType e)

{

int j;

if (i<1 || i>L->length+1)

return 0;

i--; /*将顺序表位序转化为elem下标*/

for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/

L->elem[j]=L->elem[j-1];

L->elem[i]=e;

L->length++; /*顺序表长度增1*/

return 1;

}

int ListDelete(SqList *&L,int i,ElemType &e)

{

int j;

if (i<1 || i>L->length)

return 0;

i--; /*将顺序表位序转化为elem下标*/

e=L->elem[i];

for (j=i;jlength-1;j++)

L->elem[j]=L->elem[j+1];

L->length--;

return 1;

}/*文件名:*/

#include

#include

typedef char ElemType; typedef struct LNode /*定义单链表结点类型*/

{

ElemType data;

struct LNode *next; } LinkList;

void InitList(LinkList *&L) {

L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/

L->next=NULL;

}

void DestroyList(LinkList *&L)

{

LinkList *p=L,*q=p->next;

while (q!=NULL)

{

free(p);

p=q;

q=p->next;

}

free(p);

}

int ListEmpty(LinkList *L) {

return(L->next==NULL); }

int ListLength(LinkList *L) {

LinkList *p=L;int i=0;

while (p->next!=NULL)

{

i++;

p=p->next;

}

return(i);

}

void DispList(LinkList *L) {

LinkList *p=L->next;

while (p!=NULL)

{

printf("%c",p->data);

p=p->next;

}

printf("n");

}

int GetElem(LinkList *L,int i,ElemType &e)

{

int j=0;

LinkList *p=L;

while (j

{

j++;

p=p->next;

}

if (p==NULL)

return 0;

else

{

e=p->data;

return 1;

}

}

int LocateElem(LinkList *L,ElemType e)

{

LinkList *p=L->next;

int n=1;

while (p!=NULL && p->data!=e)

{

p=p->next;

n++;

}

if (p==NULL)

return(0);

else

return(n);

}

int ListInsert(LinkList *&L,int i,ElemType e)

{

int j=0;

LinkList *p=L,*s;

while (j

{

j++;

p=p->next;

}

if (p==NULL) /*未找到第i-1个结点*/

return 0;

else /*找到第i-1个结点*p*/

{

s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/

s->data=e;

s->next=p->next; /*将*s插入到*p之后*/

p->next=s;

return 1;

}

}

int ListDelete(LinkList *&L,int i,ElemType &e)

{

int j=0;

LinkList *p=L,*q;

while (j

{

j++;

p=p->next;

}

if (p==NULL) /*未找到第i-1个结点*/

return 0;

else /*找到第i-1个结点*p*/

{

q=p->next; /*q指向要删除的结点*/

p->next=q->next; /*从单链表中删除*q结点*/

free(q); /*释放*q结点*/

return 1;

}

}/*文件名:*/

#include

#include

typedef char ElemType; typedef struct DNode /*定义双链表结点类型*/ {

ElemType data;

struct DNode *prior; /*指向前驱结点*/

struct DNode *next; /*指向后继结点*/ } DLinkList;

void InitList(DLinkList *&L) {

L=(DLinkList *)malloc(sizeof(DLinkList)); /*创建头结点*/

L->prior=L->next=NULL; }

void DestroyList(DLinkList *&L) {

DLinkList *p=L,*q=p->next;

while (q!=NULL)

{

free(p);

p=q;

q=p->next;

}

free(p);

}

int ListEmpty(DLinkList *L) {

return(L->next==NULL); }

int ListLength(DLinkList *L)

{

DLinkList *p=L;int i=0;

while (p->next!=NULL)

{

i++;

p=p->next;

}

return(i);

}

void DispList(DLinkList *L) {

DLinkList *p=L->next;

while (p!=NULL)

{

printf("%c",p->data);

p=p->next;

}

printf("n");

}

int GetElem(DLinkList *L,int i,ElemType &e)

{

int j=0;

DLinkList *p=L;

while (j

{

j++;

p=p->next;

}

if (p==NULL)

return 0;

else

{

e=p->data;

return 1;

}

}

int LocateElem(DLinkList *L,ElemType e)

{

int n=1;

DLinkList *p=L->next;

while (p!=NULL && p->data!=e)

{

n++;

p=p->next;

}

if (p==NULL)

return(0);

else

return(n);

}

int ListInsert(DLinkList *&L,int i,ElemType e)

{

int j=0;

DLinkList *p=L,*s;

while (j

{

j++;

p=p->next;

}

if (p==NULL) /*未找到第i-1个结点*/

return 0;

else /*找到第i-1个结点*p*/

{

s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/

s->data=e;

s->next=p->next; /*将*s插入到*p之后*/

if (p->next!=NULL) p->next->prior=s;

s->prior=p;

p->next=s;

return 1;

}

}

int ListDelete(DLinkList *&L,int i,ElemType &e)

{

int j=0;

DLinkList *p=L,*q;

while (j

{

j++;

p=p->next;

}

if (p==NULL) /*未找到第i-1个结点*/

return 0;

else /*找到第i-1个结点*p*/

{

q=p->next; /*q指向要删除的结点*/

if (q==NULL) return 0; /*不存在第i个结点*/

p->next=q->next; /*从单链表中删除*q结点*/

if (p->next!=NULL) p->next->prior=p;

free(q); /*释放*q结点*/

return 1;

}

}

void Sort(DLinkList *&head) /*双链表元素排序*/

{

DLinkList *p=head->next,*q,*r;

if (p!=NULL) /*若原双链表中有一个或以上的数据结点*/

{

r=p->next; /*r保存*p结点后继结点的指针*/

p->next=NULL; /*构造只含一个数据结点的有序表*/

p=r;

while (p!=NULL)

{

r=p->next; /*r保存*p结点后继结点的指针*/

q=head;

while (q->next!=NULL && q->next->datadata) /*在有序表中找插入*p的

前驱结点*q*/

q=q->next;

p->next=q->next; /*将*p插入到*q之后*/

if (q->next!=NULL) q->next->prior=p;

q->next=p;

p->prior=q;

p=r;

}

}

}/*文件名:*/

#include

#include

typedef char ElemType;

typedef struct LNode /*定义单链表结点类型*/ {

ElemType data;

struct LNode *next;

} LinkList;

void InitList(LinkList *&L) {

L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/

L->next=L;

}

void DestroyList(LinkList *&L)

{

LinkList *p=L,*q=p->next;

while (q!=L)

{

free(p);

p=q;

q=p->next;

}

free(p);

}

int ListEmpty(LinkList *L) {

return(L->next==L); }

int ListLength(LinkList *L) {

LinkList *p=L;int i=0;

while (p->next!=L)

{

i++;

p=p->next;

}

return(i);

}

void DispList(LinkList *L) {

LinkList *p=L->next;

while (p!=L)

{

printf("%c",p->data);

p=p->next;

}

printf("n");

}

int GetElem(LinkList *L,int i,ElemType &e)

{

int j=0;

LinkList *p;

if (L->next!=L) /*单链表不为空表时*/

{

if (i==1)

{

e=L->next->data;

return 1;

}

else /*i不为1时*/

{

p=L->next;

while (j

{

j++;

p=p->next;

}

if (p==L)

return 0;

else

{

e=p->data;

return 1;

}

}

}

else /*单链表为空表时*/

return 0;

}

int LocateElem(LinkList *L,ElemType e)

{

LinkList *p=L->next;

int n=1;

while (p!=L && p->data!=e)

{

p=p->next;

n++;

}

if (p==L)

return(0);

else

return(n);

}

int ListInsert(LinkList *&L,int i,ElemType e)

{

int j=0;

LinkList *p=L,*s;

if (p->next==L || i==1) /*原单链表为空表或i==1时*/

{

s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/

s->data=e;

s->next=p->next; /*将*s插入到*p之后*/

p->next=s;

return 1;

}

else

{

p=L->next;

while (j

{

j++;

p=p->next;

}

if (p==L) /*未找到第i-1个结点*/

return 0;

else /*找到第i-1个结点*p*/

{

s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/

s->data=e;

s->next=p->next; /*将*s插入到*p之后*/

p->next=s;

return 1;

}

}

}

int ListDelete(LinkList *&L,int i,ElemType &e)

{

int j=0;

LinkList *p=L,*q;

if (p->next!=L) /*原单链表不为空表时*/

{

if (i==1) /*i==1时*/

{

q=L->next; /*删除第1个结点*/

L->next=q->next;

free(q);

return 1;

}

else /*i不为1时*/

{

p=L->next;

while (j

{

j++;

p=p->next;

}

if (p==L) /*未找到第i-1个结点*/

return 0;

else /*找到第i-1个结点*p*/

{

q=p->next; /*q指向要删除的结点*/

p->next=q->next; /*从单链表中删除*q结点*/

free(q); /*释放*q结点*/

return 1;

}

}

}

else return 0;

}/*文件名:*/

#include

#include

typedef char ElemType; typedef struct DNode /*定义双链表结点类型*/ {

ElemType data;

struct DNode *prior; /*指向前驱结点*/

struct DNode *next; /*指向后继结点*/ } DLinkList;

void InitList(DLinkList *&L) {

L=(DLinkList *)malloc(sizeof(DLinkList)); /*创建头结点*/

L->prior=L->next=L;

}

void DestroyList(DLinkList *&L) {

DLinkList *p=L,*q=p->next;

while (q!=L)

{

free(p);

p=q;

q=p->next;

}

free(p);

}

int ListEmpty(DLinkList *L) {

return(L->next==L);

}

int ListLength(DLinkList *L)

{

DLinkList *p=L;int i=0;

while (p->next!=L)

{

i++;

p=p->next;

}

return(i);

}

void DispList(DLinkList *L)

{

DLinkList *p=L->next;

while (p!=L)

{

printf("%c",p->data);

p=p->next;

}

printf("n");

}

int GetElem(DLinkList *L,int i,ElemType &e)

{

int j=0;

DLinkList *p;

if (L->next!=L) /*双链表不为空表时*/

{

if (i==1)

{

e=L->next->data;

return 1;

}

else /*i不为1时*/

{

p=L->next;

while (j

{

j++;

p=p->next;

}

if (p==L)

return 0;

else

{

e=p->data;

return 1;

}

}

}

else /*双链表为空表时*/

return 0;

}

int LocateElem(DLinkList *L,ElemType e)

{

int n=1;

DLinkList *p=L->next;

while (p!=NULL && p->data!=e)

{

n++;

p=p->next;

}

if (p==NULL)

return(0);

else

return(n);

}

int ListInsert(DLinkList *&L,int i,ElemType e)

{

int j=0;

DLinkList *p=L,*s;

if (p->next==L) /*原双链表为空表时*/

{

s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/

s->data=e;

p->next=s;s->next=p;

p->prior=s;s->prior=p;

return 1;

}

else if (i==1) /*原双链表不为空表但i=1时*/

{

s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/

s->data=e;

s->next=p->next;p->next=s; /*将*s插入到*p之后*/

s->next->prior=s;s->prior=p;

return 1;

}

else

{

p=L->next;

while (j

{ j++;

p=p->next;

}

if (p==L) /*未找到第i-1个结点*/

return 0;

else /*找到第i-1个结点*p*/

{

s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/

s->data=e;

s->next=p->next; /*将*s插入到*p之后*/

if (p->next!=NULL) p->next->prior=s;

s->prior=p;

p->next=s;

return 1;

}

}

}

int ListDelete(DLinkList *&L,int i,ElemType &e)

{

int j=0;

DLinkList *p=L,*q;

if (p->next!=L) /*原双链表不为空表时*/

{

if (i==1) /*i==1时*/

{

q=L->next; /*删除第1个结点*/

L->next=q->next;

q->next->prior=L;

free(q);

return 1;

}

else /*i不为1时*/

{

p=L->next;

while (j

{

j++;

p=p->next;

}

if (p==NULL) /*未找到第i-1个结点*/

return 0;

else /*找到第i-1个结点*p*/

{

q=p->next; /*q指向要删除的结点*/

if (q==NULL) return 0; /*不存在第i个结点*/

p->next=q->next; /*从单链表中删除*q结点*/

if (p->next!=NULL) p->next->prior=p;

free(q); /*释放*q结点*/

return 1;

}

}

}

else return 0; /*原双链表为空表时*/

}/*文件名:*/

#include

#include

#define MaxSize 100

typedef char ElemType; typedef struct

{

ElemType elem[MaxSize];

int top; /*栈指针*/

} SqStack;

void InitStack(SqStack *&s) {

s=(SqStack *)malloc(sizeof(SqStack));

s->top=-1;

}

void ClearStack(SqStack *&s) {

free(s);

}

int StackLength(SqStack *s) {

return(s->top+1);

}

int StackEmpty(SqStack *s) {

return(s->top==-1);

}

int Push(SqStack *&s,ElemType e) {

if (s->top==MaxSize-1)

return 0;

s->top++;

s->elem[s->top]=e;

return 1;

}

int Pop(SqStack *&s,ElemType &e)

{

if (s->top==-1)

return 0;

e=s->elem[s->top];

s->top--;

return 1;

}

int GetTop(SqStack *s,ElemType &e)

{

if (s->top==-1)

return 0;

e=s->elem[s->top];

return 1;

}

void DispStack(SqStack *s) {

int i;

for (i=s->top;i>=0;i--)

printf("%c ",s->elem[i]);

printf("n");

}/*文件名:*/

#include

#include typedef char ElemType; typedef struct linknode {

ElemType data; /*数据域*/

struct linknode *next; /*指针域*/ } LiStack;

void InitStack(LiStack *&s) {

s=(LiStack *)malloc(sizeof(LiStack));

s->next=NULL;

}

void ClearStack(LiStack *&s) {

LiStack *p=s->next;

while (p!=NULL)

{

free(s);

s=p;

p=p->next;

}

}

int StackLength(LiStack *s) {

int i=0;

LiStack *p;

p=s->next;

while (p!=NULL)

{

i++;

p=p->next;

}

return(i);

}

int StackEmpty(LiStack *s) {

return(s->next==NULL); }

void Push(LiStack *&s,ElemType e)

{

LiStack *p;

p=(LiStack *)malloc(sizeof(LiStack));

p->data=e;

p->next=s->next; /*插入*p结点作为第一个数据结点*/

s->next=p;

}

int Pop(LiStack *&s,ElemType &e)

{

LiStack *p;

if (s->next==NULL) /*栈空的情况*/

return 0;

p=s->next; /*p指向第一个数据结点*/

e=p->data;

s->next=p->next;

free(p);

return 1;

}

int GetTop(LiStack *s,ElemType &e)

{

if (s->next==NULL) /*栈空的情况*/

return 0;

e=s->next->data;

return 1;

}

void DispStack(LiStack *s)

{

LiStack *p=s->next;

while (p!=NULL)

{

printf("%c ",p->data);

p=p->next;

}

printf("n");

}/*文件名:*/

#include

#include

#define MaxSize 5

typedef char ElemType; typedef struct

{

ElemType elem[MaxSize];

int front,rear; /*队首和队尾指针*/

} SqQueue;

void InitQueue(SqQueue *&q) {

q=(SqQueue *)malloc (sizeof(SqQueue));

q->front=q->rear=0;

}

void ClearQueue(SqQueue *&q) {

free(q);

}

int QueueEmpty(SqQueue *q) {

return(q->front==q->rear); }

int QueueLength(SqQueue *q) {

return (q->rear-q->front+MaxSize)%MaxSize;

}

int enQueue(SqQueue *&q,ElemType e)

{

if ((q->rear+1)%MaxSize==q->front) /*队满*/

return 0;

q->rear=(q->rear+1)%MaxSize;

q->elem[q->rear]=e;

return 1;

}

int deQueue(SqQueue *&q,ElemType &e)

{

if (q->front==q->rear) /*队空*/

return 0;

q->front=(q->front+1)%MaxSize;

e=q->elem[q->front];

return 1;

}/*文件名:*/ #include #include

typedef char ElemType; typedef struct qnode {

ElemType data;

struct qnode *next; } QNode;

typedef struct

{

QNode *front;

QNode *rear;

} LiQueue;

void InitQueue(LiQueue *&q)

{

q=(LiQueue *)malloc(sizeof(LiQueue));

q->front=q->rear=NULL; }

void ClearQueue(LiQueue *&q)

{

QNode *p=q->front,*r;

if (p!=NULL) /*释放数据结点占用空间*/

{

r=p->next;

while (r!=NULL)

{

free(p);

p=r;r=p->next;

}

}

free(q); /*释放头结点占用空间*/ }

int QueueLength(LiQueue *q)

{

int n=0;

QNode *p=q->front;

while (p!=NULL)

{

n++;

p=p->next;

}

return(n);

}

int QueueEmpty(LiQueue *q) {

if (q->rear==NULL)

return 1;

else

return 0;

}

void enQueue(LiQueue *&q,ElemType e)

{

QNode *s;

s=(QNode *)malloc(sizeof(QNode));

s->data=e;

s->next=NULL;

if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/

q->front=q->rear=s;

else

{

q->rear->next=s; /*将*s结点链到队尾,rear指向它*/

q->rear=s;

}

}

int deQueue(LiQueue *&q,ElemType &e)

{

QNode *t;

if (q->rear==NULL) /*队列为空*/

return 0;

if (q->front==q->rear) /*队列中只有一个结点时*/

{

t=q->front;

q->front=q->rear=NULL;

}

else /*队列中有多个结点时*/

{

t=q->front;

q->front=q->front->next;

}

e=t->data;

free(t);

return 1;

}/*文件名:*/

#include

#define MaxSize 100 /*最多的字符个数*/ typedef struct

{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/

int len; /*标记当前实际串长*/ } SqString;

void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ {

int i;

for (i=0;cstr[i]!='0';i++)

[i]=cstr[i];

=i;

}

void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {

int i;

for (i=0;i<;i++)

[i]=[i];

=;

}

int StrEqual(SqString s,SqString t)

{

int same=1,i;

if (!=) /*长度不相等时返回0*/

same=0;

else

{

for (i=0;i<;i++)

if ([i]!=[i]) /*有一个对应字符不相同时返回0*/

same=0;

}

return same;

}

int StrLength(SqString s) {

return ;

}

SqString Concat(SqString s,SqString t)

{

SqString str;

int i;

=+;

for (i=0;i<;i++) /*将[0],[-1]复制到str*/

[i]=[i];

for (i=0;i<;i++) /*将[0],[-1]复制到str*/

[+i]=[i];

return str;

}

SqString SubStr(SqString s,int i,int j) {

SqString str;

int k;

=0;

if (i<=0 || i> || j<0 || i+j-1>)

{

printf("参数不正确n");

return str; /*参数不正确时返回空串*/

}

for (k=i-1;k

[k-i+1]=[k];

=j;

return str;

}

SqString InsStr(SqString s1,int i,SqString s2)

{

int j;

SqString str;

=0;

if (i<=0 || i>+1) /*参数不正确时返回空串*/

{

printf("参数不正确n");

return s1;

}

for (j=0;j

[j]=[j];

for (j=0;j<;j++) /*将[0],[-1]复制到str*/

[i+j-1]=[j];

for (j=i-1;j<;j++) /*将[i-1],[-1]复制到str*/

[+j]=[j];

=+;

return str;

}

SqString DelStr(SqString s,int i,int j) {

int k;

SqString str;

=0;

if (i<=0 || i> || i+j>+1) /*参数不正确时返回空串*/

{

printf("参数不正确n");

return str;

}

for (k=0;k

[k]=[k];

for (k=i+j-1;k<;k++)/*将[i+j-1],ch[-1]复制到str*/

[k-j]=[k];

=-j;

return str;

}

SqString RepStr(SqString s,int i,int j,SqString t)

{

int k;

SqString str;

=0;

if (i<=0 || i> || i+j-1>) /*参数不正确时返回空串*/

{

printf("参数不正确n");

return str;

}

for (k=0;k

[k]=[k];

for (k=0;k<;k++) /*将[0],[-1]复制到str*/

[i+k-1]=[k];

for (k=i+j-1;k<;k++) /*将[i+j-1],ch[-1]复制到str*/

[+k-j]=[k];

=-j+;

return str;

}

void DispStr(SqString str) {

int i;

if (>0)

{

for (i=0;i<;i++)

printf("%c",[i]);

printf("n");

}

}/*文件名:*/

#include

#include

typedef struct snode

{

char data;

struct snode *next;

} LiString;

void StrAssign(LiString *&s,char t[]) {

int i;

LiString *r,*p;

s=(LiString *)malloc(sizeof(LiString));

s->next=NULL;r=s;

for (i=0;t[i]!='0';i++)

{

p=(LiString *)malloc(sizeof(LiString));

p->data=t[i];p->next=NULL;

r->next=p;r=p;

}

}

void StrCopy(LiString *&s,LiString *t) {

LiString *p=t->next,*q,*r;

s=(LiString *)malloc(sizeof(LiString));

s->next=NULL;s->next=NULL;r=s;

while (p!=NULL) /*将t的所有结点复制到s*/

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

}

int StrEqual(LiString *s,LiString *t) {

LiString *p=s->next,*q=t->next;

while (p!=NULL && q!=NULL && p->data==q->data)

{

p=p->next;

q=q->next;

}

if (p==NULL && q==NULL)

return 1;

else

return 0;

}

int StrLength(LiString *s)

{

int i=0;

LiString *p=s->next;

while (p!=NULL)

{

i++;p=p->next;

}

return i;

}

LiString *Concat(LiString *s,LiString *t) {

LiString *str,*p=s->next,*q,*r;

str=(LiString *)malloc(sizeof(LiString));

str->next=NULL;r=str;

while (p!=NULL) /*将s的所有结点复制到str*/

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

p=t->next;

while (p!=NULL) /*将t的所有结点复制到str*/

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

return str;

}

LiString *SubStr(LiString *s,int i,int j) {

int k;

LiString *str,*p=s->next,*q,*r;

str=(LiString *)malloc(sizeof(LiString));

str->next=NULL;r=str;

if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))

{

printf("参数不正确n");

return str; /*参数不正确时返回空串*/

}

for (k=0;k

p=p->next;

for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

return str;

}

LiString *InsStr(LiString *s,int i,LiString *t) {

int k;

LiString *str,*p=s->next,*p1=t->next,*q,*r;

str=(LiString *)malloc(sizeof(LiString));

str->next=NULL;r=str;

if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/

{

printf("参数不正确n");

return str;

}

for (k=1;k

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

while (p1!=NULL) /*将t的所有结点复制到str*/

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p1->data;q->next=NULL;

r->next=q;r=q;

p1=p1->next;

}

while (p!=NULL) /*将*p及其后的结点复制到str*/

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

return str;

}

LiString *DelStr(LiString *s,int i,int j) {

int k;

LiString *str,*p=s->next,*q,*r;

str=(LiString *)malloc(sizeof(LiString));

str->next=NULL;r=str;

if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))

{

printf("参数不正确n");

return str; /*参数不正确时返回空串*/

}

for (k=0;k

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

for (k=0;k

p=p->next;

while (p!=NULL) /*将*p及其后的结点复制到str*/

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

return str;

}

LiString *RepStr(LiString *s,int i,int j,LiString *t) {

int k;

LiString *str,*p=s->next,*p1=t->next,*q,*r;

str=(LiString *)malloc(sizeof(LiString));

str->next=NULL;r=str;

if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))

{

printf("参数不正确n");

return str; /*参数不正确时返回空串*/

}

for (k=0;k

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

for (k=0;k

p=p->next;

while (p1!=NULL) /*将t的所有结点复制到str*/

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p1->data;q->next=NULL;

r->next=q;r=q;

p1=p1->next;

}

while (p!=NULL) /*将*p及其后的结点复制到str*/

{

q=(LiString *)malloc(sizeof(LiString));

q->data=p->data;q->next=NULL;

r->next=q;r=q;

p=p->next;

}

return str;

}

void DispStr(LiString *s) {


发布者:admin,转转请注明出处:http://www.yc00.com/web/1704374878a1346710.html

相关推荐

发表回复

评论列表(0条)

  • 暂无评论

联系我们

400-800-8888

在线咨询: QQ交谈

邮件:admin@example.com

工作时间:周一至周五,9:30-18:30,节假日休息

关注微信