设计一个算法,将一个头结点指针为a的单链表A分解成两个单链表A和B,使得A中元素为奇数,B中元素为偶数.

请给出具体的C语言程序!谢谢!

第1个回答  2009-05-12
程序如下:

#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,使 ...
1.节点计数器 count=1, 当前节点指针 *pCurr=第1个节点。2.count为奇数,pCurr指向的节点保持在A中,否则将pCurr指向的节点放到B中。3.让pCurr指向下一个节点, count++。4.如果pCurr的值不为NULL(即已没到A的末尾),则跳到第2步重复执行,否则退出。

试设计一个算法,将一个头结点指针为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与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++;} }

设计一个算法,将一个带头结点的数据域依次为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; ...

设计一个计算单链表(链表带头结点)中结点个数的算法,并依此输出链表中的...
int data;struct node *next;}node;void count(node* l)\/\/计算节点个数,输出所有值 { int n = 0;node* p = l->next;while(p){ printf("%d ",p->data);p = p->next;n++;} printf("\\n%d\\n",n);} int main(){ int e;\/\/头节点 node *head,*p,*q;head = (node*)...

有一个带头结点的单链表L,设计一个算法使其元素递增有序排列
\/* 插入排序法 *\/void sort(Linklist *&L){ LinkList *p=L->next, *q, *r; if(p!=NULL) { \/* 把链表分成两条,一条已经排序好了(L),一条待排序(p)*\/ r=p->next; p->next=NULL; p=r; \/* 对于所有待排序的元素 *\/ while(p!=NULL) { ...

数据结构算法题,合并两个链表的算法,计算时间复杂度。
如果要比较两个链表的大小,那就得将两具链表分别访问一次,这样至少需要m+n次访问,不如直接访问一个链表到结束,然后将另一个链表连接到结尾处,这样平均需要访问(m+n)\/2次,这样算法的时间复杂度应该为O(m+n)

...的结点的循环单链表LA、LB,编写一个算法,将两个循环单链表合并为一...
为 m , lb 的元素个数为 n。循环单链表是单链表的另一种形式,其结构特点链表中最后一个结点的指针域不再是结束标记,而是指向整个链表的第一个结点,从而使链表形成一个环。和单链表相同,循环链表也有带头结点结构和不带头结点结构两种,带头结点的循环单链表实现插入和删除操作较为方便。

若x和y是两个单链表表示的串,请设计一个算法,找出x中第一个不在y中出 ...
【答案】:(1)数据结构采用字符串的链接表示(用带头结点的单链表表示)定义。(2)思路从x的第一个字符开始在y中查找,找到第一个不在y中出现的字符,将这个字符返回。若x中所有字符均在y中出现,则返回'\\0'。(3)算法char FindChar(LinkString x,LinkString y){\/*找出串x中第一个不在串y中...

将一个单链表分解成两个相同结构的链表,使得一个链表存放原链表中的奇数...
\/\/起始单链表存储在头结点headA所指向的序列,执行完后头结点headA所在序列保存奇数序列 \/\/headB所在序列保存偶数序列 void detachList(Node &headA, Node &headB){ Node * p = &headA;Node * q = &headB;while(p->next != NULL){ if(p->next->data % 2 == 0){\/\/为偶数该节点...

相似回答