三者取中演算法

Ⅰ 有沒有快速排序不能排的數的組合，這與快速排序不穩定有什麼關系

沒有，
即使是原始待排序序列完全正序或者完全逆序，使用普通的取最左元素為基準的方法會導致排序演算法性能下降，但是如果將取基準值的原則改為三者取中或者隨機取值後，演算法依然可以保存O(nlogn)的性能

Ⅱ 有3個4.6.7,任意取其中2個求和,得數有幾種可能

典型的排列組合題，該題結果是C(2,3)，就是在三個不同的數字中取出兩個，且不分順序。所以其他結果是3*2/(1*2)=3種情況。
如果是從三個數字中取中兩位組成一個二位數，這里因為存在十位與個數原因，所以可以看作是有順序的，結果應該是P(2,3),其結果就是 3*2 = 6種。
排列組合時只要分清其組合的形式即可。一種是取出來不需要順序的，那麼取的結果就是C符號表示，如果區分順序就用P表示。C的演算法是如C(n,m) = M*(M-1)*(M-2)*...*(M-N-1)/(1*2*3*...*N)，而P的演算法則不需要除法，即先從M中拿出一個的機率是M，再在剩餘的結果中拿出一個即M-1，依次類推。即P(n,m)/C(n,m) = n!(n的階乘)。只需要記好這個規律，你的初中幾乎所有的排列組合計算都不會錯了。說兩個絕對的結果，C(n,n)的結果是1，從三個數中取出三個數，計算其和，其實只有一種可能。而P(n,n)的結果是n!，從三個數中取出三個數字，組合一個三位數，其結果就是1*2*3=6種，如果上題中，467,476,647,674,764,746這六個數字。

Ⅲ 用演算法實現:單鏈表和順序表刪除。刪除順序表中值相同的多餘結點

第8章排序(演算法設計)習題練習答案
作者： 來源： http://www.csai.cn 2006年9月4日

13. 將哨兵放在R[n]中，被排序的記錄放在R[0..n-1]中，重寫直接插入排序演算法。
解：
重寫的演算法如下：
void InsertSort(SeqList R)
{//對順序表中記錄R[0..n-1]按遞增序進行插入排序
int i,j;
for(i=n-2;i>=0;i--) //在有序區中依次插入R[n-2]..R[0]
if(R[i].key>R[i+1].key) //若不是這樣則R[i]原位不動
{
R[n]=R[i];j=i+1; //R[n]是哨兵
do{ //從左向右在有序區中查找插入位置
R[j-1]=R[j]; //將關鍵字小於R[i].key的記錄向右移
j++;
}while(R[j].key<R[n].key]);
R[j-1]=R[n]; //將R[i]插入到正確位置上
}//endif
}//InsertSort.

14.以單鏈表作為存儲結構實現直接插入排序演算法。
解：
#define int KeyType //定義KeyType 為int型
typedef struct node{
KeyType key; //關鍵字域
OtherInfoType info; //其它信息域，
struct node * next; //鏈表中指針域
}RecNode; //記錄結點類型
typedef RecNode * LinkList ; //單鏈表用LinkList表示

void InsertSort(LinkList head)
{//鏈式存儲結構的直接插入排序演算法,head是帶頭結點的單鏈表
RecNode *p,*q,*s;
if ((head->next)&&(head->next->next))//當表中含有結點數大於1
{
p=head->next->next;//p指向第二個節點
head->next=NULL;
q=head;//指向插入位置的前驅節點
while(p)&&(q->next)&&(p->key<q->next->key)
q=q->next;
if (p)
{s=p;p=p->next;// 將要插入結點摘下
s->next=q->next;//插入合適位置：q結點後
q->next=s;
}
}
}

15.設計一演算法，使得在盡可能少的時間內重排數組，將所有取負值的關鍵字放在所有取非負值的關鍵字之前。請分析演算法的時間復雜度。
解：
因為只需將負數關鍵字排在前面而無需進行精確排列順序，因此本演算法採用兩端掃描的方法，就象快速排序採用的方法一樣，左邊掃描到正數時停止，開始掃描右邊，遇到負數時與左邊的當前記錄交換，如此交替進行，一趟下來就可以完成排序。

