從高到低比較演算法

① 、在函數中進行10個學生成績從高到低排名 sort(int a[10])；的代碼怎麼寫：

給個思路，代碼還是自己練習著寫才會有長進的

1.這個函數的局限性在於指定了元素數量大小是10，也就是說只能給有10個元素的數組排序

2.這個函數第一個參數沒有指定元素大小，而是將元素大小作為第2個參數，這樣就可以給任意元素個數的數組排序，只要將數組和元素個數傳入函數

3.這個函數增加了第3個參數，那麼根據第3個參數的值來進行降序排列或者升序排列，在函數體內用switch或者if就可以

至於排序的演算法，比較常見和簡單的譬如冒泡排序法

② 幾種常用的排序演算法比較

排序，從小大，0坐標的在下面，即排序後小的在下面，大的在上面。

1，冒泡Bubble：從第0個開始，一直往上，與相鄰的元素比較，如果下面的大，則交換。
Analysis：
Implementation：
void BubbleSort(int *pData, int iNum)

2，插入Insertion：與打撲克牌時整理牌很想像，假定第一張牌是有序的，從第二張牌開始，拿出這張牌來，往下比較，如果有比這張牌大的，則把它撥到上一個位置，直到找到比手上的這張更小的（或到頂了），
則把手上的這張牌插入到這張更小的牌的後面。
Analysis：
Implementation：
void InsertionSort(int *list, int length)
{
int i, j, temp;
for (i = 1; i < length; i++)
{
temp = list[i];
j = i - 1;
while ((j >= 0) && (list[j] > temp))
{
list[j+1] = list[j];
j--;
}
list[j+1] = temp;
}
}

3，選擇Selection：從所有元素中找到最小的放在0號位置，從其它元素（除了0號元素）中再找到最小的，放到1號位置，......。
Analysis：
Implementation：
void SelectionSort(int data[], int count)
{
int i, j, min, temp;
for (i = 0; i < count - 1; i++)
{
/* find the minimum */
min = i;
for (j = i+1; j < count; j++)
{
if (data[j] < data[min])
{
min = j;
}
}
/* swap data[i] and data[min] */
temp = data[i];
data[i] = data[min];
data[min] = temp;
}
}

4，快速Quick：先拿出中間的元素來（值保存到temp里），設置兩個索引（index or pointer），一個從0號位置開始往最大位置尋找比temp大的元素；一個從最大號位置開始往最小位置尋找比temp小的元素，找到了或到頂了，則將兩個索引所指向的元素
互換，如此一直尋找交換下去，直到兩個索引交叉了位置，這個時候，從0號位置到第二個索引的所有元素就都比temp小，從第一個索引到最大位置的所有元素就都比temp大，這樣就把所有元素分為了兩塊，然後採用前面的辦法分別排序這兩個部分。總的來
說，就是隨機找一個元素（通常是中間的元素），然後把小的放在它的左邊，大的放右邊，對左右兩邊的數據繼續採用同樣的辦法。只是為了節省空間，上面採用了左右交換的方法來達到目的。
Analysis：
Implementation：
void QuickSort(int *pData, int left, int right)
{
int i, j;
int middle, iTemp;
i = left;
j = right;

middle = pData[(left + right) / 2]; //求中間值
do
{
while ((pData[i] < middle) && (i < right)) //從左掃描大於中值的數
i++;

while ((pData[j] > middle) && (j > left)) //從右掃描小於中值的數
j--;

if (i <= j) //找到了一對值
{
//交換
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
} while (i <= j); //如果兩邊掃描的下標交錯，就停止（完成一次）

//當左邊部分有值(left<j)，遞歸左半邊
if(left < j)
QuickSort(pData, left, j);

//當右邊部分有值(right>i)，遞歸右半邊
if(right > i)
QuickSort(pData, i, right);
}

5，希爾Shell：是對Insertion Sort的一種改進，在Insertion Sort中，從第2個位置開始取出數據，每次都是與前一個（step/gap==1）進行比較。Shell Sort修改為，在開始時採用較大的步長step，
從第step位置開始取數據，每次都與它的前step個位置上的數據進行比較（如果有8個數據，初始step==4，那麼pos(4)與pos(0)比較，pos(0)與pos(-4)，pos(5)與pos(1)，pos(1)與pos(-3)，
...... pos(7)與pos(3)，pos(3)與pos(-1)），然後逐漸地減小step，直到step==1。step==1時，排序過程與Insertion Sort一樣，但因為有前面的排序，這次排序將減少比較和交換的次數。
Shell Sort的時間復雜度與步長step的選擇有很大的關系。Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相對比較簡單，它適合
於數據量在5000以下並且速度並不是特別重要的場合。它對於數據量較小的數列重復排序是非常好的。
Analysis：
Implementation：
template<typename RandomIter, typename Compare>
void ShellSort(RandomIter begin, RandomIter end, Compare cmp)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
typedef typename std::iterator_traits<RandomIter>::difference_type diff_t;

diff_t size = std::distance(begin, end);
diff_t step = size / 2;
while (step >= 1)
{

for (diff_t i = step; i < size; ++i)
{
value_type key = *(begin+i);
diff_t ins = i; // current position

while (ins >= step && cmp(key, *(begin+ins-step)))
{
*(begin+ins) = *(begin+ins-step);
ins -= step;
}

*(begin+ins) = key;
}

if(step == 2)
step = 1;
else
step = static_cast<diff_t>(step / 2.2);
}
}

