c數值演算法代碼

1. 用類C編寫一個將三個數值排序的演算法

用類C編寫？是c語言，還是編寫一個類？

什麼叫類C演算法？

2. 怎麼學習數值線性代數怎麼用C語言編演算法代碼

著作權歸作者所有。
商業轉載請聯系作者獲得授權，非商業轉載請註明出處。
作者：白榮東
鏈接：http://www.hu.com/question/29774635/answer/45575936
來源：知乎

數值線性代數？你問的是那種專門用到計算機上面的矩陣嗎？
既然你們老師不講，那應該就是不會考吧，既然不會考，那麼就沒必要死板的做題目學習吧，既然如此，那麼就學點真本事吧，學著把這東西用上，如果學的比較ok的話，以後找工作可以用上哦。
關鍵這東西會用才是王道。

如果你對自己的英文有點自信的話，可以點擊以下鏈接：然後，點擊預覽課程，裡面會有機器學習的東西，會有一堆課程，挨個看一下，然後基本就可以
1.對機器學習有了一點了解了。。
2.順帶著把矩陣在機器學習中的應用給了解了。
3.順帶，把如何用代碼寫矩陣，寫機器學習演算法的過程給了解了。
Coursera - Free Online Courses From Top Universities
（這堆視頻比較高大上，那個講師非常厲害，而且不裝b，很親民，慢慢的給你講。每個視頻的右下角有個cc，可以點開，然後有各種語言的字幕）

3. 水仙花數的c語言編程。

所謂的「水仙花數」是指一個三位數其各位數字的立方和等於該數本身，例如153是「水仙花數」，因為：153 = 1^3 + 5^3+ 3^3。

下面是完整的C語言編程代碼：

運行結果：
result is：153 370 371 407

(3)c數值演算法代碼擴展閱讀

常見水仙花數

水仙花數又稱阿姆斯特朗數。

1、三位的水仙花數共有4個：153，370，371，407；

2、四位的四葉玫瑰數共有3個：1634，8208，9474；

3、五位的五角星數共有3個：54748，92727，93084；

4、六位的六合數只有1個：548834；

5、七位的北斗七星數共有4個：1741725，4210818，9800817，9926315；

6、八位的八仙數共有3個：24678050，24678051，88593477

4. C語言演算法 求a、b、c三個數的中間數值

a、b、c三個數的中間數值的源代碼如下：

#include<stdio.h>

