一张表的简单算法

⑴ c++链表简单算法设计题，帮同学忙，求代码，谢谢

LinkList delnode(LinkList head,DataType x)
{
if (head == NULL || head->next == NULL) return head;
LinkNode *p = head->next;
LinkNode *pPrev = head;
while (p != NULL)
{
if (p->data == x)
{
pPrev->next = p->next;
free(p);
p = pPrev->next;
}
else
{
pPrev = pPrev->next;
p = p->next;
}
}
return head;
}

⑵ 帮忙写出一个简单的算法呗。设顺序表S中元素递增有序，编写算法删除S中所有大于K1小于K2的元素。谢谢啦

int min,max;
int flag f=1,g=1;
for(int i=0;i<n;i++)
{
if (f==1&&a[i]>k1){min=i;f=0;}

else if(g==1&&a[i]<k2){max=k2;g=0}

}
if(j==0&&g==0)
{
for(int i=min,int j=max;j<n;i++,j++)

{

a[i]=a[j];

if(j==n-1)a[i+1]=null;

}

}

⑶ 求一个简单的线性表（链式的，用C语言）

#include<stdio.h>
#include <stdlib.h>
#include <math.h>

/************************************************************************/
/* 常量定义 */
/************************************************************************/
#define ElemType int
#define Status int
#define TRUE 1
#define OK 1
#define FALSE 0
#define ERROR -1

/************************************************************************/
/* 线性表的单链表存储结构*/
/************************************************************************/
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode, *LinkList;

//////////////////////////////////////////////////////////////////////////
//
// 带有头结点的单链表的基本操作(13个)
//
//////////////////////////////////////////////////////////////////////////

/************************************************************************/
/* 操作结果：构造一个空的线性表L */
/************************************************************************/
void InitList(LinkList *L)
{
*L = (LinkList)malloc(sizeof(struct LNode)); /* 产生头结点，并使L指向此头结点 */
if( !*L ) /* 存储分配失败 */
exit(OVERFLOW);
(*L)->next = NULL; /* 指针域为空 */
}

/************************************************************************/
/* 初始条件：线性表L已存在。*/
/* 操作结果：销毁线性表L */
/************************************************************************/
void DestroyList(LinkList *L)
{
LinkList q;
while(*L)
{
q = (*L)->next;
free(*L);
*L=q;
}
}
/************************************************************************/
/* 初始条件：线性表L已存在。*/
/* 操作结果：将L重置为空表 */
/************************************************************************/
void ClearList(LinkList L) /* 不改变L */
{
LinkList p, q;
p = L->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
q = p->next;
free(p);
p = q;
}
L->next = NULL; /* 头结点指针域为空 */
}

/************************************************************************/
/* 初始条件：线性表L已存在。*/
/* 操作结果：若L为空表，则返回TRUE，否则返回FALSE */
/************************************************************************/
Status ListEmpty(LinkList L)
{
/* 非空 */
return (L->next) ? FALSE : TRUE;
}

/************************************************************************/
/* 初始条件：线性表L已存在。操作结果：返回L中数据元素个数 */
/************************************************************************/
int ListLength(LinkList L)
{
int i = 0;
LinkList p = L->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
i++;
p = p->next;
}
return i;
}

/************************************************************************/
/* L为带头结点的单链表的头指针。*/
/* 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR */
/************************************************************************/
Status GetElem(LinkList L, int i, ElemType *e) /* 算法2.8 */
{
int j = 1; /* j为计数器 */
LinkList p = L->next; /* p指向第一个结点 */
while(p && j < i) /* 顺指针向后查找，直到p指向第i个元素或p为空 */
{
p = p->next;
j++;
}
if( !p || j > i) return ERROR; /* 第i个元素不存在 */

*e = p->data; /* 取第i个元素 */
return OK;
}

/************************************************************************/
/* 初始条件: 线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)*/
/* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
/************************************************************************/
int LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
int i = 0;
LinkList p = L->next;
while(p)
{
i++;
if(compare(p->data,e)) /* 找到这样的数据元素 */
return i;
p=p->next;
}
return 0;
}

