设单链表中指针p指向结点ai,指针f指向将要插入的新结点 x，则当x插在链表中两个数据元素ai和ai+1之间时，

node *mergelink(node *p, node *q)
{
node *h, *r;
h = (node*) malloc (sizeof(node));
h->next = NULL;
r = h;
while (p != NULL && q != NULL)
{
if (p->data <= q->data)
{
r->next = p;
r = p;
p = p->next;
}
else
{
r->next = q;
r = q;
q = q->next;
}
}

if (p == NULL)
r->next = q;
if (q == NULL)
r->next = p;

p = h->next;
h = h->next;
free(p);
return h;
}

完全满足你的要求#include
#include

typedef int NodeType;

typedef struct _node {
NodeType data;
struct _node *next;
} Linklist;

void display(Linklist *head) {
Linklist *p;
for(p = head->next; p; p = p->next)
printf("%d%c", p->data, (p->next ? ',':'n'));
}

void split(Linklist *a, Linklist *b, Linklist *c) {
Linklist *bp = b, *cp = c, *p;
for(p = a->next; p; p = p->next) {
if(p->data < 0) {
bp->next = p;
bp = p;
} else if(p->data > 0) {
cp->next = p;
cp = p;
}
}
bp->next = NULL;
cp->next = NULL;
}

int main(){
Linklist *a = (Linklist*)malloc(sizeof(Linklist)),
*b = (Linklist*)malloc(sizeof(Linklist)),
*c = (Linklist*)malloc(sizeof(Linklist)),
*ap = a;
a->next = NULL;
b->next = NULL;
c->next = NULL;
int i;
for(i = 0; i < 50; i++) {
int data = rand()%100 - 50;
Linklist *q = (Linklist*)malloc(sizeof(Linklist));
q->data = data;
q->next = NULL;
ap->next = q;
ap = q;
}
display(a);
split(a, b, c);
display(b);
display(c);
return 0;
}运行结果：
-9,17,-16,-50,19,-26,28,8,12,14,-45,-5,31,-23,11,41,45,-8,-23,-14,41,-46,-48,3,42,32,-29,-34,-32,45,-3,-24,21,-12,19,-38,17,49,-15,44,-47,-39,-28,-17,23,14,-9,-39,3,18-9,-16,-50,-26,-45,-5,-23,-8,-23,-14,-46,-48,-29,-34,-32,-3,-24,-12,-38,-15,-47,-39,-28,-17,-9,-3917,19,28,8,12,14,31,11,41,45,41,3,42,32,45,21,19,17,49,44,23,14,3,18

#include
#include
#include
#include

#define elem int
#define M 10
typedef struct node
{
elem data;
struct node *next;
}no;

//以下单链表均带头节点
//1.
int f1(no *L,elem x)
{
int i=0;
L=L->next;
while(L)
{
if(L->data==x)
i++;
L=L->next;
}
return i;
}
//2.算法复杂度为O(N)
void f2(no *L,int k1,int k2)
{
if(k1>=k2)
{
coutnext;
}
while(L && L->datanext=L->next;
free(q);
L=p->next;
}
}
//3.算法采用的是头插法
node *f3(no *a,no *b)
{
if(!a || !b)
return 0;
node *c=new node,*p;
if(!c)
exit(1);
c->next=0;
while(a->next || b->next)
{
if(!a->next || b->next && b->next->data < a->next->data)
{//当链表a为空时，或b链表存在且b链表的第一个值小于a链表
p=b->next;
b->next=p->next;
}
else
{
p=a->next;
a->next=p->next;
}
p->next=c->next;
c->next=p;
}
return c;
}

来我空间来看~~456875423加!

1、C 3、A 4、n(n-1)/2 5、P->next->next->next 6、240
第二道题,B、C、D都不对,A不怎么确定

C、h->head->a1->a2->a3->a1
所以a2->next为a3,a2->next->next为a1

你这是什么呀，C++不对，伪代码也不是？
伪代码如下：
p = head;
q = head->next
while (q)
if p->data == q->data
t = q;
q = q->next;
delete t;
else
p->next = q;
p = q;

O(1)和O(n)