void ReSort(SeqList R)
{//重排數組，使負值關鍵字在前
int i=1,j=n; //數組存放在R[1..n]中
while (i<j) //i<j表示尚未掃描完畢
{ while(i<j&&R[i].key<0) //遇到負數則繼續掃描
i++;
R[0]=R[i]; //R[0]為輔助空間
while(i<j&&R[j].key>=0)// 遇到正數則繼續向左掃描
j--;
R[i++]=R[j];R[j--]=R[0];//交換當前兩個元素並移動指針
}//endwhile
}//ReSort

本演算法在任何情況下的比較次數均為n(每個元素和0)相比，交換次數少於n/2，總的來說，時間復雜度為O(n).

*16.寫一個雙向冒泡排序的演算法，即在排序過程中交替改變掃描方向。
解：
演算法如下：
void BubbleSort(SeqList R)
{//R[1..n]是待排序文件，雙向掃描冒泡排序
int i,j,k;
Boolean exchange; //交換標記
i=n;j=1;
exchange=TRUE;
while (i>j)&&(exchange)
{k=i-1;exchange=FALSE;
while (k>=j)//由下往上掃描
{if (r[k]>r[k+1])
{r[0]=r[k];r[k]=r[k+1];r[k+1]=r[k];exchange=TRUE;//交換
}//endif
k--;
}//endwhile
if (exchange)
{exchange=FALSE;
j++;k=j+1;
while(k<=i)//由上往下掃描
{if (r[k]<r[k-1])
{r[0]=r[k];r[k]=r[k-1];r[k-1]=r[k];exchange=TRUE;//交換
}//endif
k++;
}endwhile
i--;
}//endif
}endwhile
}//endsort

17.下面是一個自上往下掃描的冒泡排序的偽代碼演算法，它採用lastExchange 來記錄每趟掃描中進行交換的最後一個元素的位置，並以它作為下一趟排序循環終止的控制值。請仿照它寫一個自下往上掃描的冒泡排序演算法。
void BubbleSort(int A[],int n)
//不妨設A[0..n-1]是整型向量
int lastExchange,j,i=n-1;
while (i>0)
lastExchange=0;
for(j=0;j<i;j++)//從上往下掃描A[0..i]
if(A[j+1]<A[j]){
交換A[j]和A[j+1];
lastExchange=j;
}
i=lastExchange;//將i置為最後交換的位置
}//endwhile
}//BubbleSort

解：演算法如下：
void BubbleSort(int A[],int n)
//不妨設A[0..n-1]是整型向量
int lastExchange,j,i=0;
while (i<n) //這一條很重要，如不改為這樣，演算法將無限循環下去
lastExchange=n;
for(j=n-1;j>i;j--)//從下往上掃描A[0..i]
if(A[j-1]<A[j]){
交換A[j]和A[j-1];
lastExchange=j;
}
i=lastExchange;//將i置為最後交換的位置
}//endwhile
}//BubbleSort

18.改寫快速排序演算法，要求採用三者取中的方式選擇劃分的基準記錄；若當前被排序的區間長度小於等於3時，無須劃分而是直接採用直接插入方式對其排序。
解：
改寫後的演算法如下：
void QuickSort(SeqList R,int low ,int high)
{//對R[low..high]快速排序
int pivotpos;
if(high-low<=2)//若當前區內元素少於3個
{//則進行直接插入排序
InsertSort(R,low,high);
}
else
{
pivotpos=midPartion(R,low,high);
QuickSort(R,low,pivotpos-1);
QuickSort(R,pivotpos+1，high);
}
}//QuickSort

int midPartion(SeqList R,int i, int j)
{//三者取中規則定基準
if(R[(i+j)/2].key>R[i].key)
{ 交換R[(i+j)/2]和R[i];}
if(R[i].key>R[j].key)
{ 交換R[i]和R[j];}
if(R[i].key)<R[(i+j)/2].key)
{ 交換R[i]和R[(i+j)/2];}
//以上三個if語句就使區間的第一個記錄的key值為三個key的中間值
return Partion(R,i,j);//這樣我們就可以仍使用原來的劃分演算法了
}

