取元素算法

⑴ 写一个算法,将一个顺序栈中的元素依次取出,并打印元素

对，后进先出。打印的顺序与原来输入的相反。
算法：
#define Stack_Size 20
typedef struct
{
int elem [Stack_Size];
int top ;/*存放栈顶元素的下标*/
} SeqStack;
void Pop (SeqStack *S,int x)
{
if(S->top==-1） /*栈为空*/
exit(0);
else
{
*x=S->elem[S->top];
printf("%d ",x); /*打印*/
S->top--; /*修改栈顶指针*/
}
}

⑵ 写一算法将一链队列中的元素依次取出，并打印这些元素值

int print(linkqueue q)//linkqueue为定义q的类型
{
int e=0;
while(q.rear !=q.front ){
dequeue(q,e);
cout<<e<<" "; //打印
}
return 1;
}

⑶ 设计算法求解从集合{1..n}中选取K（k<=n）个元素的所有组合。

C(k,n-1)=∏(n-k,n-1)/k!
C(k-1,n-1)=∏(n-k+1,n-1)/(k-1)!
C(k-1,n)+C(k-1,n-1)
=∏(n-k,n-1)/k!+∏(n-k+1,n-1)/(k-1)!
=∏(n-k,n-1)/k!+k·∏(n-k+1,n-1)/k!
=[(n-k)·∏(n-k+1,n-1)!+k·∏(n-k+1,n-1)]/(k-1)!
=[n·∏(n-k+1,n-1)]/k!
=∏(n-k+1,n)]/k!
=C(k,n)
即：C(k-1,n)+C(k-1,n-1)=C(k,n)
说简单点，就是杨辉三角形的元素算法。
此原理应用到你的问题上，重点是：结果集合的每个元素又是个集合。
若通用集合类Set(其实java中Set就是)；
new
Set{value...}为构造方法，-{value..}为集合差，+{value...}为集合和，Set(i)和集合第i个元素；
对于n个元素的集合Sn，如果有函数Set
combine(k,Sn)，产生n个元素中选k个元素集合的集合；那么，当a是n个元素中的任意一个时，combine(k,Sn)=combine(k,Sn-{a})+combine(k-1,Sn-{a})。
由此可以产生递归算法：
Set
Sn=new
Set{a0,a1,...an-1};
Set
result=Sn.combine(k,Sn);
...........................
...........................
function
Set
combine(int
count,Set
S){
if(count==S.size()){
return
new
Set{S};//这是集合S仅为结果集的一个元素
}
if(count+1==S.size()){
Set
result=new
Set{};
for(Element
a:S){
result+=new
Set{S-{a}};//集合依次排除一个元素产生的子集作为结果的一个元素
}
return
result;
}
Set
S2=combine(count-1,S-S(0));//对应YH公式的后一项，S(0)为集合S的第一个元素
for(Set
Si:S2){
Si+={S(0)};//Si是缺了一个元素的
}
Set
S1=combine(count,S-S(0));//这个是个数整好的，YH公式的前一项
return
S1+S2;//YH公式
}
这个问题比较有意思，不知道谁出的。没有中学组合知识或YH公式，真困难了。
要是谁有更好算法，不妨交流一下。
这题分给的够低了，纯属兴趣做一下玩。

⑷ c++ 从一维数组中抽取元素的算法

#include <stdlib.h>
#include <time.h>

bool isSelect( int num, int* arrnum, int arrcount )
{
for (int i = 0;i< arrcount; i++)
{
if(num == arrnum[i])
return true;
}
return false;
}

int main()
{
int n = 100; //(n的值可能是1到100 的任意值）
int* index = (int*)malloc(sizeof(int)*n);
for(int i=0;i<n;i++) index[i] = i+1;

if (n<25)
{
return 0;
}
srand(time(NULL));
int nCount = 0;
int selectNum[25] = {0};
while( nCount < 25 ){
int nIndex = rand() % n;
if(!isSelect(index[nIndex],selectNum,25)){
selectNum[nCount] = index[nIndex];
nCount = nCount + 1;
}
}

for (int i = 0;i<25;i++)
{
printf("%d ", selectNum[i]);
}

return 0;
}

