求数据结构算法题详细解题步骤已知线性表中的结点以关键字非递减有序排列，并以带头结点的单链表作存储结构。请写一算法，删除表

/* */
#include
#define size 100 /* 输入人数的上限 */
void main()
{
int person[size];
int i, j; /* 循环修正变量 */
int arrayLen; /* 数组长度 */
int start, overNum; /* 开始位置各跨过位置 */
int deleNum; /* 出列人所在数组中的下标 */
int name, total; /* 输入时,人的信息以及人的总数 */
printf( "请输入圆桌上人的总数: " );
scanf( "%d", &arrayLen ); printf( "n" );
if( ( arrayLen > size ) || ( arrayLen < 0 ) )
{
printf( "超出范围,请重新输入: " );
scanf( "%d", &arrayLen ); printf( "n" );
};
printf( "请输入各个人的信息(整数): n" );
for( i = 0; i < arrayLen; i++ )
{
scanf( "%d", &name );
person[i] = name;
}
printf( "你输入的数据的顺序为: n" );
for( i = 0; i < arrayLen - 1; i++ )
printf( " %d ==>", person[i] );
printf( "%d n", person[arrayLen - 1] );
printf( "你打算从第几个人开始? 请输入开始号: " );
scanf( "%d", &start );
printf( "n" );
start = start - 1;
printf( "请输入相邻两出列人之间的间隔: " );
scanf( "%d", &overNum );
printf( "n" );

total = arrayLen;
printf( "程序运行后,出列人的顺序为:nn" );
for( i = 0; i < total; i++ ) /* 要打印total个人的情况,故做total次 */
{
if ( arrayLen == 1 )
printf( "%d", person[0] ); /* 如果是数组只剩一个元素,直接出列 */
else
{
deleNum = ( start + overNum - 1 ) % arrayLen; /* 此取模保证循环 */
printf( "%d ==> ", person[deleNum] );
for ( j = deleNum; j < arrayLen; j++ ) /* 将出列元素后面的各元素前移 */
person[j] = person[j+1];
start = deleNum;
arrayLen = arrayLen - 1; /* 移动完毕后,数组长度减1 */
}
}
printf( "nn" );
}

从一本数据结构书上看到的用向量实现此问题：
void Josephus (Vector &P, int n, int s, int m)
{
//将人员编号存入向量P；
int k = 1;
for(int i = 0; i=1; j--)
{
s1=(s1+m-1)%j;
if(s1== 0) s1 = j;
int w = P.Getnode(s1 - 1);
P.Remvoe(s1 - 1);
P.Insert(w,n-1);
}
}

简单，比较m和n的大小，选择小的那个链表，找到它的尾节点，然后把另一个链表的头连接到这个链表的尾，最后把hc赋值为当前链表的头，返回即可。
时间复杂度是min(m,n)+c，c是常数。

数据结构主要研究组织大量数据的方法,而算法分析则是对算法运行时间的评估.随着计算机的速度越来越快,对于能够处理大量输入数据的程序的需求变得日益急切.可是,由于在输入量很大的时候,程序的低效率现象变得非常明显,因此这又要求对效率问题给予更仔细的关注.通过在实际编程之前对算法的分析,学生可以决定一个特定的解法是否可行.例如,学生在本书中将读到一些特定的问题并看到精心的实现方法是如何把对大量数据的时间限制从16年减至不到1秒的.因此,若无运行时间的阐释,就不会有算法和数据结构的提出.
我所选择的教材是《数据结构与算法分析——C语言描述》（原书第2版）,英文版的名称是《Data Structures and Algorithm Analysis in C》,作者是：(美)Mark Allen Weiss.原书曾被评为20世纪顶尖的30部计算机著作之一.之所以选这本书,还因为它的简体中文版翻译得相当不错,几乎没有给我的阅读带来什么障碍.^_^
这本教科书所使用的是C语言,也许很多人会说C语言已经过时了,但是,我认为在数据结构的学习中,应该用尽量简单的语言,以免进入了语言的细枝末节中,反而冲淡了主题.实际上在国外的许多大学中（甚至中学）,数据结构和算法分析的课程是选用Scheme的,例如MIT麻省理工大学极其著名的SICP课程.呵呵,语言又能说明什么呢?
书中详细介绍了当前流行的论题和新的变化,讨论了算法设计技巧,并在研究算法的性能、效率以及对运行时间分析的基础上考查了一些高级数据结构,从历史的角度和近年的进展对数据结构的活跃领域进行了简要的概括.由于本书选材新颖,方法实用,题例丰富,取舍得当.本书的目的是培养学生良好的程序设计技巧和熟练的算法分析能力,使得他们能够开发出高效率的程序.从服务于实践又锻炼学生实际能力出发,书中提供了大部算法的C程序和伪码例程,但并不是全部.一些程序可从互联网上获得.
本书是《Data Structures and Algorithm Analysis in C》一书第2版的简体中译本.原书曾被评为20世纪顶尖的30部计算机著作之一,作者Mark Allen Weiss在数据结构和算法分析方面卓有建树,他的数据结构和算法分析的著作尤其畅销,并受到广泛好评．已被世界500余所大学用作教材.
在本书中,作者更加精炼并强化了他对算法和数据结构方面创新的处理方法.通过C程序的实现,着重阐述了抽象数据类型的概念,并对算法的效率、性能和运行时间进行了分析.
全书特点如下：
●专用一章来讨论算法设计技巧,包括贪婪算法、分治算法、动态规划、随机化算法以及回溯算法
●介绍了当前流行的论题和新的数据结构,如斐波那契堆、斜堆、二项队列、跳跃表和伸展树
●安排一章专门讨论摊还分析,考查书中介绍的一些高级数据结构
●新开辟一章讨论高级数据结构以及它们的实现,其中包括红黑树、自顶向下伸展树.treap树、k-d树、配对堆以及其他相关内容
●合并了堆排序平均情况分析的一些新结果
本书是国外数据结构与算法分析方面的标准教材,介绍了数据结构(大量数据的组织方法)以及算法分析(算法运行时间的估算).本书的编写目标是同时讲授好的程序设计和算法分析技巧,使读者可以开发出具有最高效率的程序. 本书可作为高级数据结构课程或研究生一年级算法分析课程的教材,使用本书需具有一些中级程序设计知识,还需要离散数学的一些背景知识.