int main(

{

int a,b,c,t,max,min;

scanf("%d%d%d",&a,&b,&c);

t=a+b+c;

max=a>b?a:b

max=max>c?max:c;

min=a<b?a:b;

min=min<c?min:c

printf("middle=%d",t-max-min);

return 0;

}

(4)c數值演算法代碼擴展閱讀

1既不是質數也不是合數的源代碼如下：

#include

int main()

{

int n, i, flag=0;

printf("Enter a positive integer: ");

scanf("%d",&n);

for(i=2;i<=n/2;++i)

{

if(n%i==0)

{

flag=1;

break;

}

}

if (flag==0)

printf("%d is a prime number.",n)

else

printf("%d is not a prime number.",n);

return 0;

}

5. 請教C語言各種數值排序的源碼。冒泡、插入等等

================================================
功能：選擇排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述：
在要排序的一組數中，選出最小的一個數與第一個位置的數交換；
然後在剩下的數當中再找最小的與第二個位置的數交換，如此循環
到倒數第二個數和最後一個數比較為止。
選擇排序是不穩定的。演算法復雜度O(n2)--[n的平方]
=====================================================
*/
void select_sort(int *x, int n)
{
int i, j, min, t;
for (i=0; i <n-1; i++) /*要選擇的次數：0~n-2共n-1次*/
{
min = i; /*假設當前下標為i的數最小，比較後再調整*/
for (j=i+1; j <n; j++)/*循環找出最小的數的下標是哪個*/
{
if (*(x+j) < *(x+min))
{
min = j; /*如果後面的數比前面的小，則記下它的下標*/
}
}
if (min != i) /*如果min在循環中改變了，就需要交換數據*/
{
t = *(x+i);
*(x+i) = *(x+min);
*(x+min) = t;
}
}
}
/*
================================================
功能：直接插入排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述：
在要排序的一組數中，假設前面(n-1) [n>=2] 個數已經是排
好順序的，現在要把第n個數插到前面的有序數中，使得這n個數
也是排好順序的。如此反復循環，直到全部排好順序。
直接插入排序是穩定的。演算法時間復雜度O(n2)--[n的平方]
=====================================================
*/
void insert_sort(int *x, int n)
{
int i, j, t;
for (i=1; i <n; i++) /*要選擇的次數：1~n-1共n-1次*/
{
/*
暫存下標為i的數。注意：下標從1開始，原因就是開始時
第一個數即下標為0的數，前面沒有任何數，單單一個，認為
它是排好順序的。
*/
t=*(x+i);
for (j=i-1; j>=0 && t <*(x+j); j--) /*注意：j=i-1，j--，這里就是下標為i的數，在它前面有序列中找插入位置。*/
{
*(x+j+1) = *(x+j); /*如果滿足條件就往後挪。最壞的情況就是t比下標為0的數都小，它要放在最前面，j==-1，退出循環*/
}
*(x+j+1) = t; /*找到下標為i的數的放置位置*/
}
}
/*
================================================
功能：冒泡排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述：
在要排序的一組數中，對當前還未排好序的范圍內的全部數，自上
而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較
小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要
求相反時，就將它們互換。
下面是一種改進的冒泡演算法，它記錄了每一遍掃描後最後下沉數的
位置k，這樣可以減少外層循環掃描的次數。
冒泡排序是穩定的。演算法時間復雜度O(n2)--[n的平方]
=====================================================
*/
void bubble_sort(int *x, int n)
{
int j, k, h, t;
for (h=n-1; h>0; h=k) /*循環到沒有比較范圍*/
{
for (j=0, k=0; j <h; j++) /*每次預置k=0，循環掃描後更新k*/
{
if (*(x+j) > *(x+j+1)) /*大的放在後面，小的放到前面*/
{
t = *(x+j);
*(x+j) = *(x+j+1);
*(x+j+1) = t; /*完成交換*/
k = j; /*保存最後下沉的位置。這樣k後面的都是排序排好了的。*/
}
}
}
}
================================================
功能：希爾排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述：
在直接插入排序演算法中，每次插入一個數，使有序序列只增加1個節點，
並且對插入下一個數沒有提供任何幫助。如果比較相隔較遠距離（稱為
增量）的數，使得數移動時能跨過多個元素，則進行一次比較就可能消除
多個元素交換。D.L.shell於1959年在以他名字命名的排序演算法中實現
了這一思想。演算法先將要排序的一組數按某個增量d分成若干組，每組中
記錄的下標相差d.對每組中全部元素進行排序，然後再用一個較小的增量
對它進行，在每組中再進行排序。當增量減到1時，整個要排序的數被分成
一組，排序完成。
下面的函數是一個希爾排序演算法的一個實現，初次取序列的一半為增量，
以後每次減半，直到增量為1。
希爾排序是不穩定的。
=====================================================
*/
void shell_sort(int *x, int n)
{
int h, j, k, t;
for (h=n/2; h>0; h=h/2) /*控制增量*/
{
for (j=h; j <n; j++) /*這個實際上就是上面的直接插入排序*/
{
t = *(x+j);
for (k=j-h; (k>=0 && t <*(x+k)); k-=h)
{
*(x+k+h) = *(x+k);
}
*(x+k+h) = t;
}
}
}
/*
================================================
功能：快速排序
輸入：數組名稱（也就是數組首地址）、數組中起止元素的下標
================================================
*/
/*
====================================================
演算法思想簡單描述：
快速排序是對冒泡排序的一種本質改進。它的基本思想是通過一趟
掃描後，使得排序序列的長度能大幅度地減少。在冒泡排序中，一次
掃描只能確保最大數值的數移到正確位置，而待排序序列的長度可能只
減少1。快速排序通過一趟掃描，就能確保某個數（以它為基準點吧）
的左邊各數都比它小，右邊各數都比它大。然後又用同樣的方法處理
它左右兩邊的數，直到基準點的左右只有一個元素為止。它是由
C.A.R.Hoare於1962年提出的。
顯然快速排序可以用遞歸實現，當然也可以用棧化解遞歸實現。下面的
函數是用遞歸實現的，有興趣的朋友可以改成非遞歸的。
快速排序是不穩定的。最理想情況演算法時間復雜度O(nlog2n)，最壞O(n2)
=====================================================
*/
void quick_sort(int *x, int low, int high)
{
int i, j, t;
if (low < high) /*要排序的元素起止下標，保證小的放在左邊，大的放在右邊。這里以下標為low的元素為基準點*/
{
i = low;
j = high;
t = *(x+low); /*暫存基準點的數*/
while (i <j) /*循環掃描*/
{
while (i <j && *(x+j)>t) /*在右邊的只要比基準點大仍放在右邊*/
{
j--; /*前移一個位置*/
}
if (i <j)
{
*(x+i) = *(x+j); /*上面的循環退出：即出現比基準點小的數，替換基準點的數*/
i++; /*後移一個位置，並以此為基準點*/
}
while (i <j && *(x+i) <=t) /*在左邊的只要小於等於基準點仍放在左邊*/
{
i++; /*後移一個位置*/
}
if (i <j)
{
*(x+j) = *(x+i); /*上面的循環退出：即出現比基準點大的數，放到右邊*/
j--; /*前移一個位置*/
}
}
*(x+i) = t; /*一遍掃描完後，放到適當位置*/
quick_sort(x,low,i-1); /*對基準點左邊的數再執行快速排序*/
quick_sort(x,i+1,high); /*對基準點右邊的數再執行快速排序*/
}
}
/*
================================================
功能：堆排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
演算法思想簡單描述：
堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。
堆的定義如下：具有n個元素的序列（h1,h2,...,hn),當且僅當
滿足（hi>=h2i,hi>=2i+1）或（hi <=h2i,hi <=2i+1）(i=1,2,...,n/2)
時稱之為堆。在這里只討論滿足前者條件的堆。
由堆的定義可以看出，堆頂元素（即第一個元素）必為最大項。完全二叉樹可以
很直觀地表示堆的結構。堆頂為根，其它為左子樹、右子樹。
初始時把要排序的數的序列看作是一棵順序存儲的二叉樹，調整它們的存儲順序，
使之成為一個堆，這時堆的根節點的數最大。然後將根節點與堆的最後一個節點
交換。然後對前面(n-1)個數重新調整使之成為堆。依此類推，直到只有兩個節點
的堆，並對它們作交換，最後得到有n個節點的有序序列。
從演算法描述來看，堆排序需要兩個過程，一是建立堆，二是堆頂與堆的最後一個元素
交換位置。所以堆排序有兩個函數組成。一是建堆的滲透函數，二是反復調用滲透函數
實現排序的函數。
堆排序是不穩定的。演算法時間復雜度O(nlog2n)。
*/
/*
功能：滲透建堆
輸入：數組名稱（也就是數組首地址）、參與建堆元素的個數、從第幾個元素開始
*/
void sift(int *x, int n, int s)
{
int t, k, j;
t = *(x+s); /*暫存開始元素*/
k = s; /*開始元素下標*/
j = 2*k + 1; /*右子樹元素下標*/
while (j <n)
{
if (j <n-1 && *(x+j) < *(x+j+1))/*判斷是否滿足堆的條件：滿足就繼續下一輪比較，否則調整。*/
{
j++;
}
if (t <*(x+j)) /*調整*/
{
*(x+k) = *(x+j);
k = j; /*調整後，開始元素也隨之調整*/
j = 2*k + 1;
}
else /*沒有需要調整了，已經是個堆了，退出循環。*/
{
break;
}
}
*(x+k) = t; /*開始元素放到它正確位置*/
}
/*
功能：堆排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
*/
void heap_sort(int *x, int n)
{
int i, k, t;
int *p;
for (i=n/2-1; i>=0; i--)
{
sift(x,n,i); /*初始建堆*/
}
for (k=n-1; k>=1; k--)
{
t = *(x+0); /*堆頂放到最後*/
*(x+0) = *(x+k);
*(x+k) = t;
sift(x,k,0); /*剩下的數再建堆*/
}
}
void main()
{
#define MAX 4
int *p, i, a[MAX];
/*錄入測試數據*/
p = a;
printf("Input %d number for sorting :\n",MAX);
for (i=0; i <MAX; i++)
{
scanf("%d",p++);
}
printf("\n");

6. 求C語言 用梯形法求定積分(數值求解演算法)

#include<stdio.h>
float f(float x)
{
return x*x+2*x+1;
}
void main()
{
float a,b,len,F=0;//
int n,i;
printf("Please input a,b: ");
scanf("%f%f",&a,&b);
printf("Please input n: ");
scanf("%d",&n);
len=(a+b)/n;//區間長度
for(i=0;i<n;i++)
{
F+=len*f(a);
a+=len;
}
printf("%f\n",F);
}
結果例如：
Please input a,b: 0 10.0
Please input n: 100
437.349792

7. 關於C語言的問題，位數大小排序（掌握數值排序演算法）

比如，輸入 18592

會先分離 1 8 5 9 2

然後再排序成 98521輸出

需要兩個函數，一個分離用，另一個排序用

#include<stdio.h>
intmain(void)
{
	voidpart(int,int[]);
	voidsort(int[]);
	intnum,x[5];
	printf("輸入一個5位正整數:");
	scanf("%d",&num);
	if(num>99999||num<10000)
	{
		printf("輸入不合格
");
		return1;
	}
	part(num,x);
	sort(x);
	for(num=0;num<5;num++)
		printf("%d",x[num]);
	return0;
}
voidpart(intn,intx[])
{
	inti;
	for(i=0;i<5;i++)
	{
		x[i]=n%10;
		n/=10;
	}
}
voidsort(intx[])
{
	inti,j,tmp;
	for(i=0;i<4;i++)
		for(j=i;j<5;j++)
			if(x[i]<x[j])
			{
				tmp=x[i];
				x[i]=x[j];
				x[j]=tmp;
			}
}

8. 怎麼用C語言編寫一個程序，輸入三個數值，然後輸出其中最大者。

#include

int
main()
{
int
a,b,c;//定義三個整形變數用來存儲那從鍵盤輸出的三個數
printf("請輸入3個數：");//提示語
scanf("%d
%d
%d",&a,&b,&c);//從鍵盤輸出三個數到a,b,c中
int
max;
//下面是最簡單的if循環求出這三個數最大值存入max中
if(a>b)
{
if(a>c)
{
max=a;
}
else
{
max=c;
}
}
else
{
if(b>c)
{
max=b;
}
else
{
max=c;
}
}
printf("這三個數的最大數為:
%d\n",max);
return
0;
}

9. 數制轉換寫演算法(用c語言編寫)

C語言中實現10進制轉換為任意進制的過程為：

• 定義數組int rs[32]，保存轉換後的數據，整數的轉換結果最多32位（4位元組*8位）

• 定義一個數組char map[]={'0','1','2','3',...,'9','A','B',...'F'}，完成相應數值對應的轉換後的字元

• 輸入10進制數（整數）num

• 轉入轉換進制基數（2-16）ind

• 循環對num進行模ind運算，得到余數存儲到數組rs中

• num縮小ind倍
  

• 當num為0時結束循環
  

• 反向輸出數組rs中對應的各元素對應的map字元，得到轉換結果

參考代碼：

#include<stdio.h>
intmain()
{
charmap[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
inti,c[32],num,ind;
do{printf("inputnum:");scanf("%d",&num);}while(num<0);
do{printf("inputind:");scanf("%d",&ind);}while(ind>16||ind<2);
i=0;
do{
c[i++]=num%ind;
num/=ind;
}while(num!=0);
for(i--;i>=0;i--)
printf("%c",map[c[i]]);
printf(" ");
return0;
}

運行結果：

input num: 100

input ind: 2

1100100

input num: 100

input ind: 8

144

input num: 100

input ind: 16

64

10. 求C語言排序演算法代碼，要求排序完以後能夠返回原來數值所在的位置。不能返回位置的排序代碼就不要復制了

#include<stdio.h>

int main()

{int n,i,j,t,a[20],b[20],c[20];

printf("請輸入有幾個數：");

scanf("%d",&n);

printf("請輸入%d個數： ",n);

for(i=0;i<n;i++)

{

scanf("%d",&a[i]);

b[i]=a[i];

c[i]=i+1;

}

for(i=0;i<n-1;i++)

for(j=0;j<n-1-i;j++)

if(b[j]>b[j+1])

{ t=b[j];b[j]=b[j+1];b[j+1]=t;

t=c[j];c[j]=c[j+1];c[j+1]=t;}

printf(" 排序以後的B數組： ");

for(i=0;i<n;i++)

printf("%d ",b[i]);

printf(" 排序以後的B數組： ");

for(i=0;i<n;i++)

printf("%d ",c[i]);

printf(" ");

return 0;

}