19.對給定的j(1≤j≤n ),要求在無序的記錄區R[1..n]中找到按關鍵字自小到大排在第j個位置上的記錄(即在無序集合中找到第j個最小元)，試利用快速排序的劃分思想編寫演算法實現上述的查找操作。
答：
int QuickSort(SeqList R,int j,int low,int high)
{ //對R[low..high]快速排序
int pivotpos； //劃分後的基準記錄的位置
if(low<high){//僅當區間長度大於1時才須排序
pivotpos=Partition(R，low，high)； //對R[low..high]做劃分
if (pivotpos==j) return r[j];
else if (pivotpos>j) return(R,j,low,pivotpos-1);
else return quicksort(R,j,pivotpos+1,high);
}
} //QuickSort

20.以單鏈表為存儲結構，寫一個直接選擇排序演算法。
答：
#define int KeyType //定義KeyType 為int型
typedef struct node{
KeyType key; //關鍵字域
OtherInfoType info; //其它信息域，
struct node * next; //鏈表中指針域
}RecNode; //記錄結點類型

typedef RecNode * LinkList ; //單鏈表用LinkList表示

void selectsort(linklist head)
{RecNode *p,*q,*s;
if(head->next)&&(head->next->next)
{p=head->next;//p指向當前已排好序最大元素的前趨
while (p->next)
{q=p->next;s=p;
while(q)
{if (q->key<s->key) s=q;
q=q->next;
}//endwhile
交換s結點和p結點的數據；
p=p->next;
}//endwhile
}//endif
}//endsort

21.寫一個heapInsert(R,key)演算法，將關鍵字插入到堆R中去，並保證插入R後仍是堆。提示：應為堆R增加一個長度屬性描述(即改寫本章定義的SeqList類型描述，使其含有長度域)；將key先插入R中已有元素的尾部(即原堆的長度加1的位置，插入後堆的長度加1)，然後從下往上調整，使插入的關鍵字滿足性質。請分析演算法的時間。
答：
#define n 100//假設文件的最長可能長度
typedef int KeyType; //定義KeyType 為int型
typedef struct node{
KeyType key; //關鍵字域
OtherInfoType info; //其它信息域，
}Rectype; //記錄結點類型

typedef struct{
Rectype data[n] ; //存放記錄的空間
int length;//文件長度
}seqlist;

void heapInsert(seqlist *R,KeyType key)
{//原有堆元素在R->data[1]~R->data[R->length],
//將新的關鍵字key插入到R->data[R->length+1]位置後，
//以R->data[0]為輔助空間，調整為堆(此處設為大根堆)
int large;//large指向調整結點的左右孩子中關鍵字較大者
int low,high;//low和high分別指向待調整堆的第一個和最後一個記錄
int i;
R->length++；R->data[R->length].key=key;//插入新的記錄
for(i=R->length/2;i>0;i--)//建堆
{
low=i;high=R->length;
R->data[0].key=R->data[low].key;//R->data[low]是當前調整的結點
for(large=2*low;large<=high;large*=2){
//若large>high，則表示R->data[low]是葉子，調整結束；
//否則令large指向R->data[low]的左孩子
if(large<high&&R->data[large].key<R->data[large+1].key)
large++;//若R->data[low]的右孩子存在
//且關鍵字大於左兄弟，則令large指向它
if (R->data[0].key<R->data[large].key)
{ R->data[low].key= R->data[large].key;
low=large;//令low指向新的調整結點
}
else break;//當前調整結點不小於其孩子結點的關鍵字，結束調整
}//endfor
R->data[low].key=R->data[0].key;//將被調整結點放入最終的位置上
}//end of for
}end of heapinsert

演算法分析：
設文件長度為n,則該演算法需進行n/2趟調整，總的時間復雜度與初建堆類似，最壞時間復雜度為O(nlgn)，輔助空間為O(1).

22.寫一個建堆演算法：從空堆開始，依次讀入元素調用上題中堆插入演算法將其插入堆中。
答：
void BuildHeap(seqlist *R)
{
KeyType key;
R->length=0;//建一個空堆
scanf("%d",&key);//設MAXINT為不可能的關鍵字
while(key!=MAXINT)
{
heapInsert(R,key);
scanf("%d",&key);
}
}