template<typename RandomIter>
void ShellSort(RandomIter begin, RandomIter end)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
ShellSort(begin, end, std::less<value_type>());
}

6，歸並Merge：先將所有數據分割成單個的元素，這個時候單個元素都是有序的，然後前後相鄰的兩個兩兩有序地合並，合並後的這兩個數據再與後面的兩個合並後的數據再次合並，充分前面的過程直到所有的數據都合並到一塊。
通常在合並的時候需要分配新的內存。
Analysis：
Implementation：
void Merge(int array[], int low, int mid, int high)
{
int k;
int *temp = (int *) malloc((high-low+1) * sizeof(int)); //申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列
int begin1 = low;
int end1 = mid;
int begin2 = mid + 1;
int end2 = high;

for (k = 0; begin1 <= end1 && begin2 <= end2; ++k) //比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置
{
if(array[begin1]<=array[begin2])
{
temp[k] = array[begin1++];
}
else
{
temp[k] = array[begin2++];
}
}
if(begin1 <= end1) //若第一個序列有剩餘，直接拷貝出來粘到合並序列尾
{
memcpy(temp+k, array+begin1, (end1-begin1+1)*sizeof(int));
}
if(begin2 <= end2) //若第二個序列有剩餘，直接拷貝出來粘到合並序列尾
{
memcpy(temp+k, array+begin2, (end2-begin2+1)*sizeof(int));
}
memcpy(array+low, temp, (high-low+1)*sizeof(int));//將排序好的序列拷貝回數組中
free(temp);
}

void MergeSort(int array[], unsigned int first, unsigned int last)
{
int mid = 0;
if (first < last)
{
mid = (first+last)/2;
MergeSort(array, first, mid);
MergeSort(array, mid+1,last);
Merge(array,first,mid,last);
}
}

③ 寫出按從大到小的順序重新排列x，y，z三個數值的演算法。 注意，是演算法！

你說的是C語言嗎?
首先初始狀態是xyz
①、比較第一和第二個數，如果第一個小，不作處理，然後執行步驟②；如果第二個小，將兩者位置交換，然後執行步驟②
②、比較第二和第三個數，如果第二個小，不作處理，並結束排序；如果第三個小，將兩者位置交換，然後執行步驟③
③、比較第一和第二個數，如果第一個小，不作處理，並結束排序；如果第二個小，將兩者位置交換，並結束處理

④ 考核者對員工績效最高列最低進行排序的方法，是比較排序中哪種方法

簡單排序
考核者對員工績效最高列最低進行排序的方法，是比較排序中的簡單排序。

⑤ 從高到低 排序 去掉5% 取最高值 九五演算法

操作v字v剎v剎

⑥ C語言，5個數按從大到小排序，冒泡法

正確的程序代碼如下：

#include<stdio.h>
#defineN5
voidmain()
{	inta[N],i,j,t;
printf("請輸入5位學生的成績
");
for(i=0;i<N;i++)
scanf("%d",&a[i]);
for(i=0;i<N-1;i++)
{for(j=0;j<N-1-i;j++)
if(a[j+1]<=a[j]){
t=a[j];a[j]=a[j+1];a[j+1]=t;
}
}
printf("成績由高到低的排序為：
");	
for(i=0;i<N;i++)
printf("%d",a[i]);
}

修改兩個地方，一是{從if的前面移動到後面，而是判斷的內容j和j+1交換。

⑦ 對30個同學按身高排序並輸出結果的演算法

可以使用冒泡排序法。假如從高到低進行排序，先建立一個數組存放30個同學的身高數據int a[29];
然後通過循環進行比較。
for(int i=0;i<29;i++)
{
int b;
if(a[i]<a[i+1])
{
b=a[i];
a[i]=a[i+1];
a[i+1]=b;
}
}
這段代碼只是個大概思想，可能你得改改。

⑧ 怎麼樣才能自動的把幾個數據由高到低的排列名次

隨便用什麼排序演算法都行啊。
最簡單的冒泡排序，排序之後按照先後順序給定名次就可以啦啊