/************************************************************************/
/* 初始条件: 线性表L已存在 */
/* 操作结果: 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱 */
/* 返回OK；否则操作失败，pre_e无定义，返回INFEASIBLE */
/************************************************************************/
Status PriorElem(LinkList L, ElemType cur_e, ElemType *pre_e)
{
LinkList q, p = L->next; /* p指向第一个结点 */
while(p->next) /* p所指结点有后继 */
{
q = p->next; /* q为p的后继 */
if(q->data == cur_e)
{
*pre_e = p->data;
return OK;
}
p = q; /* p向后移 */
}
return ERROR;
}

/*************************************************************************/
/* 初始条件：线性表L已存在 */
/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继*/
/* 返回OK; 否则操作失败，next_e无定义，返回INFEASIBLE */
/*************************************************************************/
Status NextElem(LinkList L, ElemType cur_e, ElemType *next_e)
{
LinkList p = L->next; /* p指向第一个结点 */
while(p->next) /* p所指结点有后继 */
{
if(p->data == cur_e)
{
*next_e = p->next->data;
return OK;
}
p = p->next;
}
return ERROR;
}

/************************************************************************/
/* 在带头结点的单链线性表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) return ERROR;/* i小于1或者大于表长 */

s = (LinkList)malloc(sizeof(struct LNode)); /* 生成新结点 */
s->data = e; /* 插入L中 */
s->next = p->next;
p->next = s;
return OK;
}

/************************************************************************/
/* 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值 */
/************************************************************************/
Status ListDelete(LinkList L, int i, ElemType *e)
{
int j = 0;
LinkList p = L, q;
while(p->next && j < i-1) /* 寻找第i个结点，并令p指向其前岖 */
{
p = p->next;
j++;
}
if( !p->next || j > i-1) /* 删除位置不合理 */
return ERROR;
q = p->next; /* 删除并释放结点 */
p->next = q->next;
*e = q->data;
free(q);
return OK;
}

/************************************************************************/
/* 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi() */
/************************************************************************/
void ListTraverse(LinkList L, void(*vi)(ElemType))
{
LinkList p = L->next;
while(p)
{
vi(p->data);
p = p->next;
}
printf("\n");
}

/************************************************************************/
/* 初始条件：线性表L已存在。打印链表的data域 */
/************************************************************************/
void ListPrint(LinkList L)
{
LinkList p = L->next;
while(p)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}

void printInt(int data)
{
printf("%d ", data);
}

/************************************************************************/
/* 插入排序 */
/************************************************************************/
void ListSort(LinkList L)
{
LinkList first, p, q; //为原链表剩下用于直接插入排序的节点头指针
LinkList t; //临时指针变量：插入节点

//原链表剩下用于直接插入排序的节点链表
first = L->next;

//只含有一个节点的链表的有序链表
L->next = NULL;

//遍历剩下无序的链表
while (first != NULL)
{
//无序节点在有序链表中找插入的位置
for (t = first, q = L; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);

//退出for循环，就是找到了插入的位置
first = first->next;

p->next = t;

//完成插入动作
t->next = q;
}
}

//排序，指针交换法
void ListSort1(LinkList L)
{
LinkList head = L->next;//head指向除头结点以外的链表
LinkList pre_p; //p的前驱结点
LinkList pre_q; //q的前驱结点
LinkList min; //最小的结点
LinkList p, q, temp;

for(p = head; p->next; pre_p = min, p = min->next)
{
//找出最小的结点
for(min = p, q = p; q->next; q = q->next)
{
if(q->next->data < min->data)
{
pre_q = q;
min = q->next;
}
}

//如果最小是自己 就不需要交换
if(min == p) continue;

//如果p是指向head的结点，则链表直接指向min
if(p == head)
L->next = min;
else
pre_p->next = min;

temp = min->next;
if(p->next == min)
{
min->next = p;
p->next = temp;
}
else
{
min->next = p->next;
pre_q->next = p;
p->next = temp;
}
}
}