23.寫一個堆刪除演算法：HeapDelete(R,i),將R[i]從堆中刪去，並分析演算法時間，提示：先將R[i]和堆中最後一個元素交換，並將堆長度減1，然後從位置i開始向下調整，使其滿足堆性質。
答：
void HeapDelete(seqlist *R,int i)
{//原有堆元素在R->data[1]~R->data[R->length],
//將R->data[i]刪除，即將R->data[R->length]放入R->data[i]中後，
//將R->length減1，再進行堆的調整，
//以R->data[0]為輔助空間，調整為堆(此處設為大根堆)
int large;//large指向調整結點的左右孩子中關鍵字較大者
int low,high;//low和high分別指向待調整堆的第一個和最後一個記錄
int j;
if (i>R->length)
Error("have no such node");
R->data[i].key=R->data[R->length].key;
R->length--；R->data[R->length].key=key;//插入新的記錄
for(j=i/2;j>0;j--)//建堆
{
low=j;high=R->length;
R->data[0].key=R->data[low].key;//R->data[low]是當前調整的結點
for(large=2*low;large<=high;large*=2){
//若large>high，則表示R->data[low]是葉子，調整結束；
//否則令large指向R->data[low]的左孩子
if(large<high&&R->data[large].key<R->data[large+1].key)
large++;//若R->data[low]的右孩子存在
//且關鍵字大於左兄弟，則令large指向它
if (R->data[0].key<R->data[large].key)
{ R->data[low].key= R->data[large].key;
low=large;//令low指向新的調整結點
}
else break;//當前調整結點不小於其孩子結點的關鍵字，結束調整
}//endfor
R->data[low].key=R->data[0].key;//將被調整結點放入最終的位置上
}//end of for
}end of HeapDelete

24.已知兩個單鏈表中的元素遞增有序，試寫一演算法將這兩個有序表歸並成一個遞增有序的單鏈表。演算法應利用原有的鏈表結點空間。
答：
typedef struct node{
KeyType key; //關鍵字域
OtherInfoType info; //其它信息域，
struct node * next; //鏈表中指針域
}RecNode; //記錄結點類型

typedef RecNode * LinkList ; //單鏈表用LinkList表示

void mergesort(LinkList la,LinkList lb,LinkList lc)
{RecNode *p,*q,*s,*r;
lc=la;
p=la;//p是la表掃描指針，指向待比較結點的前一位置
q=lb->next;//q是lb表掃描指針，指向比較的結點
while(p->next)&&(q)
if (p->next->key<=q->key)
p=p->next;
else {s=q;q=q->next;
s->next=p->next;p->next=s;//將s結點插入到p結點後
p=s;}
if (!p->next) p->next=q;
free(lb);
}

25.設向量A[0..n-1]中存有n個互不相同的整數，且每個元素的值均在0到n-1之間。試寫一時間為O(n)的演算法將向量A排序，結果可輸出到另一個向量B[0..n-1]中。
答：
sort(int *A,int *B)
{//將向量A排序後送入B向量中
int i;
for(i=0;i<=n-1;i++)
B[A[i]]=A[i];
}

*26.寫一組英文單詞按字典序排列的基數排序演算法。設單詞均由大寫字母構成，最長的單詞有d個字母。提示：所有長度不足d個字母的單詞都在尾處補足空格，排序時設置27個箱子，分別與空格，A，B...Z對應。
答：
#define KeySize 10 //設關鍵字位數d=10
#define Radix 27 //基數rd為27
typedef RecType DataType;//將隊列中結點數據類型改為RecType類型
typedef struct node{
char key[KeySize]; //關鍵字域
OtherInfoType info; //其它信息域，
}RecType; //記錄結點類型
typedef RecType seqlist[n+1];

void RadixSort(seqlist R)
{
LinkQueue B[Radix];
int i;
for(i=0;i<Radix;i++)//箱子置空
InitQueue(&B[i]);
for(i=KeySize-1;i>=0;i--){//從低位到高位做d趟箱排序
Distribute(R,B,i);//第KeySize-i趟分配
Collect(R,B);//第KeySize-i趟收集
}
}

