1. c語言冒泡排序法詳解
任意兩個數作比較，大的放後面，小的放前面，然後大的在和下一個數比較，還是大的放後小的往前，以此類推，直到所有數比完了，然後輸出
2. C語言鏈表如何實現冒泡排序
兩種
思路:
1、交換鏈表中各節點的數據，不交換節點;
2、交換節點，即節點link指針的內容。
下面以第一種思路為例:
void
sort(LinkList
*L)
{
int
i,j,t;
LinkList
*p
=
L;
int
count
=
0;
while(p->link
!=
NULL)
{
count++;
p
=
p->link;
}
for(i=0;i<count-1;i++)
/*
冒泡法排序
*/
{
p
=
L;
for(j=0;j<count-i-1;j++)
{
if(p->data
>
p->link->data)
{
t=p->data;
p->data
=
p->link->data;
p->link->data=t;
}
p
=
p->link;
}
}
}
3. 數據結構C語言冒泡排序問題
修改：
for(j=n-1;j>=i;j--)
if(R[j+1].key<R[j].key)
{
int t = 0;
t=R[j].key;
R[j]=R[j+1];
R[j+1].key=t;
exchange=1;
}
了解一下冒泡排序（BubbleSort）的基本概念：
依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重復以上過程，直至最終完成排序。 由於在排序過程中總是小數往前放，大數往後放，相當於氣泡往上升，所以稱作冒泡排序。 用二重循環實現，外循環變數設為i，內循環變數設為j。外循環重復9次，內循環依次重復9，8，...，1次。每次進行比較的兩個元素都是與內循環j有關的，它們可以分別用a[j]和a[j+1]標識，i的值依次為1,2,...,9，對於每一個i,j的值依次為1,2,...10-i。
4. C語言，結構體冒泡排序，按平均分由大到小排列，怎麼弄啊
給你答案希望採納！！！！！！
#include <iostream>
#include<vector>
using namespace std;
struct Student
{
const char* name; //名字
float averageScore; //平均分
};
int main()
{
Student one = { "張三",65.2f };
Student two = { "李四",95.5f };
Student three = { "王二",75.8f };
Student four = { "麻子",88.3f };
Student five = { "提問者",5.0f };
//用數組
Student all[] = { one,two,three,four,five };
int count = 5; //5個學生
cout << "排序之前：\n";
for (int i = 0; i < count; ++i)
cout << all[i].name << "的平均成績為：" << all[i].averageScore << "分\n";
cout << "\n\n\n";
for (int i = 0; i < count - 1; ++i)
{
for (int j = count - 1; j > i; --j)
{
if (all[j].averageScore <= all[j - 1].averageScore)continue;
Student temp = all[j];
all[j] = all[j - 1];
all[j - 1] = temp;
}
}
//測試
cout << "排序之後：\n";
for (int i = 0; i < count; ++i)
cout << all[i].name << "的平均成績為：" << all[i].averageScore << "分\n";
cout << "\n\n\n";
/*
//用數據結構
vector<Student> allStudents;
allStudents.push_back(one);
allStudents.push_back(two);
allStudents.push_back(three);
allStudents.push_back(four);
allStudents.push_back(five);
for (int i = 0; i < allStudents.size() - 1; ++i)
{
for (int j = allStudents.size() - 1; j > i; --j)
{
if (allStudents[j].averageScore <= allStudents[j - 1].averageScore)continue;
Student temp = allStudents[j];
allStudents[j] = allStudents[j - 1];
allStudents[j - 1] = temp;
}
}
*/
return 1;
}
5. C語言:編寫一個程序用冒泡排序實現升序排列
程序如下：
#include <stdio.h>
int main ()
{
int a[10];
int i, j, t;
printf ("請輸入十個數: ");
for (i = 0; i < 10; i++)
{
printf ("a[%d]=", i+1);
scanf ("%d",&a[i]);
}
for (j = 0;j < 9; j++)
for (i = 0; i < 9 - j; i++)
if (a[i] > a[i+1])
{
t = a[i];
a[i] = a[i+1];
a[i+1] = t;
}
printf ("由小到大的順序為： ");
for (i = 0; i < 10; i++)
{
printf ("%d,",a[i]);
}
printf (" ");
return 0;
}
運行結果
請輸入十個數:
a[1]=7
a[2]=8
a[3]=9
a[4]=6
a[5]=5
a[6]=4
a[7]=1
a[8]=2
a[9]=3
a[10]=99
由小到大的順序為：
1,2,3,4,5,6,7,8,9,99。
冒泡排序演算法的原理如下：
1、比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2、對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
3、針對所有的元素重復以上的步驟，除了最後一個。
4、持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
(5)冒泡排序c語言數據結構擴展閱讀：
冒泡排序的思想:
首先，從表頭開始往後掃描數組，在掃描過程中逐對比較相領兩個元素的大小。若相鄰兩個元素中，前面的元素大於後面的元素，則將它們互換，稱之為清去了一個逆序。
在掃描過程中，不斷地將兩相鄰元素中的大者往後移動，最後就將數組中的最大者換到了表的最後，這正是數組中最大元素應有的位置。
然後，在剩下的數組元素中(n-1個元素)重復上面的過程，將次小元素放到倒數第2個位置。不斷重復上述過程，直到剩下的數組元素為0為止，此時的數組就變為了有序。
假設數組元素的個數為西，在最壞情況下需要的比較總次數為:(n-1)+(n-2)...+2+1)-n(n-1)/2。
6. C語言冒泡排序。
#include<stdio.h>
void main()
{
int a[10];
int i,j,t;
printf("input 10 numbers: ");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(j=0;j<9;j++) /*進行9次循環 實現9趟比較*/
for(i=0;i<9-j;i++) /*在每一趟中進行9-j次比較*/
if(a[i]>a[i+1]) /*相鄰兩個數比較,想降序只要改成a[i]<a[i+1]*/
{
t=a[i];
a[i]=a[i+1];
a[i+1]=t;
}
printf("the sorted numbers: ");
for(i=0;i<10;i++)
printf(" %d",a[i]);
}
(6)冒泡排序c語言數據結構擴展閱讀：
冒泡排序演算法的運作
1、比較相鄰的元素。如果第一個比第二個大（小），就交換他們兩個。
2、對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大（小）的數。
3、針對所有的元素重復以上的步驟，除了最後已經選出的元素（有序）。
4、持續每次對越來越少的元素（無序元素）重復上面的步驟，直到沒有任何一對數字需要比較，則序列最終有序。
簡單的表示
#include <stdio.h>
void swap(int *i, int *j)
{
int temp = *i;
*i = *j;
*j = temp;
}
int main()
{
int a[10] = {2,1,4,5,6,9,7,8,7,7};
int i,j;
for (i = 0; i < 10; i++)
{
for (j = 9; j > i; j--)//從後往前冒泡
{
if (a[j] < a[j-1])
{
swap(&a[j], &a[j-1]);
}
}
}
for (i = 0; i < 10; i++)
{
printf("%d ", a[i]);
}
return 0;
}
參考資料來源：冒泡排序-網路
7. C語言冒泡排序法
冒泡排序每一趟排序把最大的放在最右邊。
比如：
87 12 56 45 78
87和12交換：12 87 56 45 78
87和56交換： 56 87 45 78
87和45交換： 45 87 78
87和78交換： 78 87
到此第一趟排序結束，接下來的每一趟排序都是這樣。
#include<stdio.h>
voidPrint(int*num,intn)
{
inti;
for(i=0;i<n;i++)
printf("%d",num[i]);
puts(" ");
return;
}
voidBubble_Sort(int*num,intn)
{
inti,j;
for(i=0;i<n;i++)
{
for(j=0;i+j<n-1;j++)
{
if(num[j]>num[j+1])
{
inttemp=num[j];
num[j]=num[j+1];
num[j+1]=temp;
}
Print(num,n);
}
}
return;
}
intmain()
{
intnum[8]={87,12,56,45,78};
Bubble_Sort(num,5);
return0;
}
8. 請問數據結構（C語言版）冒泡排序剛開始要怎麼定義啊
定義 要排序數據的數組，定義兩個整型變數用於排序，定義一個排序數據類型的變數，用於交換數據，如：
int a[10];
int i,j;
int temp;
9. C語言,用結構體編寫冒泡排序
struct Student
{
int ID;
char Name[10];
};
void sort(Student *a, int n)
{
Student t;
int i, j;
for(i=0;i<n;i++)
for(j=0;j<n-i;j++)
if(a[j].ID>a[j+1].ID)
{
memcpy(&t, &a[j], sizeof(Student));
memcpy(&a[j], &a[j+1], sizeof(Student));
memcpy(&a[j+1], &t, sizeof(Student));
}
}
在結構體賦值中，上面使用memcpy函數，如：
memcpy(&t, &a[j], sizeof(Student));
可以替換為：
t.ID = a[j].ID;
strcpy(t.Name, a[j].Name);
依次類推。
10. c語言冒泡排序詳解
冒泡排序是最簡單的排序方法，理解起來容易。雖然它的計算步驟比較多，不是最快的，但它是最基本的，初學者一定要掌握。
冒泡排序的原理是：從左到右，相鄰元素進行比較。每次比較一輪，就會找到序列中最大的一個或最小的一個。這個數就會從序列的最右邊冒出來。
以從小到大排序為例，第一輪比較後，所有數中最大的那個數就會浮到最右邊；第二輪比較後，所有數中第二大的那個數就會浮到倒數第二個位置……就這樣一輪一輪地比較，最後實現從小到大排序。
比如對下面這個序列進行從小到大排序：
90 21 132 -58 34
第一輪：
1) 90 和 21比，90>21，則它們互換位置：
21 90 132 -58 34
2) 90 和 132 比，90<132，則不用交換位置。
3）132 和 –58 比，132>–58，則它們互換位置：
21 90 -58 132 34
4）132 和 34 比，132>34，則它們互換位置：
21 90 -58 34 132
到此第一輪就比較完了。第一輪的結果是找到了序列中最大的那個數，並浮到了最右邊。
比較時，每輪中第 n 次比較是新序列中第 n 個元素和第 n+1 個元素的比較（假如 n 從 1 開始）。
第二輪：
1) 21 和 90 比，21<90，則不用交換位置。
2) 90 和 –58 比，90>–58，則它們互換位置：
21 -58 90 34 132
3) 90 和 34 比，90>34，則它們互換位置：
21 -58 34 90 132
到此第二輪就比較完了。第二輪的結果是找到了序列中第二大的那個數，並浮到了最右邊第二個位置。
第三輪：
1) 21 和 –58 比，21>–58，則它們互換位置：
-58 21 34 90 132
2) 21 和 34 比，21<34，則不用交換位置。
到此第三輪就比較完了。第三輪的結果是找到了序列中第三大的那個數，並浮到了最右邊第三個位置。
第四輪：
1) –58 和 21 比，–58<21，則不用交換位置。
至此，整個序列排序完畢。從小到大的序列就是「–58 21 34 90 132」。從這個例子中還可以總結出，如果有 n 個數據，那麼只需要比較 n–1 輪。而且除了第一輪之外，每輪都不用全部比較。因為經過前面輪次的比較，已經比較過的輪次已經找到該輪次中最大的數並浮到右邊了，所以右邊的數不用比較也