//排序，数据选择法排序
void ListSort2(LinkList L)
{
LinkList head = L->next;//head指向除头结点以外的链表
LinkList min; //最小的结点
LinkList p, q; //遍历链表指针
int temp;
for (p = head; p->next; p = p->next)
{
//在p指针后的链表选取最小的结点
for (min = p, q = p->next; q; q = q->next)
{
if (q->data < min->data)
min = q;
}

//两者结点值不相等，数据交换
if (min->data != p->data)
{
temp = min->data;
min->data = p->data;
p->data = temp;
}
}
}

void ListSort3(LinkList L)
{
LinkList first; //指向链表L第一个结点，除头结点
LinkList pre; //指向first的前驱结点
LinkList last; //指向first指向排好序的最后一个结点
LinkList rest; //指向未排好序的第一个结点，即链表第二个结点
LinkList curr; //指向当前结点

first = L->next; //指向第一个结点
if(first == NULL) return;

pre = L ; //pre指向first的前驱结点
last = first; //last指向排好序的最后一个结点
rest = first->next; //指向剩余的结点
first->next = NULL; //first断链

while (rest) //当余下的结点不为空
{
//保存当前结点
curr = rest;

//取下一个结点
rest = rest->next;

//当结点小于第一个结点，则链接到first前面
if( curr->data < first->data )
{
pre->next = curr;
curr->next = first;
pre = curr;
}
//当前结点大于第一个结点，则链接到last后
else if(curr->data > first->data)
{
curr->next = last->next;
last->next = curr;
last = curr;
}
//当前结点与第一个结点相等，则链接到first后面
else
{
curr->next = first->next;
first->next = curr;
}
}
}

void main()
{
LinkList L;
InitList(&L);
ListInsert(L, 1, 6);
ListInsert(L, 2, 3);
ListInsert(L, 3, 67);
ListInsert(L, 4, 2);
ListInsert(L, 5, 15);
ListInsert(L, 6, 13);
ListInsert(L, 7, 10);
ListInsert(L, 8, 6);
ListInsert(L, 9, 4);

ListSort3(L);
ListTraverse(L, printInt);
}

⑷ EXCEL表格制作，求助解决思路及算法

=IF(OR(D5<1,D5>2),"",(INDEX(B2:J2,MATCH(LOOKUP(D5,B1:J1,B2:J2),B2:J2,)+1)-LOOKUP(D5,B1:J1,B2:J2))*(D5-LOOKUP(D5,B1:J1))/(INDEX(B1:J1,MATCH(LOOKUP(D5,B1:J1,B2:J2),B2:J2,)+1)-LOOKUP(D5,B1:J1))+LOOKUP(D5,B1:J1,B2:J2))

⑸ 跪求分别写一个线性表的插入的完整算法

//Try:
#include<iostream>
#include<stdlib.h>
usingnamespacestd;

#defineOK1
#defineERROR0
#defineTRUE1
#defineFALSE0
#defineINFEASIBLE-1
#defineOVERFLOW-2

typedefintStatus;//Status是函数的类型,其值是函数结果状态码
typedefintElemType;//ElemType为数据元素,暂定为int型

#defineLIST_INIT_SIZE100//线性表存储空间的初始分配量
#defineLIST_INCREMENT10//线性表存储空间的分配增量

typedefstruct//线性表顺序存储结构
{
	ElemType*elem;//存储空间基址
	intlength;//线性表当前长度
	intlistsize;//当前分配的存储容量(以sizeof(ElemType)为单位)
}SqList;

StatusInitList_SL(SqList&L)//初始化顺序线性表
{
//构造一个空的线性表L
	L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
	if(!L.elem)exit(OVERFLOW);//存储分配失败
	L.length=0;//空表长度为0
	L.listsize=LIST_INIT_SIZE;//初始存储容量
	returnOK;
}
Statusvisit(ElemTypee)//访问元素
{
cout<<e<<"";
returnOK;
}

StatusListEmpty_SL(SqListL)//判断线性表是否为空
{
if(L.length==0)returnTRUE;
	elsereturnFALSE;
}

StatusGetElem_SL(SqListL,inti,ElemType&e)//用e返回L中第i个数据元素的值(注意:下标由0开始的)
{
if(L.length==0/*||i<1*/||i>L.length)returnERROR;
e=*(L.elem+i);
returnOK;
}


StatusClearList_SL(SqList&L)//将线性表置为空表
{
	L.length=0;
	returnOK;
}

