// 1.请写出链栈的出栈的算法，并分析平均情况下的时间复杂度
bool Pop(LinkStNode *&s,ElemType &e)
{
LinkStNode *p;
if(s->next==null)//栈为空的情况
{
return false;//返回假
}
p=s->next;//p指向首结点
e=p->data;//提取首结点值
s-next=p->next;//删除首结点
free§;//释放被删除的结点空间
return true;//返回真
} //时间复杂度为O（1）
// 2.请写出链栈的入栈的算法，并分析平均情况下的时间复杂度
void Push(LinkStNode *&s,ElemType e)
{
LInkStNode *p;
p=(LinkStNode *)malloc(sizeof(LinkStNode));//新建结点p
p->data=e;//存放元素e
p->next=s->next;//将p结点插入作为首结点
s->next=p;
} //时间复杂度为O（1）
// 3. 请写出顺序栈的入栈、出栈算法
bool Push(SqStack 8&s,ElemType e) //入栈
{
if(s->topMaxSize-1)//栈满的情况，即栈上溢出
{
return false;
}
s->top++;//栈顶指针+1
s->data[s->top]=e;//元素e放在栈顶指针处
return true;
}//时间复杂度为O（1）
bool Pop(SqStack 8&s,ElemType e)//出栈
{
if(s->top-1)//栈为空的情况 即栈下溢出
{
return false;
}
e=s->data[s->top];//取栈顶元素
s->top–;//栈顶指针减一
return true;
}//时间复杂度为O（1）
// 4.请写出循环队的出队、入队的算法
bool enQueue(SqQueue *&q,ElemType e)
{
if((q-rear+1)%MaxSizeq->front)//队满上溢出
{
return false;
}
q-rear =(q->rear+1)%MaxSize;
q-data[q->rear]=e;
return true;
} //时间复杂度为O（1）
bool deQueue(SqQueue *&q,ElemType &e)
{
if(q->fontq->rear)//对空下溢出
{
return false;
}
q->font=(q->font+1)%MaxSize;
e=q->data[q->font];
return true;
}//时间复杂度为O（1）
// 5.请写出在双链表中在第i个位置上添加元素的算法，并分析平均情况下的时间复杂度
bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
int j=0;
DLinkNode *p=L,*s;//p指向头结点，j设置为0
if(i<0) return false;//错误返回false
while(j<i-1 && p!=NULL)//查找第i-1个结点
{
j++;
p=p->next;
}
if(p==NULL) //未找到第i-1个结点，返回false
return false;
else //找到第i-1个结点
{
s=(DLinkNode *)malloc(sizeof(DLinkNode));
s->data=e;//创建新结点s
s->next=p->next;//在p结点之后插入s结点
if(p->next!=NULL)//若p结点之后存在后继结点，修改其前驱指针
{
p->next->prior=s;
}
s->prior=p;
p->next=s;
return true;
}
} //时间复杂度为O（n） n为双链表中结点的个数
// 6.请写出在双链表中删除第i个位置上的元素的算法，并分析平均情况下的时间复杂度
bool ListDelete(DLinkNode *&L,int i,ElemType e)
{
int j=0;
DLinkNode *p=L,*s;//p指向头结点，j设置为0
if(i<0) return false;//错误返回false
while(j<i-1 && p!=NULL)//查找第i-1个结点
{
j++;
p=p->next;
}
if(pNULL) //未找到第i-1个结点，返回false
return false;
else //找到第i-1个结点
{
q=p->next;//q指向第i个结点
if(qNULL)//当不存在第i个结点时返回false
{
return false;
}
e=q->data;
p->next=q->next;//从双链表中删除结点q
if(p->next!=NULL)//若p结点存在后继结点，修改其前驱指针
{
p->next-prior=p;
}
free(q);//释放q结点
return true;
}
} //时间复杂度为O（n） n为双链表中结点的个数
// 7.请写出单链表中链表的销毁的算法，并分析平均情况下的时间复杂度
viod DestroyList(LinkNode *&L)
{
LInkNode *pre=L,*p=l->next;//pre指向结点p的前驱结点
while(p!=NULL)//扫描整个单链表
{
free(pre);//释放pre结点
pre=p;//pre、p同步后移5一个结点
p=pre->next;
}
free(pre);//循环结束时p为NULL，pre指向尾结点，释放它
} //时间复杂度为O（n） n为单链表中结点的个数
// 8.请写出单链表中的尾插法建立单链表的算法，并分析平均情况下的时间复杂度
void CreatListF(LinkNode *&L,ElemType a[],int n)
{
LinkNode *s;
L=(LinkNode *)malloc(sizeof(LinkNode));
L->next=NULL;//创建头结点，其next域置为NULL
for(int i=0;i<n;i++)//循环建立数据结点s
{
s=(LinkNode *)malloc(sizeof(LinkNode));
s->data=a[i];
s->next=L->next;//将s结点插入到原首结点之前、头结点之后
L->net=s;
}
} //时间复杂度为O（n） n为单链表中结点的个数
// 9.请写出单链表中的头插法建立单链表的算法，并分析平均情况下的时间复杂度
void CreatListR(LinkNode *&L,ElemType a[],int n)
{
LinkNode *s,*r;
L=(LinkNode *)malloc(sizeof(LinkNode));//创建头结点
r=L;//r始终指向尾结点
for(int i=0;i<n;i++)//循环建立数据结点
{
s=(LinkNode *)malloc(sizeof(LinkNode));
s->data=a[i];//创建数据结点s
r->next=s;//将s结点插入到结点r之后
r=s;
}
r->next=NULL;//尾结点的next域置为NULL
} //时间复杂度为O（n） n为单链表中结点的个数
// 10.请写出单链表基本运算中的在第x个位置删除结点y的算法，并分析平均情况下的时间复杂度
bool ListDelete(LinkNode *&L, int i, ElemType &e) //删除第i个元素
{
int j = 0;
LinkNode *p = L, *q;//p指向头结点，j置为0（即头结点序号为0）
if (i <= 0) return false;//i错误返回false
while (j < i - 1 && p != NULL)//查找第i-1个结点p
{
j++;
p = p->next;
}
if (p == NULL)//未找到第i-1个结点，返回false
return false;
else { //找到第i-1个结点p
q = p->next;//q指向第i个结点
if (q != NULL)//若不存在第i个结点，返回false
return false;
e = q->data;
p->next = q->next;//从单链表中删除q结点
free(q);//释放q结点
return true;//返回true表示 成功删除第i个结点
}
}//时间复杂度为O（n） n为单链表中结点的个数
// 11.请写出单链表基本运算中的在第x个位置插入结点y的算法，并分析平均情况下的时间复杂度
bool ListInsert(LinkNode *&L, int i, ElemType e) //插入第i个元素
{
int j = 0;
LinkNode *p = L, *s;//p指向头结点，j置为0（即头结点序号为0）
if (i <= 0) return false;//i错误返回false
while (j < i - 1 && p != NULL)//查找第i-1个结点p
{
j++;
p = p->next;
}
if (p == NULL)//未找到第i-1个结点，返回false
return false;
else //找到第i-1个结点p，插入新结点并返回true
{
s = (LinkNode *)malloc(sizeof(LinkNode));
s->data = e;//创建新结点s，其data域置为e
s->next = p->next;//将结点s插入到结点p之后
p->next = s;
return true;
}
}//时间复杂度为O（n） n为单链表中结点的个数
// 12.请写出顺序表基本运算中的在第i个位置删除数据元素的算法，并分析平均情况下的时间复杂度
bool ListDelete(SqList *&L,int i,ElemType e)
{
int j;
if (i<1 || i>L->length) //参数错误时返回false
return false;
i–; //将顺序表逻辑序号转化为物理序号
e=L->data[i];
for (j=i; jlength-1; j++) //将data[i…n-1]元素前移
L->data[j]=L->data[j+1];
L->length–; //顺序表长度减1
return true; //成功删除返回true
}// 平均时间复杂度为O（n） 删除一个元素需要移动（n-1）/2 个元素
// 13.写出顺序表基本运算中的在第i个位置插入数据元素x的算法，并分析平均情况下的时间复杂度
bool ListInsert(SqList *&L,int i,ElemType e)
{
int j;
if (i<1 || i>L->length+1)
return false; //参数错误时返回false
i–; //将顺序表逻辑序号转化为物理序号
for (j=L->length; j>i; j–) //将data[i…n]元素后移一个位置
L->data[j]=L->data[j-1];
L->data[i]=e; //插入元素e
L->length++; //顺序表长度增1
return true; //成功插入返回true
}// 平均时间复杂度为O（n） 删除一个元素需要移动 n/2 个元素
// 14.请写出顺序表基本运算中的按元素值查找数据元素x的算法，并分析平均情况下的时间复杂度
int LocateElem(SqList *L, ElemType e)
{
int i=0;
while (ilength && L->data[i]!=e) i++;//查找元素e
if (i>=L->length) return 0;//未找到返回0
else return i+1;//找到后返回其逻辑序号
}// 时间复杂度为O（n）
// 15.请写出顺序表基本运算中的建立顺序表的算法，并分析平均情况下的时间复杂度
void CreateList(SqList *&L, ElemType a[], int n)//由a中的n’个元素建立顺序表
{
int i;
L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间
for (i=0; i<n; i++)//扫描整个数组
L->data[i]=a[i];//将元素存到 L中
L->length=n;//设置L的长度n
}// // 时间复杂度为O（n）
// 16.请写出链栈的结构体
typedef struct LinkNode
{
ElemType data; //数据域
struct LinkNode *next; //指针域
}LinkNode;//链栈结点类型
// 17.顺序存储是线性表的一种主要存储形式，请写出顺序表的结构体
typedef struct
{
ElemType data[MaxSize];//存放线性表中的元素
int length;//存放线性表长度
} SqList;//顺序表类型
// 18.请写出线性表的链式存储结构—单链表的结构体
typedef struct LNode
{
ElemType data;//存放元素值
struct LNode *next; //指向后继结点
}LinkNode; //单链表结点类型
// 19.线性表的链式存储是一种比较适合元素的添加和删除操作的结构，请写出单链表的结构体
typedef struct LNode
{
ElemType data;//存放元素值
struct LNode *next; //指向后继结点
}LinkNode; //单链表结点类型
// 20.请写出线性表的链式存储结构—单循环链表的结构体
typedef struct Node
{
int data;//存放元素值
struct Node *next;//指向后继结点
}Node,*LinkList;//单循环链表结点类型
// 21.循环链表是将链表的首尾相连，可以实现元素的从后往前及从前往后的访问，请写出单循环链表的结构体
typedef struct Node
{
int data;//存放元素值
struct Node *next;//指向后继结点
}Node,*LinkList;//单循环链表结点类型
// 22.请写出线性表的链式存储结构—双链表的结构体
typedef struct DNode
{
ElemType data;//存放元素值 5
struct DNode *prior;//指向前驱结点
struct DNode *next;//指向后继结点
}DLinkNode; //双链表的结点类型
// 23.请写出线性表的顺序存储结构—顺序表的结构体
typedef struct
{
ElemType data[MaxSize];//存放线性表中的元素
int length;//存放线性表长度
} SqList;//顺序表类型
// 24.请写出顺序栈的结构体
typedef struct
{
ElemType data[MaxSize]; //存放栈中的数据元素
int top; //栈顶指针，即存放栈顶元素在data数组中的下标
}SqStack;//顺序栈类型
// 25.请写出树的双亲存储法的结构体
typedef struct
{
ElemType data;//存放结点的值
int parent;//存放双亲的位置
}PTree[MaxSize];//Ptree为双亲存储结构类型
// 26.请写出顺序队的结构体
typedef struct
{
ElemType data[MaxSize];//存放队中的元素
int front,rear;//对头和队尾指针
}SqQueue;//顺序队类型
// 27.队列具有先进先出的特性，使用范围广泛。请写出顺序队的结构体
typedef struct
{
ElemType data[MaxSize];//存放队中的元素
int front,rear;//对头和队尾指针
}SqQueue;//顺序队类型
// 28.请写出顺序队的循环队的结构体
typedef struct
{
ElemType data[MaxSize];//存放队中的元素
int front;//对头指针
int count;//队列中元素的个数
}QuType;//环形队类型
// 29.请写出链队的结构体
typedef struct QNode
{
ElemType data;//存放队中的元素
struct QNode *next;//下一个结点指针
}DataNode;//链队数据结点类型
// 30.请写出二叉树的链式存储的结构体
typedef struct BiTNode
{
TElemType data;//数据元素
struct BiTNode *lchild,*rchild; //左右孩子结点
}BiTNode,*BiTree;//结点类型
// 31.二叉树的一种重要存储结构是二叉链表存储，请写出二叉树的链式存储的结构体
typedef struct BiTNode
{
TElemType data;//数据元素
struct BiTNode *lchild,*rchild; //左右孩子结点
}BiTNode,*BiTree;//结点类型
// 32.二叉树也能用顺序存储来实现，但是使用局限性很大。二叉树一般用二叉链表存储，请写出二叉树的链式存储的结构体
typedef struct BiTNode
{
TElemType data;//数据元素
struct BiTNode *lchild,*rchild; //左右孩子结点
}BiTNode,*BiTree;//结点类型
// 33.请写出线性表的链式存储结构—双循环链表的结构体
typedef struct DNode
{
ElemType data;//存放元素值
struct DNode *prior;//指向前驱结点
struct DNode *next;//指向后继结点
}DLinkNode; //双链表的结点类型
// 34.以此括号表示法A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))建立一棵二叉树，实现这个算法，并分析这个算法的复杂度。
#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
ElemType data; //数据元素
struct node *lchild; //指向左孩子
struct node *rchild; //指向右孩子
} BTNode;
extern void CreateBTNode(BTNode *&b,char *str);
extern void DispBTNode(BTNode *b);
extern void DestroyBTNode(BTNode *&b);
int main()
{ BTNode *b,*p,*lp,*rp;;
CreateBTNode(b,“A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”);
printf(“二叉树:\n”);
DispBTNode(b);
printf("\n");
printf("释放二叉树\n");
DestroyBTNode(b);
}
void CreateBTNode(BTNode *&b,char *str) //由str串创建二叉链
{
BTNode *St[MaxSize],*p=NULL;
int top=-1,k,j=0;
char ch;
b=NULL; //建立的二叉树初始时为空
ch=str[j];
while (ch!=’\0’) //str未扫描完时循环
{
switch(ch)
{
case ‘(’:top++;St[top]=p;k=1; break; //为左节点
case ‘)’:top–;break;
case ‘,’:k=2; break; //为右节点
default:p=(BTNode *)malloc(sizeof(BTNode));
p->data=ch;p->lchild=p->rchild=NULL;
if (b==NULL) //p指向二叉树的根节点
b=p;
else //已建立二叉树根节点
{
switch(k)
{
case 1:St[top]->lchild=p;break;
case 2:St[top]->rchild=p;break;
}
}
}
j++;
ch=str[j];
}
}
void DispBTNode(BTNode *b) //以括号表示法输出二叉树
{
if (b!=NULL)
{
printf("%c",b->data);
if (b->lchild!=NULL || b->rchild!=NULL)
{
printf("(");
DispBTNode(b->lchild);
if (b->rchild!=NULL) printf(",");
DispBTNode(b->rchild);
printf(")");
}
}
}
void DestroyBTNode(BTNode *&b)
{
if (b!=NULL)
{
DestroyBTNode(b->lchild);
DestroyBTNode(b->rchild);
free(b);
}
}
// 35.设计一个算法，请找出一棵完全二叉树的所有叶子结点将其进行删除，并输出所有剩下的结点。实现这个算法，并分析这个算法的复杂度。
static removeLeaves( btree t )
{
if (t == null || ( t.left == null && t.right == null ))
return null;
t.left = removeLeaves( t.left );
t.right = removeLeaves( t.right );
return t;
preolder(t)
}
void preolder(btree ptr)
{
if (ptr)
{
printf("%2d", ptr->data);
preolder(ptr->left);
preolder(ptr->right);
}
}//时间复杂度为 O(n)
// 36.设计一个算法，找出二叉树上有没有一个值为x的结点，若有请输出，若没有请给出提示。实现这个算法，并分析这个算法的复杂度。（要求：采用非递归方式实现）
void PrintX(BTNode *b, int x)
{
}
// 37.设计一个算法，统计二叉树上所有的结点个数，并输出结点。实现这个算法，并分析这个算法的复杂度。（要求：采用非递归方式实现）
int Count(BTreeNode *BT)
{
int l,r;
if(BTNULL) return 0;
else if(BT->LchildNULL&&BT->Rchild==NULL) return 1;
else
{
l=Count(BT->Lchild);
r=Count(BT->Rchild);
return (l+r);
}
}//时间复杂度为 O(n)
// 38.设计一个算法，找出二叉树上所有的双分支结点，输出并统计总数。实现这个算法，并分析这个算法的复杂度。（要求：采用非递归方式实现）
int Count_Double(BiTree T)
{
if (TNULL) return 0;//空树
else if (T->lchildNULL && T->rchild==NULL) return 0;//叶子结点
else
{
if (!T->lchild && T->rchild) return count_n2(T->rchild);//只有左单分支
if (T->lchild && !T->rchild) return count_n2(T->lchild);//只有右单分支
if (T->lchild && T->rchild) return count_n2(T->lchild)+count_n2(T->rchild)+1;//双分支结点
}
}//时间复杂度为 O(n)
// 39.设计一个算法，找出二叉树上所有的非叶子结点，输出并统计总数。实现这个算法，并分析这个算法的复杂度。（要求：采用非递归方式实现）
// 40.设计一个算法，判断顺序表L是否是递减的，若不是请将其递减处理。实现这个算法，并分析这个算法的复杂度。
// 41.设计一个算法，判断单链表L是否是递增的，若不是请将其递增处理。实现这个算法，并分析这个算法的复杂度。
// 42.定义一个采用顺序结构存储的线性表，删除元素在介于[x, y]之间的所有元素，并统计删除元素的个数。 实现这个算法，并分析这个算法的复杂度。
status deleteeleminrange(sqlist *l,int x,int y){
int i=0,k=0,t=0;//k用来记录不在x，y范围内的元素
if(x>y)/检查参数是否正确，不正确则进行修正/
{
t=x;
x=y;
y=t;
}
for(i=0;ilength;i++){
if(l->data[i]>y||l->data[i]<x)
l->data[k++]=l->data[i];
}
l->length=k;
} //时间复杂度为 O(n)
// 43.设计题，请写出以下要求的伪码算法
//设从键盘输入一整数序列a1，a2，…an，试编程实现：当ai>0时，ai进队，当ai<0时，将队首元素出队，当ai=0时，表示输入结束。要求将队列处理成环形队列，使用环形队列算法库中定义的数据类型及算法，程序中只包括一个函数（main函数），入队和出队等操作直接在main函数中调用即可。当进队出队异常（如队满）时，要打印出错信息。
// 44.请设计一个算法，在表{22,4,23,11,20,2,15,13,30,45,26,34,29,35,26,36,55,98,56, ,697,535,53474,61,90,80,96,127,158,116,114,28,113,115,12,1411,243,188,187,218,195,210,279,307,492,452,408,361,421,399,856,523}中查找有没有值为x的结点？若有请输出提示，并写出是第几次查找成功的，若无请提示查找失败。实现这个算法，并分析这个算法的复杂度。方法不限，尽量选最好的方法来实现。
// 45.请设计一个算法，对表{22,4,23,11,20,2,15,13,30,45,26,34,29,35,26,36,55,98,56, ,697,535,53474,61,90,80,96,127,158,116,114,28,113,115,12,1411,243,188,187,218,195,210,279,307,492,452,408,361,421,399,856,523}进行降序排序，实现这个算法，并分析这个算法的复杂度。方法不限，尽量选最好的方法来实现。
// 46.请设计一个算法，对表{12,13,14,16,17，18,19,20,22,23，24,26,27,30,32,33，35,36,37,39,40,42,44,45，47,50，52,54,55,57,58,60,62,83,90,100，102，105，106，115,121,123,125,128,130，134}进行升序排序，实现这个算法，并分析这个算法的复杂度。方法不限，尽量选最好的方法来实现
// 47.请设计一个算法，在表{12,13,14,16,17，18,19,20,22,23，24,26,27,30,32,33，35,36,37,39,40,42,44,45，47,50，52,54,55,57,58,60,62,83,90,100，102，105，106，115,134}中查找有没有值为x的结点？若有请输出提示，并写出是第几次查找成功的，若无请提示查找失败。实现这个算法，并分析这个算法的复杂度。方法不限，尽量选最好的方法来实现
// 48.请写出冒泡排序算法，并分析平均情况下的时间复杂度
void BubbleSort1(RecType R[],int n)
{
int i,j,k,exchange;
RecType tmp;
for (i=0; i<n-1; i++)
{
exchange=0;
for (j=n-1; j>i; j–) //比较,找出最小关键字的记录
if (R[j].key<R[j-1].key)
{
tmp=R[j]; //R[j]与R[j-1]进行交换,将最小关键字记录前移
R[j]=R[j-1];
R[j-1]=tmp;
exchange=1;
}
if (exchange==0) //中途结束算法
return;
}
}//平均情况下的时间复杂度 O(n^2)
// 49.请写出折半插入排序算法，并分析平均情况下的时间复杂度
void BinaryInsertSort(T* array, int n) { //array为待排序数组,n为数组大小
int i, j, mid, low, high;
T temp;
for (i = 1; i < n; i++){
temp = array[i]; //把第i+1个元素赋值给temp(数组从下标0开始)
low = 0; //初始化low，array[low]代表数组中第1个元素
high = i; //初始化high，array[high]代表已插入的最后一个元素
while (low <= high){ //不断的折半1/2 1/4 …
mid = (low + high) / 2; //计算中间位置
if (temp > array[mid]){ //插入值大于中间值
low = mid + 1;
}
else { //插入值小于中间值
high = mid - 1;
}
}
for (j = i - 1; j >= low; j--){ //将需要移动的数组向后移
array[j + 1] = array[j];
}
//将值插入到指定位置
array[low] = temp;
}
}// 平均情况下的时间复杂度 O(n*log2 n)
// 50请写出直接插入排序算法，并分析平均情况下的时间复杂度
void InsertSort(RecType R[],int n) //对R[0…n-1]按递增有序进行直接插入排序
{
int i,j;
RecType tmp;
for (i=1; i<n; i++)
{
tmp=R[i];
j=i-1; //从右向左在有序区R[0…i-1]中找R[i]的插入位置
while (j>=0 && tmp.key<R[j].key)
{
R[j+1]=R[j]; //将关键字大于R[i].key的记录后移
j–;
}
R[j+1]=tmp; //在j+1处插入R[i]
}
}// 平均情况下的时间复杂度 O(n^2)
// 51.请写出折半查找算法，并分析平均情况下的时间复杂度
int binary_search(int key,int a[],int n)
{
int low,high,mid,count=0,count1=0;
low=0;
high=n-1;
while(low<high) //査找范围不为0时执行循环体语句
{
count++; //count记录査找次数
mid=(low+high)/2; //求中间位置
if(key<a[mid]) //key小于中间值时
high=mid-1; //确定左子表范围
else if(key>a[mid]) //key 大于中间值时
low=mid+1; //确定右子表范围
else if(keya[mid]) //当key等于中间值时，证明查找成功
{
printf(“查找成功!\n 查找 %d 次!a[%d]=%d”,count,mid,key); //输出査找次数及所査找元素在数组中的位置
count1++; //count1记录查找成功次数
break;
}
}
if(count10) //判断是否查找失敗
printf(“查找失敗!”); //査找失敗输出no found
return 0;
}// 平均情况下的时间复杂度 O(log2 n)
// 52.请写出顺序查找算法，并分析平均情况下的时间复杂度
int SequenceSearch(int a[], int value){
int[] b = new int[a.length + 1];
b[0] = value;
for(int i = 0; i < a.length; i++){
b[i + 1] = a[i];
}
int j = a.length;
while(b[j] != value){
j–;
}
return j;
}// 平均情况下的时间复杂度 O(n)
// 53定义一个采用顺序结构存储的线性表，将所有奇数移到所有偶数的前面，并统计奇数和偶数的个数。实现这个算法，并分析这个算法的复杂度。
status divide(sqlist l,int &js,int &os)
{
int i=0,j=l->length-1;
js=0;
os=0;
elemtype temp,pivot=l->data[0];/pivot即为题目中所说的第一个元素，也称枢纽元素/
while(i<j){
while(i<j&&l->data[j]%2==1)/从右向左找奇数/
j–;
if(i<j){
l->data[i++]=l->data[j];/如果找到，将其存至顺序表左侧/
js++;
}
while(i<j&&l->data[i]%2==0)/从左向右找偶数/
i++;
if(i<j){
l->data[j–]=l->data[i];/如果找到，将其存至顺序表右侧*/
os++;
}
}
}// 平均情况下的时间复杂度 O(n)
————————————————————————
如果有喜欢好看的各种类型的壁纸、头像、朋友圈背景图、QQ名片背景图的朋友可以关注我个人公众号呀
每天分享超好看的各种风格类型 头像！壁纸！朋友圈背景图！嘿嘿！
关注我的公众号：壁纸头像爱好家
