将顺序表(a1,a2,a3,...,an)重新排列为以a1为界的两部分:a1前面的值均比a1小,后面的值均比a1大(数据类型均具有可比性,都设为整型)
#include
#include
#define maxsize 100
typedef struct //顺序表结构
{
int data[maxsize];
int last;
}seqlist;
seqlist *init_seqlist(int arrsize) //顺序表初始化
{
seqlist *L;
L=(seqlist*)malloc(sizeof(seqlist));
L->last=arrsize-1;
return L;
}
void input(seqlist *L)
{
int i;
for(i=0;i<=L->last;i++)
{
scanf("%d",&L->data[i]);
}
}
void show(seqlist*L)
{
int i;
for(i=0;i<=L->last;i++)
{
printf("%d ",L->data[i]);
}
}
void part(seqlist*L)
{
int x,y,i,j;
x=L->data[0];//将基准置入x中
for(i=1;i<=L->last;i++)//注意i从1开始
{
if(L->data[i]data[i];//记录比基准小的数,防止挪位后丢失
for(j=i-1;j>=0;j--)//该数前的数字向后挪一位
{
L->data[j+1]=L->data[j];
L->data[0]=y;//将小的数置入第一个数
}
}
}
}
int main()
{
int arrsize;
seqlist *L;
scanf("%d",&arrsize);
L=init_seqlist(arrsize);
input(L);
part(L);
show(L);
return 0;
}
两个递增有序的单链表A和B,合成链表C,不改变排序性。
输入输出样例:1组
5 //A链表元素个数
2 3 4 10 11 //A链表元素内容,递增有序
3 //B链表元素个数
5 6 12 //B链表元素内容,递增有序
样例输出:
2 3 4 5 6 10 11 12
#include
#include
#include
#define maxsize 1000
typedef struct
{
int data[maxsize];
int last;
} seqlist;
seqlist *init_seqlist(int arrsize)
{
seqlist *L;
L=(seqlist *)malloc(sizeof(seqlist));
L->last=arrsize-1;
return L;
}
void input(seqlist *A)
{
int i;
for(i=0; i<=A->last; i++)
{
scanf("%d",&A->data[i]);
}
}
void bubblesort(seqlist *A)//j将表进行冒泡排序
{
int i,j,temp;
for(i=0; ilast; i++)
{
for(j=i+1; jlast+1; j++)
{
if(A->data[j]data[i])
{
temp=A->data[j];
A->data[j]=A->data[i];
A->data[i]=temp;
}
}
}
}
seqlist * merge(seqlist *A,seqlist *B,seqlist *C)
{
int i=0,j=0,k=0;
while(i<=A->last&&j<=B->last)
{
if(A->data[i]data[j])
{
C->data[k++]=A->data[i++];
}
else
{
C->data[k++]=B->data[j++];
}
}
while(i<=A->last)//表B先结束
{
C->data[k++]=A->data[i++];
}
while(j<=B->last)//表A先结束
{
C->data[k++]=B->data[j++];
}
C->last=k-1;
return C;
}
int main()
{
int i,arrsize1,arrsize2;
seqlist *A,*B,*C;
C=(seqlist *)malloc(sizeof(seqlist));
scanf("%d",&arrsize1);
A=init_seqlist(arrsize1);
input(A);
scanf("%d",&arrsize2);
B=init_seqlist(arrsize2);
input(B);
bubblesort(A);
bubblesort(B);
C=merge(A,B,C);
for(i=0;i<=C->last;i++)
{
printf("%d ",C->data[i]);
}
return 0;
}
顺序表A中删除值在x~y(x<=y)之间的所有元素。
输入输出样例:1组
7 //输入顺序表中结点个数,数组规模可以很大。但是用这个值来指定当前大数组中的前几个用于顺序表中的值
1 2 3 3 4 4 2 //输入当前顺序表中的元素都有哪些
3 6 //分别输入x和y的值,即范围
1 2 2
#include
#include
#define maxsize 100
typedef struct
{
int data[maxsize];
int last;
} seqlist;
seqlist *init_seqlist(int arrsize)
{
seqlist *L;
L=(seqlist *)malloc(sizeof(seqlist));
L->last=arrsize-1;
return L;
}
seqlist *result_seqlist(seqlist *L,int x,int y)
{
int k=0,j,i;
seqlist *S;
S=(seqlist *)malloc(sizeof(seqlist));
if(x==y)
{
for(i=0; i<=L->last; i++)
{
if(L->data[i]==x)
{
for(j=i+1; j<=L->last; j++)
{
L->data[j-1]=L->data[j];
}
L->last--;i--;
}
else
{
S->data[k++]=L->data[i];
}
}
}
else //x,y不相等
{
for(i=0; i<=L->last; i++)
{
if(L->data[i]>=x&&L->data[i]<=y)
{
for(j=i+1; j<=L->last; j++) //将数据进行向前移一位,即删除在此范围内的数
{
L->data[j-1]=L->data[j];
}
L->last--;i--; //表长减一,i减一,从挪位后的新一个数据判断
}
else
{
S->data[k++]=L->data[i];
}
}
}
S->last=k-1;
return S;
}
int main()
{
int i,arrsize,x,y;
seqlist *L,*S;
scanf("%d",&arrsize);
L=init_seqlist(arrsize);
for(i=0; i<=L->last; i++)
{
scanf("%d",&L->data[i]);
}
scanf("%d %d",&x,&y);
S=result_seqlist(L,x,y);
for(i=0; i<=S->last; i++)
{
printf("%d ",S->data[i]);
}
return 0;
}
已知带头结点的单链表L中的结点是按整数值递增排列的,试写一算法,将值为x的结点插入到表L中,使得L仍然递增有序(这里我们将插入和排序用一个函数完成,不用排序和插入两个函数实现)
#include
#include
#define maxsize 1000
typedef struct node
{
int data;
struct lnode *next;
} LNode,*LinkList;
LinkList init_LNode()
{
LinkList L;
L=(LinkList)malloc(sizeof(LNode));
L->data=0;
L->next=NULL;
return L;
}
LinkList insert_linklist(LinkList L,int insert_data)
{
LNode *p,*q,*s;
p=L->next;
q=p;
while(p!=NULL&&insert_datadata)
{
q=p;//q记录前驱结点
p=p->next;
}
if(p==NULL)//为空代表走到了最后或表开始为空
{
s=(LinkList)malloc(sizeof(LNode));
s->data=insert_data;
s->next=NULL;
q->next=s;
}
else
{
s=(LinkList)malloc(sizeof(LNode));
s->data=insert_data;
s->next=p;
q->next=s;
}
return L;
}
void output_link(LinkList L)
{
LNode *p;
p=L->next;
while(p!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
}
int main()
{
int input_data;
LinkList L=init_LNode();
printf("please input the data for the list,100 represent the end\n");
scanf("%d",&input_data);
while(input_data!=100)
{
L=insert_linklist(L,input_data);
scanf("%d",&input_data);
}
output_link(L);//输入结束,输出该表内容
printf("please input the insert data:");
scanf("%d",&input_data);
L=insert_linklist(L,input_data);
output_link(L);
return 0;
}
下面的实例就只写核心过程:
实现单链表的逆置
typedef struct lnode
{
int data;
struct lnode *next;
}LNode,*LinkList;
void reverse(LinkList* L)
{
LNode *p;
p=L->next; //p指向第一个数据结点
L->next=NULL;//将原链表置为空
while(p)
{
q=p;//q为p的前驱结点
p=p->next;
q->next=L->next;//头插法实现逆转
L->nect=q;
}
}
删除一链表中的重复结点
typedef struct lnode
{
int data;
struct lnode *next;
}LNode,*LinkList;
void put_linklist(LinkList *L)
{
LinkList *q,*p,*r;
p=L->next;//p指向第一个数据结点
while(p->next)//p作为基准比较
{
q=p;
if(p==NULL)return;
while(q->next)//q作为待删前驱结点
{
if(q->next->data==p->data)
{
r=q->next;//r为待删结点
q->next=r->next;
free(r);
}
q=q->next;
}
p=p->next;
}
}
有两个单链表A,B,其中元素递增且有序,编写算法将A,B归并成一个按元素之递减(允许有相同值)有序的链表C,要求用A,B中的原结点形成,不能重新申请结点
typedef struct lnode
{
int data;
struct lnode *next;
}LNode,*LinkList;
LinkList merge(LinkList A,LinkList B)//设A,B为带头结点的单链表
{
LNode *p,*q,*s;LinkList C;
p=A->next;q=B->next;
C=A;
free(B);
while(p&&q)
{
if(p->datadata)//从原A,B中取下较小者
{
s=p;p=p->next;
}
else
{
s=q;q=q->next;
}
s->next=C->next;//插到C的头部
C->next=s;
}
if(p==NULL)p=q;//p已结束
while(p)//将剩余的结点一个个摘下,插到C表的头部
{
s=p;p=p->next;
s->next=C->next;
C->next=s;
}
}
将单链表转换为双向循环链表
typedef struct dlnode
{
int data;
struct dlnode *next,*prior;
} DLNode,*DLinkList;
DLinkList Creat_DLinkList(LinkList L)
{
DLinkList H;
DLNode *s,,*p,*rear;
H=(DLNode*)malloc(sizeof(DLNode));//生成H的头结点
H->next=H;//构造H为空的双向循环链表
H->prior=H;
rear=H;
p=L->next;//p指向L的第一个结点
while(p)
{
s=(DLNode*)malloc(sizeof(DLNode));
s->data=p->data;//申请、填充结点
s->next=rear->next;
s->prior=rear;
rear->next=s;
H->prior=s;//结点s插到H的链表尾
rear=s;//修改H的尾指针rear
p=p->next;
}
return H;
}