将A与B分别排序，然后求交。
例如：将A与B按升序排列，设A表头为P，B表头为Q，若A[P]>B[Q]那么Q++，若A[P]

顶一下算了

把小于零的元素放在数组的右边.
把大于零的元素放在数组的左边.

#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;
}

这个是哈希冲突再散列的东西,26对10取余数是6,在6号空间,43在3号空间,63发生冲突,改为加一取余数,在4号空间.24的位置被63占了,同样冲突,于是加一取余数,到了5号空间.85以此类推,5号空间被占据了,加一取余数6号空间也被占了,于是变成加四取余数,在9号空间.于是
[0]__[1]__[2]__[3]_43_[4]_63_[5]_24_[6]_26_[7]__[8]__[9]_85_
其他空白数组元素都是零就不写了.

全是很基础的概念性东西,第一个线性重散列,再通过散列函数计算的位置已经有元素时,向后找到一个空位置放入即可,所以结果为：
地址 0 1 2 3 4 5 6 7 8 9
元素 16 48 9 82 1 5 7 39
第二个插入排序更没有什么了,这个你自己看就好了,每一次就是前几个元素的正确排序,比如
第一次：89
第二次：12,89
第三次：12,34,89
一次,到最后一次,为排好的有序数组

某链表中最常用的操作是在最后一个元素之后插入一个元素和删除最后一个元素,则采用( )存储方式最节省运算时间.(A)...已知带头结点的单链表L中的结点是按整数值递增排列的,试写一算法,将值为x 的结点插入到表L中,使得L仍然有序

#include
#include
#include
typedef int status;
typedef int ElemType;
#define TRUE 1
#define ERROR 0
#define FALSE 0
#define OK 1
#define OVERFLOW -2
#define list_init_size 100
#define listincrement 10
typedef struct{
x05ElemType *elem;
x05int length;
x05int listsize;
}sqlist;
status equal(ElemType a,ElemType b)
{if(a==b)
return TRUE;
else
return FALSE;
}
int listlength(sqlist l)
{ return l.length;}
status listinsert(sqlist *l,int i,ElemType e)
{
x05ElemType *newbase,*q,*p;
x05if(i(*l).length+1)
x05return ERROR;
x05if((*l).length>=(*l).listsize){
x05x05newbase=(ElemType*)realloc((*l).elem,((*l).listsize+listincrement)*sizeof(ElemType));
if(!newbase) exit(OVERFLOW);
x05 (*l).elem=newbase;
x05 (*l).listsize+=listincrement;
}
q=&((*l).elem[i-1]);
for(p=&((*l).elem[(*l).length-1]);p>=q;--p)
x05 *(p+1)=*p;
*q=e;
++(*l).length;
return OK;
}
status initlist(sqlist *l){
x05(*l).elem=(ElemType*)malloc(list_init_size*sizeof(ElemType));
x05if(!(*l).elem)
x05x05exit(OVERFLOW);
x05(*l).length=0;
x05(*l).listsize=list_init_size;
x05return OK;
}
status getelem(sqlist l,int i,ElemType *e)
{ if(il.length)
exit(ERROR);
*e=*(l.elem+i-1);
return OK;
}
int LocateElem(sqlist L,ElemType e,status(*compare)(ElemType,ElemType))
{
ElemType *p;
int i=1;
p=L.elem;
while(i

将队列中元素按序取出并放入栈中,然后再逐一出栈并插入回队列中,就完成了逆置.