#include
#include
typedef struct node{
int data;
struct node *next;
//struct node *prior;
}Lnode,*Linklist;
//单链表初始化,定义一个Linklist(Lnode*)型函数,由其带回头指针地址
Linklist InitList(){
Lnode *L;
L=(Lnode* )malloc(sizeof(Lnode));
if(L==NULL){
printf("申请内存失败!!");
exit(0);
}
L->next==NULL;// 双向链表中需要L->prior==NULL;
return L;
}
//尾插法创建单链表
void ListInsertTail(Linklist *L){
int n,num;
Lnode * p;//存储要插入的元素
Lnode *r=L;//指向尾结点 ,也可作 Lnode *r;r=(*L)
printf("请输入链表元素个数n=");
scanf("%d",&n);
for(int i=0;idata=num;//结点数据域中放入元素
r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
r=p;//r指向新的尾结点
}
r->next=NULL;//将最终的结点next域值设为NULL
}
//输出单向链表
void Printlist(Linklist L){
Lnode *p;
p=L->next;
printf("链表为:");
while(p!=NULL){
printf("%d ",p->data);
p=p->next;
}
}
//获取长度
void Getlength(Linklist L){
Linklist p;
p=L->next;//p指向第一个结点
int count=0;//计数器
while(p!=NULL){
count++;
p=p->next;
}
printf("链表的长度是 %d\n",count);
}
//获取第XX个元素的内容
void Getelement(Linklist L){
Linklist p=L->next;//利用p从头结点开始顺着链表扫描,此后p依次下移指向当前扫描到的结点
int count=1;//计数器
int target;
int XX;//目标元素序号
printf("目标元素的排列序号是(从1开始)");
scanf("%d",&XX);
while(p!=NULL && countnext;
count++;
}
if(!p && countdata;
printf("目标元素是%d",target);
}
//按值查找,获取指定元素中链表中的位置(默认链表中无重复元素)
void Findlocation(Linklist L){
Linklist p;
p=L->next;
int count =1,count2=1;
int target;
printf("目标元素的值是");
scanf("%d",&target);
while(p&&p->data!=target){
p=p->next;
count++;
}
if(p) printf("%d在链表中是第%d个元素",target,count);
else printf("链表中没有该元素!!");
}
//插入,在第i个元素前插入元素e
void Insert(Linklist L){
int i,e;
int count=0;//计数器
printf("请问在哪个元素位置前插入什么元素?");
scanf("%d %d",&i,&e);
Lnode *s;
Lnode *p=L;//p指向头结点
while(p&&countnext;
count++;
}
if(!p||count>i-1)printf("插入位置非法!!");//i小于1(刚开始count=0时,若i=0则非法)或者大于表长加1,亦或者表空
else{
s=(Lnode*)malloc(sizeof(Lnode));//生成新结点
s->data=e;//将s的数值域设置为e
s->next=p->next;//将结点s插入L中,新结点s的指针域指向ai结点
p->next=s;
Printlist(L);
}
}
//删除第i个结点
void Deleteelem(Linklist L){
int i,e,count=0;
printf("请输入需要删除的结点:");
scanf("%d ",&i);
Linklist p=L;
Linklist q;
printf("7");
while(p->next && countnext;
count++;
}
printf("6");
if(!(p->next )||count>i-1 ){printf("删除位置不合理!!");}
q=p->next;
printf("1");
// p->data=q->next->data;
e=q->data;
printf("2");
p->next=q->next;
printf("3");
free(q);
printf("4");
Printlist(L);
printf("5");
}
int main(){
Linklist list;
list=InitList();
ListInsertTail(list);
Printlist(list);
Getlength(list);
Getelement(list);
Findlocation(list);
Insert(list);
Deleteelem(list);
return 0;
}
# include
# include
# include
//定义结构体(结点)
typedef struct _node {
int value;
struct _node * next;
} Node;
//定义数据结构struct _list表示整个链表
//存放链表的信息:头结点(如果有的话)或首结点、尾结点、链表长度等等
typedef struct _list
{
Node* head;//始终指向首结点
Node* tail;//始终指向尾结点
int size;//表示链表的长度,用在List_Insert函数中,用来判断输入的位置i是否越界,可以简化代码
} List;
//初始化链表
bool InitList(List* pList)
{
pList->head = pList->tail = NULL;
pList->size = 0;
return true;
}
//判空
bool Empty(List* pList)
{
return (pList->head==NULL);
}
//在指定结点之后添加结点
bool InsertNextNode(Node* p, int elem)
{
bool sign = true;
if(p == NULL)
{
sign = false;
}
Node* s = (Node*)malloc(sizeof(Node));
if(s == NULL)//内存分配失败
{
sign = true;
}
s->value = elem;
s->next = p->next;
p->next = s;
return sign;
}
//在指定节点之前添加结点
/*
偷天换日的操作!
指定结点的前驱结点是未知的,从头结点遍历的话时间复杂度高O(n)
虽然结点不能交换位置,但是结点中的数据可以交换位置[O(1)]
*/
bool InsertPriorNode(Node* p, int elem)
{
bool sign = true;
if(p == NULL)
{
sign = false;
}
Node* s = (Node*)malloc(sizeof(Node));
if(s == NULL)
{
sign = false;
}
//连接
s->next = p->next;
p->next = s;
//下面两个语句是精髓
s->value = p->value;//将结点p中的元素复制到s中
p->value = elem;//p中元素替换为elem
return sign;
}
//删除指定结点p(局限:当该结点是尾结点时,无法完成操作)
bool DeleteNode(Node* p)
{
bool sign = true;
if(p == NULL)
{
sign = false;
}
Node* q = p->next;//q指向p的后继结点
p->value = p->next->value;//p结点和它的后继结点交换数据
p->next = q->next;//将q结点删除
free(q);
return sign;
}
//结点添加(尾添加)
Node* List_AddOnTail(List* pList, int number)//传入指针的指针
{
//分配结点空间,并写入p->value
Node* p = (Node*)malloc(sizeof(Node));
p->value = number;
p->next = NULL;
//head始终指向首结点,tail始终指向尾结点
//如果链表是空的,最新分配的结点(p)既是head,也是tail
if(pList->head == NULL)
{
pList->head = p;
pList->tail = p;
}
//如果链表不是空的,只需要处理tail
else
{
pList->tail->next = p;//此时链表的尾结点要指向新分配的结点
pList->tail = p;//新分配的结点成为链表的tail
}
pList->size ++;
pList->tail->next = NULL;//tail里面的指针必须是NULL
/* //在链表的尾结点之后添加结点,需要循环,
Node* last = pList->head;
if(last)
{
while(last->next)
{
last = last->next;
}
//接上去
last->next = p;
}
else
{
pList->head = p;
}
*/
return pList->head;
}
//结点添加(头添)
Node* List_AddOnHead(List* pList, int n)
{
Node* p = (Node*)malloc(sizeof(Node));
p->value = n;
p->next = NULL;
if(pList->head == NULL)
{
pList->head = p;
pList->tail = p;
}
else
{
p->next = pList->head;
pList->head = p;
}
pList->size ++;
return pList->head;
}
//遍历输出链表
void List_Print(List* pList)
{
Node* p;
for(p=pList->head; p; p=p->next)
{
printf("%-5d", p->value);
}
printf("\n");
}
//查(按位)
Node* List_GetElem(List* pList, int i)
{
Node* q;
if(i<1 || i>pList->size)
q = NULL;
else
{
Node* p = pList->head;
int j = 1;
while(jnext;
j++;
}
q = p;
}
return q;
}
//查(按值)
bool List_Search(List* pList, int number)
{
bool isFound = false;
Node* p;
for(p=pList->head; p; p=p->next)
{
if(p->value == number)
{
isFound = true;
break;
}
}
return isFound;
}
//按值删除元素(仅删除第一个)
void List_DeleteByValue(List* pList, int number)
{
Node* prev;
Node* p;
Node* q;
for(p=pList->head,q=NULL; p; q=p,p=p->next)
{
if(number == p->value)
{
if(q)
{
q->next = p->next;
}
else
{
pList->head = p->next;
}
free(p);
break;
}
}
}
//更改指定元素
void List_Change(List* pList, int a, int b)
{
Node* p;
for(p=pList->head; p; p=p->next)
{
if(p->value == a)
{
p->value = b;
}
}
}
//在指定位置添加元素,引入链表长度(pList->size)
bool List_Insert(List* pList, int i, int elem)
{
bool sign = true;
if(i<1 || i>pList->size+1)
sign = false;
else if(i == 1)
{
Node* s = (Node*)malloc(sizeof(Node));
s->value = elem;
s->next = pList->head;
pList->head = s;
}
//找到第i-1个结点
else
{
Node* p = List_GetElem(pList, i-1);//封装 找到第i-1个结点,注意这里传入的参数是List*类型
sign = InsertNextNode(p,elem);//封装 在第i-1个结点之后插入新结点
}
return sign;
}
//按位序删除元素
bool List_DeleteByOrder(List* pList, int i, int* elem)
{
bool sign = true;
if(i<1 || i>pList->size+1)
sign = false;
else if(i == 1)
{
Node* p = pList->head;
pList->head = p->next;
free(p);
}
//找到第i-1个结点
else
{
Node* p = List_GetElem(pList, i-1);//简单的封装 注意这里传入的参数是List*类型
if(p==NULL || p->next==NULL)//i值越界或者第i-1个结点没有后继结点
{
sign = false;
}
Node* q = p->next;
*elem = q->value;
p->next = q->next;
free(q);
}
return sign;
}
//清除链表
bool List_Clear(List* pList)
{
Node* p;
Node* q;
bool sign = true;
if(pList->head == NULL)
sign = false;
p = pList->head->next;
while(p)
{
q = p->next;
free(p);
p = q;
}
pList->head->next = NULL;//注意!!!不能少
return sign;
}
int main(void)
{
//创建并初始化,输入元素
List list;
InitList(&list);
int number;
printf("请输入整数(输入-1结束):\n");
do
{
scanf("%d", &number);
if(number != -1)
{
list.head = List_AddOnTail(&list, number);//注意这里要传入head的地址
//list.head = List_AddOnHead(&list, number);
}
}while(number != -1);
//遍历并输出链表
printf("链表中的元素为:");
List_Print(&list);
//查(按值)
printf("\n请输入您要查找的元素:");
scanf("%d", &number);
if(List_Search(&list, number) == true)
{
printf("找到了!\n");
}
else
{
printf("没找到!\n");
}
//查(按位)
printf("请输入您要查找的位序:");
int i, elem;
scanf("%d", &i);
if(List_GetElem(&list, i) != NULL)
{
printf("找到了!该元素是%d\n", List_GetElem(&list, i)->value);//这个地方的写法有问题吗?
}
else
{
printf("位序越界!\n");
}
//删除,按元素值
printf("\n请输入您要删除的元素:");
scanf("%d", &number);
if(List_Search(&list, number) == true)
{
List_DeleteByValue(&list, number);
printf("删除成功!当前链表中的元素为:");
List_Print(&list);
}
else
{
printf("删除失败!您要删除的元素不存在!\n");
}
//更改链表元素
int a, b;
printf("\n请输入旧元素:");
scanf("%d", &a);
if(List_Search(&list, a))
{
printf("请输入新元素:");
scanf("%d", &b);
List_Change(&list, a, b);
printf("更改成功!当前链表元素为:");
List_Print(&list);
}
else
{
printf("未找到!\n");
}
//插入元素
printf("\n请输入您要插入的位置和数字:");
scanf("%d%d", &i, &elem);
if(List_Insert(&list, i, elem))
{
printf("插入成功!当前链表元素为:");
List_Print(&list);
}
else
{
printf("插入失败!\n");
}
//按位序删除元素
printf("\n请输入您要删除的结点的位序:");
scanf("%d", &i);
if(List_DeleteByOrder(&list, i, &elem))
{
printf("删除成功!删除的元素为:%d\n当前链表元素为:", elem);
List_Print(&list);
}
else
{
printf("删除失败!\n");
}
//链表清除
if(List_Clear(&list))
{
printf("\n链表已清空!\n");
}
else
{
printf("\n清空失败,链表为空\n");
}
return 0;
}
#include
#include
typedef int ElemType;
//定义单链表的结构体
typedef struct Node{
ElemType data; //数据域 存储该Node数据
struct Node *next; //指针域 指向下一个Node
}LinkList;
//返回一个初始化的节点L
LinkList* InitList(){
LinkList* L; //定义一个节点
L = (LinkList*)malloc(sizeof(LinkList)); //分配节点空间
L->next = NULL; //节点指针域置空
return L;
}
//功能说明:在单链表的尾部添加元素,返回添加元素后的尾节点
//参数1:LinkList *r 要添加元素的单链表的尾节点
//参数2:ElemType e 要添加的元素e
//返回值:LinkList * r 新的尾节点
//实现方式:
//1.定义一个临时的节点n 给临时节点开辟空间
//2.元素e存入临时节点的数据域中 将临时节点n的next置空
//3.将尾节点的next指向临时节点n 尾节点后移 返回新的尾节点
LinkList *tailAddElemLinkList(LinkList *r,ElemType e) {
//定义一个临时的节点n 给临时节点开辟空间
LinkList *n = (LinkList*)malloc(sizeof(LinkList));
//元素e存入节点n中
n->data = e;
//将临时节点n的next置空
n->next = NULL;
//将新节点插入末尾
r->next = n;
//尾指针后移一位
r = r->next;
//返回新的尾节点
return r;
}
//功能说明:创建单链表,从键盘输入len个数插入到单链表L中
//参数1: LinkList* L 要链接节点的头节点
//参数2:int len 要添加的节点个数
//实现方式:
//定义一个尾指针r 定义变量e用于存储每次输入的元素值
//使用循环每次输入一个元素值 将元素通过尾部添加到单链表
void createList(LinkList* L,int len){
//定义一个尾指针r并初始化为头指针
LinkList* r = L;
//定义变量e用于存储每次输入的元素值
ElemType e;
printf("请输入%d个单链表的元素:",len);
int i;
for(i = 0; i < len; i++){
//获取输入的元素
scanf("%d",&e);
r = tailAddElemLinkList(r,e);
}
}
//功能说明:输出单链表中的节点值
//参数: LinkList* L 要显示的单链表的头节点
//实现方式:定义一个节点p指向第一个节点 循环判断节点p是否存在,存在则输出data,节点p向后移动一位
void showLinkList(LinkList* L) {
LinkList* p = L->next;
while(p){
printf("%d ",p->data);
p = p->next;
}
}
//功能说明:单链表从小到大的排序 冒泡排序 (值交换)
//参数: LinkList* L 单链表的头节点
// 实现方式: 从第一个元素节点开始逐一比较,将节点的值进行交换
void linkListSort(LinkList* L){
LinkList* i = L->next;
LinkList* j = L->next;
//外层循环
while(i){
//内层循环
while(j){
//值交换
if(i->data > j->data){
ElemType e = i->data;
i->data = j->data;
j->data = e;
}
j = j->next;
}
j = i->next;
i = i->next;
}
}
//功能说明:判断某个元素在单链表中是否存在 存在返回1 不存在返回-1
//参数1: LinkList *L 单链表的头节点
//参数2:要查找的元素e
//实现方式:遍历单链表L,拿元素e和单链表L中的所有元素匹配 成功返回1 失败返回-1
int searchElem(LinkList *L, ElemType e){
LinkList *temp = L->next;
while(temp){
if(e == temp->data) return 1;
temp = temp->next;
}
return -1;
}
//功能说明:将单链表的数据存到另一个单链表的末尾 重复元素不存入
//参数1: LinkList *L1 存取元素的单链表的头节点
//参数2: LinkList *L1_rear 存取元素的单链表的尾节点
//参数3:LinkList *L2_head 被存取的单链表的头节点
//实现方式:
// 遍历单链表L2,判断每一个元素在L1中是否存在
//不存在则存入该元素到L1,L1的尾节点后移,最后返回L1的尾节点
LinkList *spliceLinkList(LinkList *L1,LinkList *L1_rear,LinkList *L2_head){
LinkList *r = L1_rear;
while(L2_head){
//判断单链表a里面的元素在单链表L存不存在, 不存在则存入(数据去重)
if(searchElem(L1,L2_head->data) == -1){
//将L2_head->data从尾节点r存入L1中
r = tailAddElemLinkList(r,L2_head->data);
}
L2_head = L2_head->next;
}
return r;
}
//功能说明:返回两个单链表的并集
//参数1:LinkList *a 单链表a的头节点
//参数1:LinkList *b 单链表b的头节点
//实现方式: 将两个单链表去重后存入一起,排序成一个有序链表 (使用上面封装的函数实现)
LinkList *unionLinkList(LinkList *a,LinkList *b){
//初始化一个单链表L用于存储 单链表a和单链表b的并集
LinkList *L = InitList();
LinkList *r = L;
LinkList *a_head = a->next;
LinkList *b_head = b->next;
r = spliceLinkList(L,r,a_head);
r = spliceLinkList(L,r,b_head);
//排序合并的并集结果
linkListSort(L);
return L;
}
//功能说明:返回单链表a-b的差集
//参数1:LinkList *a 单链表a的头节点
//参数1:LinkList *b 单链表b的头节点
//实现方式:
//遍历单链表a
//判断单链表a里面的每一个元素在单链表b中是否存在
//不存在则存入新的单链表L
LinkList *diffLinkList(LinkList *a,LinkList *b){
//初始化一个单链表L用于存储 单链表a和单链表b的并集
LinkList *L = InitList();
LinkList *r = L;
LinkList *a_head = a->next;
while(a_head){
//判断单链表b里面的元素在单链表a存不存在,不存在则存入(数据去重)
if(searchElem(b,a_head->data) == -1 && searchElem(L,a_head->data) == -1){
r = tailAddElemLinkList(r,a_head->data);
}
a_head = a_head->next;
}
//排序合并的并集结果
linkListSort(L);
return L;
}
//功能说明:返回单链表a和b的交集 (和上面的函数一模一样,判断里面改一下就行)
//参数1:LinkList *a 单链表a的头节点
//参数1:LinkList *b 单链表b的头节点
//实现方式:
//遍历单链表a
//判断单链表a里面的每一个元素在单链表b中是否存在
//存在则存入新的单链表L
LinkList *intersectionLinkList(LinkList *a,LinkList *b) {
//初始化一个单链表L用于存储 单链表a和单链表b的并集
LinkList *L = InitList();
LinkList *r = L;
LinkList *a_head = a->next;
while(a_head){
//判断单链表b里面的元素在单链表a存不存在, 存在则存入(数据去重)
if(searchElem(b,a_head->data) == 1 && searchElem(L,a_head->data) == -1){
r = tailAddElemLinkList(r,a_head->data);
}
a_head = a_head->next;
}
//排序合并的并集结果
linkListSort(L);
return L;
}
//功能说明:判断两个单链表是否完全相等
//参数1:LinkList *a 单链表a的头节点
//参数1:LinkList *b 单链表b的头节点
//返回值:相等返回 int 1 不相等返回 int 0
//单链表a和单链表b如果他们的差集都为空,则他们完全相等
int equalLinkList(LinkList *a,LinkList *b){
//判断a-b和b-a的差集是否都为空 差集为空则相等
if(!diffLinkList(a,b)->next && !diffLinkList(b,a)->next){
return 1;
}
return 0;
}
int main(){
//初始化一个节点作为头节点
LinkList* L1 = InitList();
LinkList* L2 = InitList();
int len;
printf("请输入要创建的第一个单链表长度:");
scanf("%d",&len);
createList(L1,len);
printf("第一个单链表的元素为:");
showLinkList(L1);
printf("\n请输入要创建的第二个单链表长度:");
scanf("%d",&len);
createList(L2,len);
printf("第二个单链表的元素为:");
showLinkList(L2);
printf("\n两个单链表的并集:");
showLinkList(unionLinkList(L1,L2));
printf("\n单链表a-b的差集:");
showLinkList(diffLinkList(L1,L2));
printf("\n单链表b-a的差集:");
showLinkList(diffLinkList(L2,L1));
printf("\n单链表a和单链表b的交集:");
showLinkList(intersectionLinkList(L2,L1));
printf("\n单链表的数据是否相等:");
if(equalLinkList(L2,L1))
printf("相等");
else
printf("不相等");
return 0;
}
利用单链表A表示一个非零整数序列,把链表A分解为两个具有相同结构的链表B和C,其中B表的结点为A表中值小于零的结点,而C表的结点为A表中值大于零的结点。要求空间复杂度为O(1)。
输入
第一行输入链表A的长度n;
第二行输入链表A的n个元素(以空格间隔)。
输出
第一行输出链表B的元素;
第二行输出链表C的元素(以空格间隔)。
样例输入 Copy
3 -6 1 -2 4 -3 8
样例输出 Copy
-6 -2 -3
3 1 4 8
#include
#include
typedef struct node{
int data;
struct node *next;
//struct node *prior;
}Lnode,*Linklist;
//单链表初始化,定义一个Linklist(Lnode*)型函数,由其带回头指针地址
Linklist InitList(){
Lnode *L;
L=(Lnode* )malloc(sizeof(Lnode));
if(L==NULL){
printf("申请内存失败!!");
exit(0);
}
L->next==NULL;// 双向链表中需要L->prior==NULL;
return L;
}
void ListInsertTail(Linklist *L){
int n,num;
Lnode * p;//存储要插入的元素
Lnode *r=L;
scanf("%d",&n);
for(int i=0;idata=num;//结点数据域中放入元素
r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
r=p;//r指向新的尾结点
}
r->next=NULL;//将最终的结点next域值设为NULL
}
void InsertTail(Linklist *L,int e){
Lnode * p;//存储要插入的元素
Lnode *r=L;
p=(Lnode*)malloc(sizeof(Lnode));//生成新结点
p->data=e;//结点数据域中放入元素
r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
r=p;//r指向新的尾结点
r->next=NULL;//将最终的结点next域值设为NULL
}//输出单向链表
void Printlist(Linklist L){
Lnode *p;
p=L->next;
while(p!=NULL){
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
void Resolve(Linklist La, Linklist Lb,Linklist Lc)
{
Lnode * pre = La;
Lnode * pb = Lb;
Lnode * pa = La;
pa = pa->next;
while (pa)
{
if (pa->data < 0)
{
Lnode *p=(Lnode *)malloc(sizeof(Lnode));
p = pa; //生成新节点
pre->next = pa->next; //删除小于0的节点,pre始终为pa的前驱
pa = pa->next; //pa后移
p->next = NULL; //后插法将元素插入Lb中
pb->next = p;
pb = p; //插入
}
else //大于0
{
pre = pa;
pa = pa->next; //pre为pa的前驱,pa指针后移动。
}
}
}
int main(){
Linklist l1,l2,l3;
l1=InitList();
l2=InitList();
l3=InitList();
ListInsertTail(l1);
Resolve(l1,l2,l3);
Printlist(l2);
Printlist(l1);
return 0;
}
链表A和B分别示两个递增的整数集合,求出A和B的差集(即仅由在A中出现而不在B中出现的元素所构成的集合),并以同样的形式存储,同时返回该集合的元素个数。要求空间复杂度为O(1)。
输入
第一行为序列A的长度n;
第二行为序列A的n个元素;
第三行为序列B的长度m;
第四行为序列B的m个元素(元素之间用空格分隔)。
输出
若有差集:
第一行输出两个递增有序链表中元素的差集;
第二行输出该差集中元素的个数。
若无差集:
输出0
样例输入 Copy
5
1 3 5 7 9
5
1 2 3 4 5
样例输出 Copy
7 9
2
#include
#include
typedef struct node
{
int data;
struct node * next;
}Node;
typedef struct list
{
Node* head;
Node* tail;
int length;
}List;
void Init_list(List* L)
{
Node* first = (Node*)malloc(sizeof(Node));
if(!first) printf("wrong!\n");
first -> data = 0;
first -> next = NULL;
L->head = L->tail = first;
int size_list;
scanf("%d",&size_list);
L->length = size_list;
for(int i = 0; i< size_list; i++)
{
Node* new = (Node*)malloc(sizeof(Node));
scanf("%d",&new -> data);
new -> next = NULL;
L->tail -> next = new;
L->tail = new;
}
}
void chaji(List* l1, List l2)
{
Node *p, *q,*save,*prev;
p = l1->head->next; q = l2.head->next; prev = l1->head;
while(p && q)
{
if(p->data == q->data)
{
p = p -> next;
q = q-> next;
prev -> next = p;
l1->length --;
}
else if(p->data > q->data)
{
q = q->next;
}
else
{
prev = p;
p = p->next;
}
}
}
void print_list(List L)
{
Node* p;
p = L.head->next;
while(p != NULL)
{
printf("%d ",p->data);
p = p -> next;
}
printf("\n");
}
int main(int argc, char const *argv[])
{
List l1,l2;
Init_list(&l1);
Init_list(&l2);
chaji(&l1,l2);
if(l1.length==0){
printf("0");
}
else {
print_list(l1);
printf("%d\n", l1.length);
}
return 0;
}
单链表A和B分别示两个递增的整数集合,求出A和B的交集并以同样的形式存储,并存放在A中。要求空间复杂度为O(1)。
输入
第一行为序列A的长度n;
第二行为序列A的n个元素;
第三行为序列B的长度m;
第四行为序列B的m个元素(元素之间用空格分隔)。
输出
若有交集:
第一行输出单链表A和B的交集,每个数据之间用空格分隔;
第二行输出该交集中元素的个数。
若无交集:
输出0
#include
#include
typedef struct node
{
int data;
struct node * next;
}Node;
typedef struct list
{
Node* head;
Node* tail;
}List;
void only_init(List *L)
{
Node* first = (Node*)malloc(sizeof(Node));
if(!first)
printf("-1");
first -> data = 0;
first -> next = NULL;
L->head = L->tail = first;
}
void Init_list(List* L)
{
Node* first = (Node*)malloc(sizeof(Node));
if(!first)
printf("-1");
first -> data = 0;
first -> next = NULL;
L->head = L->tail = first;
int length;
scanf("%d",&length);
for(int i = 0; i< length; i++)
{
Node* new = (Node*)malloc(sizeof(Node));
scanf("%d",&new -> data);
new -> next = NULL;
L->tail -> next = new;
L->tail = new;
}
}
int merge(List l1,List l2,List *l3)
{
Node *p, *q,*w,*save,*prev;
p = l1.head->next; q = l2.head->next; w = l3->tail;
int count=0;
w -> next = NULL;
while(p && q)
{
if(p->data == q->data)
{count++;
save = p;
p = p -> next;
q = q-> next;
w -> next = save;
save -> next = NULL;
w = w -> next;
}
else if(p->data < q -> data)
{
p = p->next;
}
else
q = q->next;
}
return count;
}
void print_list(List L)
{
Node* p;
p = L.head->next;
while(p != NULL)
{
printf("%d ",p->data);
p = p -> next;
}
printf("\n");
}
int main(int argc, char const *argv[])
{
List l1,l2,l3;
Init_list(&l1);
Init_list(&l2);
only_init(&l3);
int P= merge(l1,l2,&l3);
if(P==0){
printf("0");
}
else {
print_list(l3);
printf("%d",P);}
return 0;
}
利用单链表表示一个整数序列,通过一趟遍历在单链表中确定值最大的结点。
输入
第一行输入元素个数n;
第二行依次输入链表的n个元素(以空格间隔)。
输出
输出单链表的最大值。
#include
#include
typedef struct node{
int data;
struct node *next;
//struct node *prior;
}Lnode,*Linklist;
//单链表初始化,定义一个Linklist(Lnode*)型函数,由其带回头指针地址
Linklist InitList(){
Lnode *L;
L=(Lnode* )malloc(sizeof(Lnode));
if(L==NULL){
printf("申请内存失败!!");
exit(0);
}
L->next==NULL;// 双向链表中需要L->prior==NULL;
return L;
}
void ListInsertTail(Linklist *L){
int n,num;
Lnode * p;//存储要插入的元素
Lnode *r=L;
scanf("%d",&n);
for(int i=0;idata=num;//结点数据域中放入元素
r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
r=p;//r指向新的尾结点
}
r->next=NULL;//将最终的结点next域值设为NULL
}
//输出单向链表
void Printlist(Linklist L){
Lnode *p;
p=L->next;
while(p!=NULL){
printf("%d ",p->data);
p=p->next;
}
}
void FindMax( Linklist l ) {
int max,temp;
Lnode *p=l->next;
//Lnode *r;
max=p->data;
if(p==NULL){
exit(0);
}
while (p!=NULL){
if(maxdata){
max=p->data;
}
p=p->next;
}
printf("%d",max);
}
int main(){
Linklist l1;
// Lnode *l2;
l1=InitList();
// l2=InitList();
ListInsertTail(l1);
FindMax(l1);
return 0;
}
利用单链表表示一个整数序列,通过一趟遍历,将单链表中所有结点的链接方向逆转。要求空间复杂度为O(1)。
输入
第一行为单链表的长度n,
第二行为单链表的n个元素(元素之间用空格分隔)。
输出
逆序输出单链表中的元素,元素之间用空格分隔。
#include
#include
typedef struct node{
int data;
struct node *next;
//struct node *prior;
}Lnode,*Linklist;
//单链表初始化,定义一个Linklist(Lnode*)型函数,由其带回头指针地址
Linklist InitList(){
Lnode *L;
L=(Lnode* )malloc(sizeof(Lnode));
if(L==NULL){
printf("申请内存失败!!");
exit(0);
}
L->next==NULL;// 双向链表中需要L->prior==NULL;
return L;
}
void ListInsertTail(Linklist *L){
int n,num;
Lnode * p;//存储要插入的元素
Lnode *r=L;
scanf("%d",&n);
for(int i=0;idata=num;//结点数据域中放入元素
r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
r=p;//r指向新的尾结点
}
r->next=NULL;//将最终的结点next域值设为NULL
}
//输出单向链表
void Printlist(Linklist L){
Lnode *p;
p=L->next;
while(p!=NULL){
printf("%d ",p->data);
p=p->next;
}
}
Linklist ReverseList( Linklist l ) {
Linklist p = l->next, l1;
l1 = (Lnode*)malloc(sizeof(Lnode));
l1->data = l->data;
l1->next = NULL;
while (p)
{
Linklist q;
q =(Lnode*)malloc(sizeof(Lnode));
q->data = p->data;
q->next = l1->next;
l1->next = q;
p = p->next;
}
return l1;
}
int main(){
Linklist l1;
Lnode *l2;
l1=InitList();
l2=InitList();
ListInsertTail(l1);
// Printlist(l1);
l2=ReverseList(l1);
Printlist(l2);
return 0;
}
创建一个含有n个整型元素的递增单链表,删除单链表中值大于等于min且小于等于max的所有元素(min和max是给定的两个参数,min
输入
第一行输入元素个数n;
第二行依次输入n个元素(元素之间用空格分隔);
第三行输入给定的min和max(以空格间隔)。
输出
输出顺序表中删除元素后的所有元素,元素之间用空格分隔(若成功删除);
-1(若未成功删除)。
#include
#include
typedef struct node{
int data;
struct node *next;
//struct node *prior;
}Lnode,*Linklist;
//单链表初始化,定义一个Linklist(Lnode*)型函数,由其带回头指针地址
Linklist InitList(){
Lnode *L;
L=(Lnode* )malloc(sizeof(Lnode));
if(L==NULL){
printf("申请内存失败!!");
exit(0);
}
L->next==NULL;// 双向链表中需要L->prior==NULL;
return L;
}
//尾插法创建单链表
void ListInsertTail(Linklist *L,int n){
int num;
Lnode * p;//存储要插入的元素
Lnode *r=L;//指向尾结点 ,也可作 Lnode *r;r=(*L)
if(n==0){
printf("-1");
exit(0);
}
for(int i=0;idata=num;//结点数据域中放入元素
r->next=p;//将新元素插入到表尾,在双向链表中需要在该行前加上p->prior=r;
r=p;//r指向新的尾结点
}
r->next=NULL;//将最终的结点next域值设为NULL
}
//输出单向链表
void Printlist(Linklist L){
Lnode *p;
p=L->next;
while(p!=NULL){
printf("%d ",p->data);
p=p->next;
}
}
void Delete(Linklist L,int n){
int min,max;
scanf("%d %d",&min,&max);
Lnode *p=L->next;//首元结点p
Lnode *pre,*s,*q;
if(min>max||L->next==NULL){
printf("-1");
exit(0);
}
if(p->data>max){//首元结点大于max
printf("-1");
exit(0);
}
if(p->data>=min){//首元结点大于min且小于max
while(p->data<=max&&p->next!=NULL){
s->next=p->next;
free(s);
p=s->next;
}
if(p->next==NULL&&p->data<=max){
free(p);
s->next=NULL;
}
}
else{//首元结点小于min
q=p->next;
while(q->datanext==NULL){
printf("-1");
exit(0);
}
p=p->next;
q=q->next;
}
while (q->data <= max&&q->next!=NULL){
p->next = q->next;
free(q);
q = p->next;
}
if (q->next == NULL&&q->data <= max){
free(q);
p->next = NULL;
}
}
}
int main(){
Linklist l1;
l1=InitList();
int n;
scanf("%d",&n);
ListInsertTail(l1,n);
Delete(l1,n);
Printlist(l1);
return 0;
}
题目描述
给定两个非递减的整数序列A和B,利用链表表示序列A和B,将A和B合并为一个非递减的有序序列C,序列C允许有重复的数据。要求空间复杂度为O(1)。
输入
第一行为序列A的长度n;
第二行为序列A的n个元素;
第三行为序列B的长度m;
第四行为序列B的m个元素(元素之间用空格分隔)。
输出
输出合并后的序列,每个数据之间用空格分隔。
样例输入 Copy
5
1 3 5 7 9
5
2 4 6 8 10
样例输出 Copy
1 2 3 4 5 6 7 8 9 10
#include
#include
#define LIST_INIT_SIZE 20
#define LISTINCREMENT 10
#define OK 1
typedef int ElemType;
typedef int Status;
typedef struct Node{
ElemType data;
struct Node *next;
}LNode,*LinkList;
//头插法创建链表
void InitList(LNode *L){
int n; scanf("%d",&n);
int i;
for(i=0;idata);
s->next=L->next;
L->next=s;
}
}
//尾插法创建链表
void Create(LNode *L){
int n; scanf("%d",&n);
int i;
LNode *s,*r=L;//使r指向尾结点
for(i=0;idata);
r->next=s;
r=s;
}
r->next=NULL;
}
//输出
void print(LNode*L){//倒着输出的
LNode *p=L->next;
while(p){
printf("%d ",p->data);
p=p->next;
}
}
int ListBing(LinkList s1,LinkList s2,LinkList s3)
{
LNode *p=s1->next,*q=s2->next,*x=s3,*s;
while (p&&q) //查找第i-1个结点或遍历到表尾
{ s=(LinkList)malloc(sizeof(LNode));
if(p->data<=q->data)
{
s->data=p->data;
p=p->next;
}
else if(p->data>=q->data){
s->data=q->data;
q=q->next;
}
x->next=s;
x=s;
}
x->next=NULL;
if(p)
{
x->next=p;
}
if(q)
{
x->next=q;
}
return 1;
}
int main(){
LNode line1,line2,line3;
int i,x;
LNode *s1=&line1,*s2=&line2,*s3=&line3;
Create(s1);
Create(s2);
ListBing(s1,s2,s3);
print(s3);
return 0;
}