不知你要怎么选取这25个数，我这里是随机选取

⑸ 写出链栈的取栈顶元素和置栈空的算法

void StackPop(Stack *s,int *e)
{
*e=*--s->top;
return;
}

void StackEmpty(Stack *s)
{
s->top=s->base

return ;
}

⑹ 求大神指点一二：“从一个集合中任意取出若干个元素”这个怎么用C语言实现

你的题目本身就是一个随机概率事件，不管你用C语言还是真实实验实际上都是在产生随机事件，如果不用C语言产生随机事件怎么可能模拟你这个过程？

我理解可能楼主说的是随机函数的效率问题，你是认为随机函数加判断的效率太低了，是吧？
的确c自带的随机函数效率不是最高的，随机性也不是最大的，但是是一个最简单的，并且效率完全可以接受的算法。
如果你想要更高的效率，目前最高效的是查表的办法，就是你先创建一张周期足够大的随机数表，然后查表来实现，比如你这个问题，可以先建立一张表{13,5,8,7,1,4,6,11,15,3,2,9,10,12,14,8,7,1,2,4,7,11,15,4,9,8,12,4,7,9,12,13}
我这个随手打的（随手打也算一种随机事件），实际操作中应该先用一个熵足够大的随机数函数建立一张足够大的表格，保证每连续5个元素间没有相同的元素，然后初始化一个下标i=0，每次需要取出元素的时候就用递增下标的办法。目前没有比这个方法效率更高的随机数了，但是这个方法也有他的问题。希望能帮到楼主

⑺ 求一C语言思路,实现先从N个取m1个,再剩下的再取m2个的运算.

不经意间看到，觉得蛮有趣，就小编了一下，仅供楼主参考~~

1、先来讲一下我的思路：我从n个元素中取出k个元素的算法是0、1算法，即使用0或1表示集合中的元素是否出现在选出的集合中，因此一个0/1列表即可表示选出哪些元素。例如集合为：[1 2 3 4 5]，选出的元素是[1 2 3]，那么列表就是[1 1 1 0 0]。

2、因为使用递归算法的话，不容易将选出的结果用数组存起来，所以这里没有用递归（当然递归是比较简便的，楼主也可以研究下怎么做~），这里用的是“10”交换法，即首先初始化为[1 1 1 0 0]这种类型（1全部在左边），然后遇到“10”交换为“01”；且将“10”组合前面的所有1再全部移到最左侧，重复直到没有“10”出现，就会成为[0 0 1 1 1]，这样可以保证k个1的位置不重复，且覆盖n一遍~

3、再来说楼主两层的问题，用01就方便在这里~~首先假设8个元素[1 2 3 4 5 6 7 8]，先选出3个，假如为[0 0 1 0 1 0 0 1]；第二次选的时候就可以在剩余的0元素之中再选，比如5中再选2个[0 1 0 1 0]，这样的话第一次选出的是[3 5 8]，第二次是[2 6]~~~

4、最后的集合之间的运算就不是重点了，你说要乘积最小那就乘好了，运算之后挑出来复合的就可以~~

主要是想法~~下面附上程序仅供参考，楼主可以根据想法自己再编编看~~满意请采纳啦！！

