取元素演算法

⑴ 寫一個演算法,將一個順序棧中的元素依次取出,並列印元素

對，後進先出。列印的順序與原來輸入的相反。
演算法：
#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