intLocateElem_SL(SqList&L,ElemTypee)//返回L中第1个与e满足关系的数据元素的位序
{
inti;
	if(L.length==0)return0;
	for(i=0;i<L.length;i++)
	{
		if(e==*(L.elem+i))//找到
			break;
	}
	if(i>=L.length)return0;//没有找到
	return(i+1);
}

StatusListDelete_SL(SqList&L,inti,ElemType&e)
{
//在顺序线性表L中删除第i个元素,并用e返回其值
//i的合法值为1<=i<=ListLength_SL(L)
ElemType*p,*q;
if((i<1)||(i>L.length))returnERROR;//i的值不合法
p=&(L.elem[i-1]);//p为被删除元素的位置
e=*p;//被删除元素的值赋给e
q=L.elem+L.length-1;//表尾元素的位置
for(++p/*++p是指被删除元素的下一个元素开始左移*/;p<=q;++p)//被删除元素之后的元素左移
	*(p-1)=*p;
--L.length;//表长减1
returnOK;
}

StatusListTraverse(SqListL)//遍历线性表元素
{
	inti;
	for(i=0;i<L.length;i++)
		visit(*(L.elem+i));
	cout<<endl;
	returnOK;
}
StatusListInsert_SL(SqList&L,inti,ElemTypee)
{
//在L中第i个位置之前插入新的元素e,
//i的合法值为1<=i<=ListLength_SL(L)+1
	ElemType*newbase,*q,*p;
	if(i<1||i>L.length+1)returnERROR;//i值不合法
	if(L.length>=L.listsize)
	{//当前存储空间已满,增加分配
		newbase=(ElemType*)realloc(L.elem,(L.listsize+LIST_INCREMENT)*sizeof(ElemType));
if(!newbase)exit(OVERFLOW);//存储分配失败
		L.elem=newbase;//新基址
		L.listsize+=LIST_INCREMENT;//增加存储容量
	}
q=&(L.elem[i-1]);//q为插入位置
for(p=&(L.elem[L.length-1]);p>=q;--p)
*(p+1)=*p;
*q=e;//插入e
++L.length;//表长增1
returnOK;
}

intListLength_SL(SqListL)//线性表长度
{
	return(L.length);
}


intmain(void)
{
/***************************
	
	Callthealgorithminhere.


	****************************/

	return1;
}

这个是最简单的线性表,它没有使用到类.都是过程化。

⑹ 如何制作一张表格

Microsoft Word 提供了几种创建表格 （表格:表格由一行或多行单元格组成，用于显示数字和其他项以便快速引用和分析。表格中的项被组织为行和列。）的方法。最适用的方法与您工作的方式以及所需的表格的复杂与简单程度有关。

单击要创建表格的位置。
在“常用”工具栏 （工具栏:包含可用于执行命令的按钮和选项的栏。要显示工具栏，请按 Alt 然后按 Shift+F10。）上，单击“插入表格” 。
拖动鼠标，选定所需的行、列数。
可执行下列任意操作：

使用“插入表格”
使用该步骤可以在将表格插入到文档之前选择表格的大小和格式。

单击要创建表格的位置。
在“表格”菜单上，指向“插入”，再单击“表格”。
在“表格尺寸”下，选择所需的行数和列数。
在“‘自动调整’操作”下，选择调整表格大小的选项。
若要使用内置的表格格式，请单击“自动套用格式”。
选择所需选项。

绘制更复杂的表格
可以绘制复杂的表格，例如，包含不同高度的单元格 （单元格:由工作表或表格中交叉的行与列形成的框，可在该框中输入信息。）或每行包含的列数不同。

单击要创建表格的位置。
在“表格”菜单上，单击“绘制表格”。
“表格和边框”工具栏显示出来，指针变为笔形。

要确定表格的外围边框，可以先绘制一个矩形。然后在矩形内绘制行、列框线。

若要清除一条或一组线，请单击“表格和边框”工具栏上的“擦除” ，在单击需要擦除的线。
表格创建完毕后，单击其中的单元格，然后便可键入文字或插入图形。
注释 绘制表格时，按住 Ctrl 可以自动应用文字环绕格式。