#include<stdio.h>
#include<string.h>
#include<math.h>
#defineM500
#defineN100
intl;
/****************从n个元素中取出k个元素的0、1组合********************/
voidcombine(intn,intk,intset[M][N])
{
	inti,j,count=0,vec[N],has_next=1;
	l=0;
for(i=0;i<n;i++)//0、1初始化，即让所有的1在最左边
{
if(i<k)
		{
			vec[i]=1;
			set[l][i]=1;
		}
else
		{
			vec[i]=0;
			set[l][i]=0;
		}
}
	l++;
while(has_next)//当所有1到最右边的时候结束
{
		count=0;
		for(j=0;j<n-k;j++)
			if(vec[j]==0)
				count++;
		if(count==(n-k))
			has_next=0;
for(i=0;i<n-1;i++)
{
if((vec[i]==1)&&(vec[i+1]==0))
{
vec[i]=0;
vec[i+1]=1;//交换1与0
				count=0;
for(j=0;j<i;j++)
if(vec[j]==1)
						count++;
if(count<i)//将上一步10前的1移到最左端
{
for(j=0;j<count;j++)
vec[j]=1;
for(j=count;j<i;j++)
vec[j]=0;
}
				for(j=0;j<n;j++)
set[l][j]=vec[j];
				l++;
has_next=1;
break;
}
}
}
}
/****************两种组合之间的运算（乘积最小）********************/
voidfunction(intC[10],intc1[10],intc2[10],intx,inty,intz)
{
	inta[M][N],b[M][N],l1,l2,i,j,k,flag1,flag2,count,Cc[10];
	longs1,s2,s=4000000;
	combine(x,y,a);
	l1=l;
	combine(x-y,z,b);
	l2=l;
	flag1=l1;flag2=l2;
	for(i=0;i<l1;i++)
	{
		s1=1;
		for(count=0,k=0;k<x;k++)
		{
			if(a[i][k])
				s1*=C[k];
			else
				Cc[count++]=C[k];
		}
		for(j=0;j<l2;j++)
		{
			s2=s1;
			for(k=0;k<count;k++)
				if(b[j][k])
					s2*=Cc[k];
			if(s2<s)
			{
				s=s2;
				flag1=i;flag2=j;
			}
		}
	}
	for(i=0,j=0,count=0;i<x;i++)
	{
		if(a[flag1][i])
			c1[j++]=C[i];
		else
			Cc[count++]=C[i];
	}
	for(j=0,k=0;k<count;k++)
				if(b[flag2][k])
					c2[j++]=Cc[k];
}
/****************主函数********************/
voidmain()
{
intX,A[10],A1[10],B1[10],m,n,i;
	printf("请输入集合元素个数（不大于10个）:");
	scanf("%d",&X);
	printf("请输入集合:");
	for(i=0;i<X;i++)
		scanf("%d",&A[i]);
printf("请输入集合中要分别取出的m、n的值:");
scanf("%d%d",&m,&n);
	function(A,A1,B1,X,m,n);
	printf("符合要求的组合为：
");
	for(i=0;i<m;i++)
		printf("%d",A1[i]);
	printf("
");
	for(i=0;i<n;i++)
		printf("%d",B1[i]);
	printf("
");
}

⑻ 编写循环双向链表的求数据元素个数操作算法和取数据元素操作算法

#include <stdio.h>
#include <malloc.h>
#define MAXLENGTH 10
typedef struct node_type{
int data;
struct node_type * next;
}node_type;
typedef struct list_type{
node_type *head;
node_type *tail;
int length;
}list_type;

void create_list(list_type *table)
{
int x;
int i;
node_type *temp;

table->head = NULL;
table->tail = NULL;
table->length = 0;
for(i = 5; i >= 1 ; i --){
printf("input the data of a%d = ",i);
scanf(" %d",&x);
printf("\n");

temp = (node_type *)malloc(sizeof(node_type));
temp->data = x;
temp->next = NULL;
temp->next = table->head;
table->head = temp;
}
table->length = 5;
}

void show_list(list_type *table)
{
int count;
node_type * temp;
count = 1;
temp = table->head;
while(count <= table->length && temp != NULL){
printf("%d, ",temp->data);
count ++;
temp = temp->next;
}
printf("\n");
}
void main(void)
{
int x;
int l;
list_type table;
create_list(&table);

show_list(&table);

return;
}
这个好像是我们学哪个时的 你看看

⑼ LUA 关于取出两个table中不同元素的算法。

【我理解下你的意思
你是要把 T_letter_tbl 中所有元素的 letter标签和 和 hope_letter_tbl 中的元素比较，如果 发现重复 的 则删除 T_letter_tbl 中的 重复标签吗？
【一般做法】用 lua 做这种很容易，但是要注意方法，不是比较，那样遍历比较 效率太低。先把 需要比较的 table 的元素作为 索引 建立一个 hash
直接取元素 进行 标签判断，

下面是一个演示：table.print 自定义的输出，可以删去，自己选择输出方式

functiontable.print(tbl,name)
name=nameor"table"
localprompt=''
locali=1
localprinted={}
localfunctiontostring2(var)
if(type(var)=="string")then
return'"'..var..'"'
end

returntostring(var)
end
localfunctionitor(t,i)
printed[tostring(t)]=true;
forkey,eleinpairs(t)do
ifnot(type(ele)=="table")then
print(string.format('%s[%s]=%s;',string.rep(prompt,i),tostring2(key),tostring2(ele)))
elseifprinted[tostring(ele)]then
print(string.format('%s[%s]=%s;',string.rep(prompt,i),tostring2(key),tostring2(ele)))
else
print(string.format('%s[%s]={',string.rep(prompt,i),tostring2(key)))
i=i+1
itor(ele,i)
i=i-1
print(string.format('%s};',string.rep(prompt,i)))
end
end
end

print(string.format("%s={",name))
itor(tbl,i)
print("};")
end
-----------------------------------------------------
tbl_letter_HOPE={
[1]="bbbbbb";
[2]="ffffff";
[3]="cccccc";
[4]="xxxxxx";
[5]="eeeeee";
};
tbl_letter_T={
[1]={["letter"]="Y"};
[2]={["letter"]="M"};
[3]={["letter"]="P"};
[4]={["letter"]="K"};
[5]={["letter"]="bbbbbb"};
[6]={["letter"]="R"};
[7]={["letter"]="Q"};
[8]={["letter"]="xxxxxx"};
[9]={["letter"]="L"};
[10]={["letter"]="D"};
[11]={["letter"]="B"};
[12]={["letter"]="ffffff"};
[13]={["letter"]="Z"};
[14]={["letter"]="T"};
[15]={["letter"]="["};
[16]={["letter"]="cccccc"};
[17]={["letter"]="E"};
[18]={["letter"]="C"};
[19]={["letter"]="W"};
[20]={["letter"]="I"};
[21]={["letter"]="F"};
[22]={["letter"]="eeeeee"};
[23]={["letter"]="O"};
[24]={["letter"]="X"};
[25]={["letter"]="U"};
[26]={["letter"]="S"};
};
---根据tbl_letter_HOPE中的元素去除tbl_letter_T中的元素
--
localfunctionmain()
localtbl_erase={}
forkey,eleinpairs(tbl_letter_HOPE)do
--不考虑元素权重则改为=true
tbl_erase[tostring(ele)]=(tbl_erase[tostring(ele)]or0)+1
end


forkey,eleinpairs(tbl_letter_T)do
iftbl_erase[ele.letter]then
--移除整行[12]={["letter"]="ffffff"};
tbl_letter_T[key]=nil

--还是一个标签letter
--tbl_letter_T[key].letter=nil
end
end
table.print(tbl_letter_T)
end
startTime=os.time()
main()
print(string.format(">>Thisfunctioncost:%sms",tostring(os.time()-startTime)))

【附】

如果只想 获得去除给定元素后的 table

可以先 复制原 tbl_letter_T

注意：

不要用 浅复制 你之前 那个代码 可能 就是 希望做一个 tbl_letter_T 的副本

但是 使用 浅复制相当于仅复制了指向table的句柄。

php">tbl_Interim=tbl_letter_T--2个变量指向同一个table表

要用

python">forkey,eleinpairs(tbl_letter_T)do
tbl_Interim[key]=ele
end