void Distribute(seqlist R,LinkQueue B[], int j)
{//按關鍵字的第j個分量進行分配，初始時箱子為空
int i;
j=KeySize-j; // 確定關鍵字從低位起的位置
for(i=0;i<n;i++) //依次掃描R[i]，將其裝箱
if (R[i].key[j]-'A'>26)
EnQueue(&B[0],R[i]);//將第j位關鍵字位空格的記錄入第0個隊列
else EnQueue(&B[0],R[R[i].key[j]-'A'+1]);
}

void Collect(seqlist R,LinkQueue B[])
{
//依次將各非空箱子中的記錄收集起來，本過程結束，各箱子都變空
int i,j;
for (j=0;j<Radix;j++)
while(!QueueEmpty(&B[j]))
R[i++]=DeQueue(&B[j]);//將出隊記錄依次輸出到R[i]中
}

Ⅳ 怎麼計算中位值

中位值演算法：將所有數排序，然後取最中間的數，如果是偶數則取中間的兩個數然後除以2。

比如說有99個數字從小到大排列，排在第50的，就是這組數的中位數。這個數字的前面有49個數字，後面有49個數字，它正好排在最中間，就是中位數。

中位值---是將所給的一組數從小到大或從大到小排列，奇數個數的話取中間的數字，偶數個數的話取中間兩個數的平均數。

(4)三者取中演算法擴展閱讀

1、特點

中位數：與數據的排列位置有關，某些數據的變動對它沒有影響；它是一組數據中間位置上的代表值，不受數據極端值的影響。

2、作用

中位數：作為一組數據的代表，可靠性比較差，因為它只利用了部分數據。但當一組數據的個別數據偏大或偏小時，用中位數來描述該組數據的集中趨勢就比較合適。

Ⅳ 數據結構一道排序題怎麼排啊我想知道思路 答案已經有請告訴幫我分析一下

快速排序是對冒泡排序的一種改進。它的基本思想是：通過一躺排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一不部分的所有數據都要小，然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

假設要排序的數組是A[1]……A[N]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一躺快速排序。一躺快速排序的演算法是：

1）、設置兩個變數I、J，排序開始的時候I：=1，J：=N；

2）以第一個數組元素作為關鍵數據，賦值給X，即X：=A[1]；

3）、從J開始向前搜索，即由後開始向前搜索（J：=J-1），找到第一個小於X的值，兩者交換；

4）、從I開始向後搜索，即由前開始向後搜索（I：=I+1），找到第一個大於X的值，兩者交換；

5）、重復第3、4步，直到I=J；

例如：待排序的數組A的值分別是：（初始關鍵數據X：=49）

A[1] A[2] A[3] A[4] A[5] A[6] A[7]：

49 38 65 97 76 13 27

進行第一次交換後： 27 38 65 97 76 13 49