/*
有n个人围坐在一起形成头尾相接的一个环,从第m个人开始报数,每次有人数到r时,zhe
*/
#include
using namespace std;
// 表示一个犯人的结构体
struct Prisoner
{
// 编号
int id;
// 密码
int pass;
// 用于链表的指针
struct Prisoner * pre;
struct Prisoner * next;
};
class JosephCircle
{
public:
// 基本的约瑟夫构造函数
JosephCircle(int N,int M,int R);
// 输出约瑟夫环
void print();
// 开始处决犯人
void start();
private:
int N,M,R;
// 约瑟夫环的头指针
struct Prisoner * head;
// 第一个被处决的犯人的节点指针
struct Prisoner * firstPunishedPrision;
};
JosephCircle::JosephCircle(int N,int M,int R)
{
this->N = N;
this->M = M;
this->R = R;

struct Prisoner * p , *pr;
// 约瑟夫环的头指针初始化为空
this->head = NULL;
// 构造一个由 N 个犯人组成的约瑟夫环
for(int i=1;ihead == NULL)
{
// 新增一个犯人
p = new struct Prisoner();
// 犯人编号
p -> id = i;
// 犯人密码
p -> pass = R;
// 紧挨着的下一个犯人（因为是环状的,每个人都会有紧挨着的其他犯人）
p -> pre = p;
p -> next = p;
// 约瑟夫环的头指针
this->head = pr = p;
}
else
{
p = new struct Prisoner();
p -> id = i;
p -> pass = R;
p -> pre = pr;
p -> next = pr->next;

pr -> next -> pre = p;
pr -> next = p;

pr = p;
}
}