在表格中创建表格
创建嵌套表格 （嵌套表格:插入到表格单元格中的表格。如果用一个表格布局页面，并希望用另一个表格组织信息，则可以插入一个嵌套表格。）以设计网页。可以将网页想象为一个包含其他表格的大表格，将文本和图形置于不同的表格单元格之内，以帮助您排列页面中的不同部分。

在“表格”菜单上，单击“绘制表格”。
“表格和边框”工具栏显示出来，指针变为笔形。

将笔形指针移动到要创建嵌套表格（即表格中的表格）的单元格中。
绘制新表格。先绘制一个矩形以确定表格的边框，然后在矩形中绘制行、列的边框线。
嵌套表格创建完成后，请单击某个单元格，就可以开始键入文字或插入图形了。
注释 如果有一个原有表格，可将其复制并粘贴到另一个表格内部。

⑺ excel 2003中，一张工资表，如何求同一个姓氏的工资和用什么函数最简单

建立《工资表》，如下（模拟的Excel表）：
行 A 列 B列 C列 D列 E列 F列 G列 ......
1 序号 姓名 工资 姓氏 工资总和
2 1 张三 100 张氏 【此处输入公式】
3 2 王五 200 王氏 【此处输入公式】
4 3 张二 100 刘氏 【此处输入公式】
5 4 王六 240
6 5 王三 320
7 6 刘二 180
8 7 张七 260
9 8 刘三 150
.... ..... ........ .......

求同一个姓氏的工资和：
张氏工资总和：在F列的F2单元格输入以下公式：
=SUMIF($B$100:$B$100,CONCATENATE(LEFT($E2,1),"*"),$C$100:$C$100)

用鼠标下托复制功能，将F2单元格中的函数公式复制到F列的其他单元格；就可分别得到“王氏、刘氏、.........”的工资总和。鼠标下托复制“王氏、刘氏......”所对应的工资总所在的单元格中的函数公式为：

王氏工资总和：在F列的F3单元格，显示的公式为：
=SUMIF($B$100:$B$100,CONCATENATE(LEFT($E3,1),"*"),$C$100:$C$100)

刘氏工资总和：在F列的F2单元格，显示的公式为：
=SUMIF($B$100:$B$100,CONCATENATE(LEFT($E4,1),"*"),$C$100:$C$100)

【补充说明】：
SUMIF函数的语法：
SUMIF(range, criteria, [sum_range])
1）range为：作为计算某单元格区域的值的条件单元格区域；通俗称“条件单元格区域”；
2）criteria为：用于确定对哪些单元格求和的条件；
3）[sum_range]为：要求和的实际单元格

那么，在上述给的函数公式（即：如下）：
=SUMIF($B$100:$B$100,CONCATENATE(LEFT($E2,1),"*"),$C$100:$C$100)
其SUMIF函数语法解读如下：
1）range为：条件单元格区域，$B$100:$B$100
2）criteria为：用于确定对哪些单元格求和的条件，CONCATENATE(LEFT($E2,1),"*")
也就是，单元格E2中含有第一个字符+通配符(*)，即：王*，代表王姓的人
3）[sum_range]为：要求和的实际单元格，$C$100:$C$100

如果《工资表》有1000行，那么，上述给的函数公式：
=SUMIF($B$100:$B$100,CONCATENATE(LEFT($E2,1),"*"),$C$100:$C$100)
中的“条件单元格区域”、“要求和的实际单元格”必须改变，变更后的函数公式为：
=SUMIF($B$1000:$B$1000,CONCATENATE(LEFT($E2,1),"*"),$C$1000:$C$1000)
如果《工资表》有1100行、1200行........行，依此类推修改公式。

⑻ 钟表的夹角算法

就180°啊，他们刚好相差60+30分钟，如果变换一下比如表1点59分到3点11分就按如下方法来：
方法1.最简单的办法就是：拿个有指针的标，把他们调到相应位置，数间隔多少个，然后再乘以每隔的度数即可完工。
方法2.直接算了，360°/
60（隔数）=6°1点45分到3点15分的夹角相当于2点45分到3点15分，也不是什么夹角，就是一直线180°