( 按照演算法的第三步從後面開始找

進行第二次交換後： 27 38 49 97 76 13 65

( 按照演算法的第四步從前面開始找>X的值，65>49,兩者交換，此時I：=3 )

進行第三次交換後： 27 38 13 97 76 49 65

( 按照演算法的第五步將又一次執行演算法的第三步從後開始找

進行第四次交換後： 27 38 13 49 76 97 65

( 按照演算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時J：=4 )

此時再執行第三不的時候就發現I=J，從而結束一躺快速排序，那麼經過一躺快速排序之後的結果是：27 38 13 49 76 97 65，即所以大於49的數全部在49的後面，所以小於49的數全部在49的前面。

快速排序就是遞歸調用此過程——在以49為中點分割這個數據序列，分別對前面一部分和後面一部分進行類似的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述數組A的快速排序的全過程如圖6所示：

初始狀態 {49 38 65 97 76 13 27}

進行一次快速排序之後劃分為 {27 38 13} 49 {76 97 65}

分別對前後兩部分進行快速排序 {13} 27 {38}

結束 結束 {49 65} 76 {97}

49 {65} 結束

結束

圖6 快速排序全過程

1）、設有N（假設N=10）個數，存放在S數組中；

2）、在S[1。。N]中任取一個元素作為比較基準，例如取T=S[1]，起目的就是在定出T應在排序結果中的位置K，這個K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的數都小於S[K]，在S[K]以後的數都大於S[K]；

3）、利用分治思想（即大化小的策略）可進一步對S[1。。K-1]和S[K+1。。N]兩組數據再進行快速排序直到分組對象只有一個數據為止。

如具體數據如下，那麼第一躺快速排序的過程是：

數組下標： 1 2 3 4 5 6 7 8 9 10

45 36 18 53 72 30 48 93 15 36

I J

（1） 36 36 18 53 72 30 48 93 15 45

（2） 36 36 18 45 72 30 48 93 15 53

（3） 36 36 18 15 72 30 48 93 45 53

（4） 36 36 18 15 45 30 48 93 72 53

（5） 36 36 18 15 30 45 48 93 72 53

通過一躺排序將45放到應該放的位置K，這里K=6，那麼再對S[1。。5]和S[6。。10]分別進行快速排序。

一般來說，冒泡法是程序員最先接觸的排序方法，它的優點是原理簡單，編程實現容易，但它的缺點就是--程序的大忌--速度太慢。下面我介紹一個理解上簡單但編程實現上不是太容易的排序方法，我不知道它是不是現有排序方法中最快的，但它是我見過的最快的。排序同樣的數組，它所需的時間只有冒泡法的 4% 左右。我暫時稱它為「快速排序法」。

「快速排序法」使用的是遞歸原理，下面我結合一個例子來說明「快速排序法」的原理。首先給出一個數組{53，12，98，63，18，72，80，46， 32，21}，先找到第一個數--53，把它作為中間值，也就是說，要把53放在一個位置，使得它左邊的值比它小，右邊的值比它大。{21，12，32， 46，18，53，80，72，63，98}，這樣一個數組的排序就變成了兩個小數組的排序--53左邊的數組和53右邊的數組，而這兩個數組繼續用同樣的方式繼續下去，一直到順序完全正確。

我這樣講你們是不是很胡塗，不要緊，我下面給出實現的兩個函數：

/*
n就是需要排序的數組，left和right是你需要排序的左界和右界，
如果要排序上面那個數組，那麼left和right分別是0和9
*/

void quicksort(int n[], int left,int right)
{
int dp;
if (left<right) {

/*
這就是下面要講到的函數，按照上面所說的，就是把所有小於53的數放
到它的左邊，大的放在右邊，然後返回53在整理過的數組中的位置。
*/
dp=partition(n,left,right);

quicksort(n,left,dp-1);

quicksort(n,dp+1,right); //這兩個就是遞歸調用，分別整理53左邊的數組和右邊的數組
}
}

我們上面提到先定位第一個數，然後整理這個數組，把比這個數小的放到它的左邊，大的放右邊，然後

返回這中間值的位置，下面這函數就是做這個的。
int partition(int n[],int left,int right)
{
int lo,hi,pivot,t;

pivot=n[left];
lo=left-1;
hi=right+1;

while(lo+1!=hi) {
if(n[lo+1]<=pivot)
lo++;
else if(n[hi-1]>pivot)
hi--;
else {
t=n[lo+1];
n[++lo]=n[hi-1];
n[--hi]=t;
}
}

n[left]=n[lo];
n[lo]=pivot;
return lo;
}

這段程序並不難，應該很好看懂，我把過程大致講一下，首先你的腦子里先浮現一個數組和三個指針，第一個指針稱為p指針，在整個過程結束之前它牢牢的指向第一個數，第二個指針和第三個指針分別為lo指針和hi指針，分別指向最左邊的值和最右邊的值。lo指針和hi指針從兩邊同時向中間逼近，在逼近的過程中不停的與p指針的值比較，如果lo指針的值比p指針的值小，lo++，還小還++，再小再++，直到碰到一個大於p指針的值，這時視線轉移到hi指針，如果 hi指針的值比p指針的值大，hi--，還大還--，再大再--，直到碰到一個小於p指針的值。這時就把lo指針的值和hi指針的值做一個調換。持續這過程直到兩個指針碰面，這時把p指針的值和碰面的值做一個調換，然後返回p指針新的位置。

Ⅵ c語言給定三個數abc試寫出中間數的演算法。

1、直接比較啊，就六種情況，都列出來即可找到中間數
2、先對著三個數進行排序，取中間位置的即是中間數
3、求三個數的和，及最大值和最小值，用和減去最大值和最小值即是中間數。

Ⅶ 設有三個整數abc，求找出中間值的演算法流程圖

設有三個整數abc，求找出中間值的演算法流程圖？（a+b+c）/2