// 寻找约瑟夫环里面第一个被处决的犯人的【节点指针】
firstPunishedPrision = head;
for(int i=2;ifirstPunishedPrision = this->firstPunishedPrision -> next;
}
}
// 输出约瑟夫环
void JosephCircle::print()
{
cout pre = q -> pre;
p = p -> next;
// 输出被处决的犯人的信息
cout

呵呵，数据结构有个有名的算法：归并排序，这个算法可以解决你的问题。自己可以网上找找，或找本数据结构的书，书里也有着算法。以下是严蔚敏的《数据结构（c语言版）》里归并排序里的核心算法，这个算法就是你要的把两个有序表归并成一个有序表。void Merge(RcdType SR[],RcdType &TR[],int i,int m,int n){ //将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] for(j=m+1,k=i;i

前驱结点,后继结点.

删除q节点，
首先要把q的next的值赋给p的next域，即p->next=q->next
否则整个链表就断开了。
然后释放q.
所以选D
---------------------------------------
B、p=q->next是把指针p移动到q 的下一位，不能删除q,free(q)没用的。
A、p,q本就是指针加*取其内容再.next不知其意。

根据你的想法我写了个 一位一个结点的 只是正长整数相加 负数没有考虑 你可以自己完善下！
代码如下：
#include
#include
#define X 101 //100位加1位进位
typedef struct NODE//单链表
{
int data;
struct NODE *next;
}List;
List *Create(char *n)//加数输入到链表
{
int i,ws=0,num=0;
char *x;
List *head,*p,*q;
x=n;
while(*x++) ws++;
head=p=(List *)malloc(sizeof(List));
//printf("%s",n);
for(i=ws-1;i>=0;i--)
{
q=(List *)malloc(sizeof(List));
q->data=n[i]-'0';
if(num==0)
{
p=q;
head=p;
}
else
p->next=q;
p=q;
num++;
}
for(i=0;idata=0;
p->next=q;
p=q;
}
q=(List *)malloc(sizeof(List));
q->data=0;
p->next=q;
p=q;p->next=NULL;
return head;
}
List *SUM(List *p,List *q)//求和
{
int jw=0,tem=0;//进位
List *head,*y;
head=(List *)malloc(sizeof(List));
head=NULL;
while(p!=NULL)
{
tem=p->data+q->data+jw;
if(tem>=10)
jw=1;
else
jw=0;
tem=tem%10;
y=(List *)malloc(sizeof(List));
y->data=tem;
y->next=head;
head=y;
p=p->next;q=q->next;
}
return head;
}
void Print(List *head)//输出结果
{
int num=0;
List *p;
p=head;
while(p!=NULL)
{
if(p->data!=0)num=1;
if(num==1)
{
printf("%d",p->data);
}
p=p->next;
}
}
main()
{
List *js1,*js2,*sum1;
char *p="654456793422",*q="4567898";
js1=Create(p);//加数输入到链表
js2=Create(q);//加数输入到链表

printf("加数1:%s",p);
printf("");
printf("加数2:%s",q);
sum1=SUM(js1,js2);//求和
printf("");
printf("求和:");
Print(sum1);
printf("");
}

给你一个判断题：
顺序表结构适于进行顺序存取，而链表适于进行随机存取。请判断。
答案：错误。
刚好弄反了。
知道这，就能解决你的问题了。 谢谢加分~

/* 插入p的前面 */
int*q;
q=p->prior;
s->next=p;
s->prior=q;
q->next=s;
p->prior=s;
/* 插入p的后面 */
int*q;
q=p->next;
s->next=q;
s->prior=p;
q->prior=s;
p->next=s;

本人书写并调试近2小时，已经调试通过；将下面代码分别保存为data.h data.c user.c
然后编译user.c data.c即可；
/*
* data.h
* */
#ifndef __DATA_H__
typedef struct node {
int id;
struct node *p_next;
} node, *ll_head;
ll_head ll_create(void); /* create a linked list */
node *ll_input(node *);
void ll_insert(ll_head, node *); /* insert a node to the linked list */
void ll_delete(ll_head, node *); /* delete a node from the linked list */
node *ll_locate(ll_head, int); /* return if the node exists */
void ll_free(ll_head); /* free memory */
void ll_traversal(ll_head); /* traversal the linked list */
#endif /* __DATA_H__*/
/*
* data.c
* */
#include
#include
#include "data.h"
/* create a linked list */
ll_head ll_create(void)
{
node *new = malloc(sizeof(struct node));
if (new == NULL) {
perror("malloc");
return NULL;
}
new->p_next = NULL;
//printf("create linked list successfully !");
return new;
}
/* insert a node to the linked list */
void ll_insert(ll_head head, node * tmp)
{
if (ll_locate(head, tmp->id)) {
printf("the id(%d) has exited", tmp->id);
return;
}
node *new = malloc(sizeof(struct node));
if (new == NULL) {
perror("malloc");
return;
}
new->id = tmp->id;
new->p_next = NULL;
node *this = head;
for (this = head; this; this = this->p_next) {
/* insert id to link list in order */
if (this->p_next == NULL) {
this->p_next = new;
break;
} else if (this->p_next->id > tmp->id) {
new->p_next = this->p_next;
this->p_next = new;
break;
}
}
}
/* delete a node from the linked list */
void ll_delete(ll_head head, node *tmp)
{
node *this = head;
node *fro = this;
int flag = 0;
for (; this;) {
fro = this;
this = this->p_next;
if (this->id == tmp->id) {
fro->p_next = this->p_next;
free(this);
this = fro;
flag = 1;
printf("delete id(%d)", tmp->id);
}
}
if (this == NULL && flag == 0) {
printf("the node not exists");
}
}
/* free the memory of the linkedlist */
void ll_free(ll_head head)
{
node *fro = head;
node *this = head;
for (; this->p_next;) {
fro = this;
this = this->p_next;
fro->p_next = this->p_next;
//printf("free(%02d,%02d) ", this->x, this->y);
free(this);
this = fro;
}
//printf("");
}
/* return if the node exists */
node *ll_locate(ll_head head, int id)
{
node *this = head;
while (this = this->p_next) {
if (this->id == id) {
return this;
}
}
return NULL;
}
/* traversal the linked list */
void ll_traversal(ll_head head)
{
node *this = head;
while (this = this->p_next) {
printf("%d ", this->id);
}
printf("");
}
/*
* user.c
* */
#include
#include
#include "data.h"
int main()
{
node *ll_head = ll_create();
node tmp;
int num = 0;
while (num++

大工11秋《数据结构》在线作业1
一,单选题
1. B
2. B
3. B
4. A
5. A
6. C
7. B
8. B
9. C
10.B
二,判断题
1.B
2.A
3.B
4.B
5.B
6.A
7.B
8.B
9.B
10.A
大工11秋《数据结构》在线作业2
一,单选题
1. difference(A,B,C)表示求集合A和B的差集C.若A={b,c,d},B={c,e},则difference(A,B,C)运算后C=( ).
A. {b,c,d,e}
B. {c}
C. {b,d}
D. {b,c,c,d,e}
正确答案：C
2. 具有6个顶点的无向图至少应有（）条边才能确保是一个连通图.
A. 5
B. 6
C. 7
D. 8
正确答案：A
3. min(A),函数的返回值是集合A的所有元素中按线性序最小的那个元素.则min({2,3,4})=( )
A. 2
B. 3
C. 4
D. 0
正确答案：A
4. index(s,t)表示子串定位运算.若串t是串s的子串,则函数返回值是串t在串s中第一次出现的开始位置,否则返回值是0.若s="ababa",t="ba",则index(s,t)=( ).
A. 0
B. 1
C. 2
D. 3
正确答案：C
5. 在一棵二叉树上第5层的结点数最多为（）,设树根为第1层.
A. 16
B. 15
C. 8
D. 32
正确答案：A
6. intersection(A,B,C)表示求集合A和B的交集C.若A={b,c,d},B={c,e},则intersection(A,B,C)运算后C=( ).
A. {b,c,d,e}
B. {c}
C. {b,d}
D. {b,c,c,d,e}
正确答案：B
7. 在一个具有n个顶点和e条边的无向图的邻接表中,边结点的个数为（）.
A. n
B. ne
C. e
D. 2e
正确答案：D
8. union(A,B,C)表示求集合A和B的并集C.若A={b,c,d},B={c,e},则union(A,B,C)运算后C=( ).
A. {b,c,d,e}
B. {c}
C. {b,d}
D. {b,c,c,d,e}
正确答案：A
9. 在一个具有n个顶点和e条边的有向图的邻接表中,保存顶点单链表的表头指针向量的大小至少为（）.
A. n
B. 2n
C. e
D. 2e
正确答案：A
10. concat(s,t)表示连接运算.将串t连接在串s之后,形成新的串s.若s="beg",t="in",则concat(s,t)之后,s="( )".
A. begin
B. bein
C. begn
D. beggin
正确答案：A
二,判断题
1. 树中的结点数等于所有结点的度数加1.
A. 错误
B. 正确
正确答案：B
2. 有向图用邻接表表示,顶点i的度是对应顶点i链表中结点个数.
A. 错误
B. 正确
正确答案：A
3. 字典是一种特殊的集合,其中每个元素由关键码和属性组成.
A. 错误
B. 正确
正确答案：B
4. 有向图用邻接表表示,顶点i的出度是对应顶点i链表中结点个数.
A. 错误
B. 正确
正确答案：B
5. 一个图的邻接矩阵表示是惟一的.
A. 错误
B. 正确
正确答案：B
6. 有向图的邻接矩阵一定是对称矩阵.
A. 错误
B. 正确
正确答案：A
7. 无向图的邻接矩阵一定是对称矩阵.
A. 错误
B. 正确
正确答案：B
8. 一个图的邻接表表示是惟一的.
A. 错误
B. 正确
正确答案：A
9. 非空二叉树上叶子结点数等于双分支结点数加1.
A. 错误
B. 正确
正确答案：B
10. 连通图的生成树不一定是惟一的.
A. 错误
B. 正确
正确答案：B
大工11秋《数据结构》在线作业3
一,单选题
1. 下述几种排序方法中,要求内存量最大的是（）.
A. 插入排序
B. 选择排序
C. 堆排序
D. 归并排序
正确答案：D
2. 堆排序是一种（）排序.
A. 插入
B. 选择
C. 交换
D. 归并
正确答案：B
3. 在长度为n的顺序表中进行顺序查找,查找失败时需与关键字比较次数是( ).
A. n
B. 1
C. n-1
D. n+1
正确答案：D
4. 用起泡排序方法对n个记录按排序码从小到大排序时,当初始序列是按排序码从大到小排列时,与排序码总比较次数是（）.
A. n-1
B. n
C. n+1
D. n(n-1)/2
正确答案：D
5. 对线性表进行顺序查找时,要求线性表的存储结构是（）.
A. 倒排表
B. 索引表
C. 顺序表或链表
D. 散列表
正确答案：C
6. 对于顺序存储的有序表(5,12,20,26,37,42,46,50,64),若采用折半查找,则查找元素26的查找长度为( ).
A. 2
B. 3
C. 4
D. 5
正确答案：C
7. 哈希表的平均查找长度和（）无直接关系.
A. 哈希函数
B. 装填因子
C. 哈希表记录类型
D. 处理冲突的方法
正确答案：C
8. 排序方法中,从未排序序列中挑选元素,并将其依次放入已排序序列（初始时为空）的一端的方法,称为（）.
A. 希尔排序
B. 归并排序
C. 插入排序
D. 选择排序
正确答案：D
9. 磁带适合存储的文件类型是（）.
A. 索引文件
B. 顺序文件
C. 散列文件
D. 倒排文件
正确答案：B
10. 排序方法中,从未排序序列中依次取出元素与已排序序列（初始时为空）中的元素进行比较,将其放入已排序序列的正确位置上的方法,称为（）.
A. 插入排序
B. 冒泡排序
C. 希尔排序
D. 选择排序
正确答案：A
二,判断题
1. 散列表既是一种查找方法,又是一种存储方法.
A. 错误
B. 正确
正确答案：B
2. 在散列文件中删除记录时,只要对被删记录作一标记即可.
A. 错误
B. 正确
正确答案：B
3. 散列文件中存放一组记录的存储单位称为桶.
A. 错误
B. 正确
正确答案：B
4. 二分查找对线性表的存储结构无任何要求.
A. 错误
B. 正确
正确答案：A
5. 直接选择排序属于选择类排序,是一种稳定的排序方法.
A. 错误
B. 正确
正确答案：A
6. 哈希表查找无须进行关键字的比较.
A. 错误
B. 正确
正确答案：A
7. 对快速排序来说,初始序列为正序和反序都是最坏情况.
A. 错误
B. 正确
正确答案：B
8. 在执行某个排序过程中,出现排序码朝着最终位置相反方向移动,则该算法是不稳定的.
A. 错误
B. 正确
正确答案：A
9. 堆排序是一种不稳定的排序方法.
A. 错误
B. 正确
正确答案：B
10. 若待排序记录已按排序码基本有序,则应采用直接插入排序或起泡排序.
A. 错误
B. 正确
正确答案：B

建议研究下单向链表的逆序
把题目要求的操作从头开始做到尾，链表就逆序了。
所以逆序搞懂了，你的题目只是其中的一次移动步骤

（ × ）1. 链表的每个结点中都恰好包含一个指针。
答：错误。链表中的结点可含多个指针域，分别存放多个指针。例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。
（ × ）2. 链表的物理存储结构具有同链表一样的顺序。
错，链表的存储结构特点是无序，而链表的示意图有序。
（ × ）3. 链表的删除算法很简单，因为当删除链...

1、k ->c->n
2、j->l->h->k->c->n
3、j->l->g->c->n
4、l->j->m->n
5、l->j->f->"p->next = NULL"->n //删除尾节点需要有个->next = NULL 的赋值吧,选项没有

#include
using namespace std;


typedef struct LNode
{
int data;
struct LNode *next;
}LinkList;

LNode *ptr;

void CreateHeadNode(LNode *&h)
{
h = (LNode*)malloc(sizeof(LNode));
h->next = NULL;
ptr = h;
}

void Destory(LNode *&h)
{
LNode*p = NULL;
while(h->next)
{
p = h;
h = h->next;
free(p);
}
}


void Insert(int value)
{
LNode *node;
node = (LNode*)malloc(sizeof(LNode));
node->data = value;
node->next = NULL;
ptr->next = node;
ptr = node;
}


void DeleteNode(LNode *&head, int data)
{
LNode *curr = head->next;//当前节点
LNode *pre = head;//当前节点的前驱节点
//找到删除位置
while (curr != NULL curr->data < data)
{
pre = curr;
curr = curr->next;
}

//删除节点,可能有连续多个需要删除
while (curr != NULL curr->data == data)
{
LNode*del = curr;
pre->next = curr->next;
curr = curr->next;
free(del);
}
}



void DispList(LinkList *L )
{
LinkList *p = L->next;
while(p != NULL)
{
cout<data<<" ";
p = p->next;
}
cout<}

int main()
{
int data;
LinkList *list;
int arr[] = {0, 1, 3, 3, 3 ,4, 5, 6, 7, 8};

CreateHeadNode(list);
for(int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
{
Insert(arr[i]);
}

cout<<"删除前:";

DispList(list);

cout<<"输入待删除的节点值:";
cin>>data;
DeleteNode(list, data);

cout<<"删除后:";
DispList(list);

Destory(list);
return 0;
}

vs2005测试通过:
删除前:0 1 3 3 3 4 5 6 7 8 8 9
输入待删除的节点值:3
删除后:0 1 4 5 6 7 8 8 9
Press any key to continue . . .

删除前:0 1 3 3 3 4 5 6 7 8 8 9
输入待删除的节点值:5
删除后:0 1 3 3 3 4 6 7 8 8 9
Press any key to continue . . .

删除前:0 1 3 3 3 4 5 6 7 8 8 9
输入待删除的节点值:9
删除后:0 1 3 3 3 4 5 6 7 8 8
Press any key to continue . . .

很久没做题了，猜的啊，你问老师不是更好嘛。有标准答案了也贴上来给我学习学习哈：
一道填空题： 在单链表中，要在已知结点*P之前插入一新节点，需找到_（前一节点）___，其时间复杂度为_（O(n)）___，而在双链表中，完成同样操作的时间复杂度为__（O(1)）__。
这个补充的我也不知道是相同还是不同，猜一下吧……
问题补充：
还有一个： 在一个不带头结点的单链表中,在表头插入或删除与其在其他位置插入或删除操作的过程__（不同）____。

1、A的data数组中元素依次为a2,a4,a6...,A的length元素为(n/2)下取整
2、该程序将单循环链表中排在偶数次序的元素（也就是第2,4,6,8,10...)赋值到顺序表A中

这其实是玩了一点技巧,并非是在p之前插入s结点,而是在p之后插入s结点,完了后,再交换两个结点的数据,后面的数据就跑到前面去了
从存储的次序而言,其最终结果就像是真正地在p前插入结点s一样

(10)先用Q保存结点P的指针
(12)借用P变量来指到表头来准备遍历表L
(8)遍历整个表,直到定位到Q结点的前一个的前一个结点,保存到P
Q=P->next;
(3)连接要删除的结点前后相邻两个结点
(14)此时,Q结点已被孤立,可以安全删除了

P->next==L

你可以看看线性代数,里面有讲

p=p--; 改成 p--;

这个过程无非就是每次比较这两个升序链表的当前第一个结点，谁小，谁就先被摘下，实施头插入法插入到新链表的表头就可以了，因为无论如何次序，这m + n个结点一定都会执行这个步骤，所以总时间复杂度一定是O(m + n)，自然最合适的答案就是D了

m叉树的多重链表中每个结点有m个指针域,n个结点共有n*m个指针域,非空指针域的个数（即分支的个数）共n-1个,所以空指针域有n*m-(n-1)=n(m-1)+1

这道题确实是用链表做的,用链表进行筛选法筛数.题目比较简单,下面的代码使用数组模拟链表的程序.此题也跟POJ的2552题相同!
---------------------------------------------------
#include
#include
#include
int top;
int res[3011];
struct Node{
int v;
int next;
};
Node L[50001];
int N;int main()
{
int i,j,k,p;
for(i=2;i=3001 ) break;
j=i;
while(L[j].next!=-1)
{
k=0;
while(L[j].next!=-1&&k

等价于(*L).length

一个节点右指针域不空的条件,是该节点不是其父节点的最后一个子节点.
根据题目给出的数据,
a是根节点,可以认为它是其父的最后一个节点,所以右指针域为空；
a的三个子节点中,b和c不是最后子节点,所以右指针域不空,而d的右指针域为空；
同理,e的右指针域不空,而f和g的右指针域均为空.
所以,右指针域不空的节点分别为：b,c和e,共3个,选C.
该链表大致如下：
a
/
b

c
/
e d

f
/
g

B错主要在于
链表中交换2个值,只要变动下next指针即可,没有数据的拷贝复制,而线性表需要交换2个值,需要拷贝节点的内容,节点的内容如果是个结构或者类对象的话,还涉及到构造什么的,开销还是挺大的
交换值肯定是链表比线性表快

对错对对对

B D都正确.
我验证过的.你可以试试
#include
using namespace std;
struct list
{
int data;
list *prior;
list *next;
};
int main()
{
list *p, *s, *q;
p = new list;
q = new list;
s = new list;
p->data = 1;
s->data = 2;
q->data = 3;
p->next = q;
q->prior = p;
p->next->prior=s;s->next=p->next;s->prior=p;p->next=s;
cout data data next->data;
}

2
Int subth(BTNode *t)
{
int l,r;
if(!t)
return 0;
l=subth(t-> left);
r=subth(t-> right);
if(l

#include
// 对于节点的定义
struct Node
{
int data;
struct Node *next;
};
// 合并两个递减有序的链表
struct Node *merge(struct Node *p1, struct Node *p2)
{
struct Node *head = NULL, *p = NULL, *pt;
// 当两链表均不空时的合并逻辑
while(p1 && p2)
{
// 将两链表当前节点中值较大的一个记录下来，
// 并后移指向该链表当前节点的指针
if(p1->data > p2->data)
{
pt = p1;
p1 = p1->next;
}
else
{
pt = p2;
p2 = p2->next;
}
if(p == NULL)
{
// 若当前新链表为空，将p和head指向找到的节点
head = p = pt;
}
else
{
// 将新节点链入当前链表尾部
p->next = pt;
p = pt;
}
}
// 找到隶完成合并的那个链表，将其链接到新链表的尾部
pt = p1 == NULL ? p2 : p1;
if(pt)
{
if(p == NULL)
{
// 如果新链表仍为空，直接指向非空的链表
head = p = pt;
}
else
{
// 将未完成合并的链表链接到新链表的尾部
p->next = pt;
}
}
return head;
}
// 链表倒置
struct Node *reverse(struct Node *head)
{
struct Node *newHead = NULL, *p;
if(!head)
{
return newHead;
}
// 先将新的头指针指向原链表的第一个节点
newHead = head;
head = head->next;
newHead->next = NULL;
// 将原链表中剩下的节点依次加到新链表的头部，以实现倒序
while(head)
{
p = head->next;
head->next = newHead;
newHead = head;
head = p;
}
return newHead;
}
int main()
{
struct Node *h1, *h2, *head;
// 生成原始的两个链表的逻辑请自行编写
// 首先，合并两个链表
head = merge(h1, h2);
// 然后，将合并后的链表倒置
head = reverse(head);
// 输出处理后的链表中的内容
while(head)
{
printf("%d ", head->data);
head = head->next;
}
getchar();
return 0;
}
以上程序是按照 zhangchaoyiay 所说的算法思路编写，其实在合并的过程中，可以直接完成倒序操作，这个楼主自己琢磨一下好了，呵呵

莫笑农家腊酒浑丰年留客足鸡豚山重水复疑无路柳暗花明又一村萧鼓追随春社近

既然不能用链表中的元素个数,那就得另想办法了.
我给你思想吧.程序你自己写了.
算法思想：
1、单链表如果知道头结点的指针,那么可以顺着结点的指针域一直找下去来遍历元素.
2、那么我们可以这样,从第一个结点开始取值,然后判断这个结点到单链表结束是不是倒数第k个,如果不是,继续往下取第二个结点值,然后判断这个结点到单链表结束是不是倒数第k个,后续依次.（其中要求判断的是个循环）
还有一种算法,最笨的 就是链表转换成顺序表,不过这个顺序表的空间可是个问题哦.
程序我不想代劳了.你自己练习吧.

未知长度单链表求倒数第K个元素解法：
1.指针a从链表头结点移动k个位置
2.指针b从头结点开始移动,同时指针a从第k个位置开始移动,当a到达链表尾部时,指针b到达倒数第k个元素位置.
设链表长度为n,a从k到尾部移动了n-k,所以b也移动了n-k,所以b的位置是倒数n-(n-k)=k

我下面这个代码自己测试通过，就是少了一个删除功能，很容易额，自己加上去吧（没有任何错误）#include
#include
int m, n;
int count = 1;struct Node
{
int data;
struct Node *next;
}*A,*B,*C,*D;
//打印AList列表
void printList(struct Node *AList)
{
struct Node *post; post = AList->next;
switch(count)
{
case 1:
printf("nListA: ");
break;
case 2:
printf("nListB: ");
break;
case 3:
printf("nListC: ");
break;
case 4:
printf("nListD: ");
break;
default:
printf("nList: ");
break;
} while (post)
{
printf("%d ",post->data);
post = post->next;
} count ++;
}
//初始化表头,列表含有表头
void init()
{
A = (struct Node*)malloc(sizeof(struct Node));
A->data = 0;
A->next = 0;
B = (struct Node*)malloc(sizeof(struct Node));
B->data = 0;
B->next = 0;
C = (struct Node*)malloc(sizeof(struct Node));
C->data = 0;
C->next = 0;
D = (struct Node*)malloc(sizeof(struct Node));
D->data = 0;
D->next = 0;
}//读取列表A和B
void ReadListAB()
{
int i;
struct Node *post;
struct Node *pre;
// 输入列表长度
printf("m="); scanf("%d",&m);
printf("n="); scanf("%d",&n);//读取列表A
pre = A;
for(i=1; idata);
post->next = 0;
pre->next = post;
pre = post;
}
//读取列表B
pre = B;
for(i=1; idata);
post->next = 0;
pre->next = post;
pre = post;
}
}
//合并列表A和B
void MergeABToC()
{
int i;
struct Node *pre, *postA, *postB, *postC; pre = C;
postA = A->next;
postB = B->next;

if(m >= n)
{
for(i=1; idata = postA->data;
postC->next = 0;
pre->next = postC;
pre = postC;
postC = (struct Node*)malloc(sizeof(struct Node));
postC->data = postB->data;
postC->next = 0;
pre->next = postC;
pre = postC; postA = postA->next;
postB = postB->next; }
for(i=n+1; idata = postA->data;
postC->next = 0;
pre->next = postC;
pre = postC;

postA = postA->next;
}
}
else
{
for(i=1; idata = postB->data;
postC->next = 0;
pre->next = postC;
pre = postC;
postC = (struct Node*)malloc(sizeof(struct Node));
postC->data = postA->data;
postC->next = 0;
pre->next = postC;
pre = postC; postA = postA->next;
postB = postB->next; }
for(i=m+1; idata = postB->data;
postC->next = 0;
pre->next = postC;
pre = postC;

postB = postB->next;
}
}

}//使用直接插入法，将C排序输出D
void SortCToD()
{
struct Node *pre, *postC, *postD, *lopD;
int len;
//表示总的长度
len = m + n;
pre = D; //指向D有序数列的尾指针
postC = C->next; //指向C列表 //列表D第一个节点加入
postD = (struct Node*)malloc(sizeof(struct Node));
postD->data = postC->data;
postD->next = 0; pre->next = postD;
pre = postD;
postC = postC->next;
while (postC)
{
//pre为指向插入的前一个节点，lopD是指向插入的后一个节点
pre = D;
lopD = D->next; while (lopD)
{
if (lopD->data > postC->data)
break;
else
{
pre = lopD;
lopD = lopD->next;
} } //将节点插入
postD = (struct Node*)malloc(sizeof(struct Node));
postD->data = postC->data;
postD->next = 0; pre->next = postD;
postD->next = lopD;


//循环条件
postC = postC->next;

}
}void main(void)
{
init();
ReadListAB();
MergeABToC();
SortCToD(); printList(A);
printList(B);
printList(C);
printList(D);
}

尾指针为L,
节点p入队
if(L==NULL) //空队列
{
p->next=p;
}
else
{
p->next=L->next;
L->next=p;
}
L=p;
出队:
node *p;
if(L==NULL) //空队列
return NULL;
if(L->next==L)//就一个节点
{
p=L;
L=NULL;
}
else
{
p=L->next;
L->next=p->next;
}
p->next=NULL; //可以不用
return p;

题目的意思就是删除s指向的结点.算法为:将s的下一个元素的的值赋给s,然后删除s的下一个结点,（删除结点就是next指针的操作）.时间复杂度是常数级.

单链表倒置(使用头插法就可以轻松实现),然后从头到尾遍历一次,就是正序输出.不需要用到栈.

将二叉树遍历一边即可
static int count = 0;//记录二叉树叶子节点的个数
struct Node{
int data;
Node *rigthNode;//右孩子
Node *leftNode;//左孩子
};
int fine_Node(Node * t)//Node 表示二叉树节点
{
if(t == Null)
{
return 0;
}
else if（(fine_Node(t->rigthNode)+fine_Node(t->leftNode)) != 0）
{
return 1;
}
else
{
count++;
return 1;
}
}

你没说什么语言.
大概思路就是数空格
读文章开始前 建立链表头
以后每遇到空格就插入一个新的单链表以存储单词
最后
空格数+1=主链表节点数=单词数