试设计一个算法,将一个头结点指针为a的单链表A分解为两个单链表A和B

试设计一个算法,将一个头结点指针为a的单链表A分解为两个单链表A和B,其头结点指针分别为a和b。使得A链表只包含原链表A中序号为奇数的元素,而B链表中只包含原链表A中序号为偶数的元素,且保持原来的相对顺序。

程序如下:
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
char data;
struct node *nextPtr;
}*LinkList, Lnode;
static void CreateList(LinkList *headPtr, LinkList *tailPtr, char ch);
static void Decompose(LinkList *headPtrA, LinkList *headPtrB, LinkList *tailPtrB);
static void VisitList(LinkList headPtr);
static void DestroyList(LinkList *headPtr, LinkList *tailPtr);
int main(void)
{
LinkList headPtrA = NULL, tailPtrA = NULL, headPtrB = NULL, tailPtrB = NULL;
char ch;
while (1)
{
printf("Enter ch('@'-quit): ");
scanf(" %c", &ch);
if (ch == '@')
{
break;
}
else
{
CreateList(&headPtrA, &tailPtrA, ch);
}
}
VisitList(headPtrA); /* 打印分解前的链表 */
if (headPtrA != NULL) /* 链表不空的情况对其进行分解 */
{
Decompose(&headPtrA, &headPtrB, &tailPtrB); /* 对链表进行分解*/
}
else
{
printf("headPtrA is empty.\n");
}
VisitList(headPtrA); /* 打印分解后的链表 */
VisitList(headPtrB);
DestroyList(&headPtrA, &tailPtrA); /* 销毁链表 */
DestroyList(&headPtrB, &tailPtrB);
return 0;
}
static void CreateList(LinkList *headPtr, LinkList *tailPtr, char ch)
{
LinkList newPtr;
if ((newPtr = (LinkList)malloc(sizeof(Lnode))) == NULL)
{
exit(1);
}
newPtr -> data = ch;
newPtr -> nextPtr = NULL;
if (*headPtr == NULL)
{
newPtr -> nextPtr = *headPtr;
*headPtr = newPtr;
}
else
{
(*tailPtr) -> nextPtr = newPtr;
}
*tailPtr = newPtr;
}
static void Decompose(LinkList *headPtrA, LinkList *headPtrB, LinkList *tailPtrB)
{
int count = 0;
LinkList cA, pA;
char ch;
cA = NULL;
for (pA = *headPtrA; pA != NULL; cA = pA,pA = pA -> nextPtr)
{
ch = pA -> data;
count++;
if (count % 2 == 0)
{
CreateList(headPtrB, tailPtrB, ch);
cA -> nextPtr = pA -> nextPtr;
}
}
}
static void VisitList(LinkList headPtr)
{
while (headPtr != NULL)
{
printf("%c -> ", headPtr -> data);
headPtr = headPtr -> nextPtr;
}
printf("NULL\n");
}
static void DestroyList(LinkList *headPtr, LinkList *tailPtr)
{
LinkList tempPtr;
while (*headPtr != NULL)
{
tempPtr = *headPtr;
*headPtr = (*headPtr) -> nextPtr;
free(tempPtr);
}
*headPtr = NULL;
*tailPtr = NULL;
}
温馨提示:内容为网友见解,仅供参考
无其他回答

试设计一个算法,将一个头结点指针为a的单链表A分解为两个单链表A和B
if (headPtrA != NULL) \/* 链表不空的情况对其进行分解 *\/ { Decompose(&headPtrA, &headPtrB, &tailPtrB); \/* 对链表进行分解*\/ } else { printf("headPtrA is empty.\\n");} VisitList(headPtrA); \/* 打印分解后的链表 *\/ VisitList(headPtrB);DestroyList(&headPtrA, &tailPtrA...

设计一个算法,将一个头结点指针为a的单链表A分解成两个单链表A和B,使 ...
1.节点计数器 count=1, 当前节点指针 *pCurr=第1个节点。2.count为奇数,pCurr指向的节点保持在A中,否则将pCurr指向的节点放到B中。3.让pCurr指向下一个节点, count++。4.如果pCurr的值不为NULL(即已没到A的末尾),则跳到第2步重复执行,否则退出。

设计一个算法,将一个带头结点的数据域依次为a1,a2,。。an(n>=3)的单...
假设链表节点为 struct Node{ _data_type data; Node *next;};则算法如下:void reverse(Node *head){ Node *p,*q; if (head->next == NULL) return; p = q = head->next; while (p->next !=NULL) { head->next = p->next; p->next->next = q; ...

已知两个单链表A与B分别表示两个集合,其元素类型为int且递增排列,其...
int i=0,j=0,k=0;while(A.elem[i]&&B.elem[j]){ if(A.elem[i]<B.elem[j]) i++;if(A.elem[i]>B.elem[j]) j++;if(A.elem[i]==B.elem[j]){ C.elem[k++]=A.elem[i];i++;j++;} }

有一个带头结点的单链表L,设计一个算法使其元素递增有序排列
=NULL) { \/* 把链表分成两条,一条已经排序好了(L),一条待排序(p)*\/ r=p->next; p->next=NULL; p=r; \/* 对于所有待排序的元素 *\/ while(p!=NULL) { \/*把p链表的第一个元素插入到L,并且将它从p中移除*\/ r=p->next; \/\/r指向p的第二个...

试写一算法在带头结点的单链表结构上实现线性表操作Length(L)。下面各...
intListLength_L(LinkList &L){int i=0;\/\/i存储链表长度,初始为0LinkList p=L;\/\/p为链表的指针,初始为头指针,指向头结点if(p) p=p-next;\/\/如果p指向的头结点不为空,p指向带数据的第一个结点while(p){\/\/如果p非空,i长度加1,且指向下一个结点p=p->next;i++;} return i;\/\/...

设有一个表头为first的单链表,式设计一个算法,通过遍历一趟链表,将链 ...
\/\/处理第一个结点,指针指向NULL,因为逆置后它将是尾结点 while( s != NULL) \/\/当s为空的时候说明p已经指向链表的最后节点了 { pre = p;p = s;s = s ->next;p -> next = pre; \/\/指针反转 } L ->next = p; \/\/处理最后一个结点,头结点的指针指向它 return L;} ...

设计一个算法,在一个单链表中值为y的结点前插入一个值为x的结点。
\/* 在带头结点的单链线性表L中第i个位置之前插入元素e *\/ \/***\/ Status ListInsert(LinkList L, int i, ElemType e){ int j = 0;LinkList p = L, s;while( p && j < i-1) \/* 寻找第i-1个结点 *\/ { p = p->next;j++;} if( !p|| j > i-1) \/* i小于1或者大于...

数据结构 设计一个算法判定一个带头结点的单链表的元素值是否递增的
基本思路:从首元(头结点指向的节点)开始,依次查看是此节点的数据否有下一个节点的数据大,如果存在一个节点的数据比下一个节点大,说明不是递增。反之如果考察到最后一个节点之前都比下一个节点小,那么就是递增 如果节点定义如下:typedef struct LNode{\/\/定义节点类型 ElemType data; \/\/...

设计一个算法,将两个递增链表La、Lb合并成一个递增链表Lc。
\/\/设计一个算法,将两个递增链表La、Lb合并成一个递增链表Lc;La,Lb,Lc均为带头结点的链表 include<stdio.h> typedef int datatype;struct PNode { datatype data; \/\/定义链表中结点的数据域,DATATYPE为数据类型 struct PNode *next; \/\/定义链表中结点的指针域 };typedef struct PNode ...

相似回答