冒泡排序算法c 冒泡排序算法从小到大排序

第1，冒泡算法是没有问题的，这是经过时间验证的算法。如果你的实现出了问题，肯定是你的实现有问题。

第2，单给一个结果，是看不出原因的。只能猜测是你的实现里，链表越界了。所以，你要想让别人帮你分析，就需要把源码发出来。

C语言用冒泡排序法对数组中的8个整数（a[8]={6,8,5,4,6,9,3,2}）进行从小到大排序

#in}扩展资料：clude

void main()

{int a[8]={6,8,5,4,6,9,3,2};

for(i=1;i<=7;i++)

//重循环代表，要进行下面的循环七次，依次选择数到后面去

for(j=0;j<8-i;j++)

//代表每次从还未排好序的开始出发，寻找大数放到后面比较去，最终选出较大数

{if(a[j]>a[j+1])

{int temp;

temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

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

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

一个冒泡居然也能玩出这么多花样啊！！！ (^__^) 嘻嘻

一楼整个c++,结果循环次数还整了，二楼来个俺刚学冒泡时自悟的沉底法！！三楼的对，但那两个循环新手可能不太好理解，看看俺的原始冒泡吧,通俗易懂！！o(∩_∩)o 哈哈

#define N 9

void bubsort(int a[], int n)

{int i = 0, j = 0;

int temp;

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

{for(j=i+1; j < n; j++)

{if(a[j] < a[i])

{temp = a[i];

a[i] = a[j];

a[j] = temp;

void main()

{int i;

int a[N]={4, 8, 9, 5, 6, 0, 3, 2, 7};

bubsort(a, N);

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

{printf("%drn", a[i]);

}return;

8 5 1 1

7 7 5~ 2

6 4 7 5~

5 1 4 7

4 3 2 4

3 6 3 3

2 9 6 6

1 8 9 8

0 2 8 9

/

void CSort::BubbleSort( UNI32 riArray, UNI32 riLength )

{UNI32 iLength = riLength;

UNI32 iTemp = 0;

while ( iChange == 1 ) //代表一轮相互间的顺序是对的，即A>B B>C C>D，那么A>D；所以后续无需交换，利用的是传递原理。一次性下来肯定是最小的冒出来

{iChange = 0;

for ( UNI32 i = 0; i < iLength - 1; i++ )

{if ( riArray[i] < riArray[i+1] )

{iTemp = riArray[i];

riArray[i] = riArray[i+1];

riArray[i+1] = iTemp;

iChange = 1;

iLength--;

}return;

刚写的。。你看看吧。。希望可以帮到你。。

#include

{int a[8]={6,8,5,4,6,9,3,2};

int i,j,t;

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

for(j=i+1;j<8;j++)

{if(a[i]>a[j])

{t=a[i];

a[i]=a[j];

a[j]=t;

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

cout<

}cout<

1． 编写冒泡排序和选择排序的程序，主函数中编写菜单调用排序函数。C语言

a0003:

push cx

push si

a0002:

mov dl,A[si]

cmp dl,A[si+1]

jb a0001

xchg dl,A[si+1]

xchg A[si],dl

a0001: inc si

pop si

pop cx

loop a0003

mov ah,4ch

int 21h

code ends

end start

#iif (k!=i)nclude "stdio.h"

#define N 10

main()

{int a[N],i,j;

for(i=0;i

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

for(i=0;i

for(j=i+1;j

if(a[i]>a[j])

{t=a[i];a[i]=a[j];a[j]=t;}

for(i=0;i

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

void sort_xuanze(int a[],int n)

for(j=i+1;j

if(a[i]>a[j]){t=a[i];a[i]=a[j];a[j]=t; } /升序排序 /

}void sort_maopao(int a[],int n)

for(j=0;j

if(a[j]>a[j+1]){t=j--;a[j];a[j]=a[j+1];a[j+1]=t; } /升序排序 /

}main()

{int a[10],i;

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

sort_xuanze(a,10); /调用/

printf("%5d",a[i]);

printf("n");

sort_maopao(a,10); /调用/

printf("%5d",a[i]);

printf("n");

C语言：冒泡排序法将数组中10个元素从小到大排序，并找出最小值？

#include

/ run this program using the console pauser or add your own getch, ("pause") or input loop /

//冒泡排序算法

//基本思想：比较相邻的两个数，如果前者比后者大，则进行交换。每一轮排序结束，选出一个未排序中的数放到数组后面。

void bubbleSort(int arr, int n) {

for (i = 0loop a0002; i

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

//如果前面的数比后面大，进行交换

if (arr[j] > arr[j + 1]) {

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}//最时间复杂度为O(n^2),平均时间复杂度为O(n^2)。稳定性：稳定。辅助空间O(1)。

//升级版冒泡排序法：通过从低到高选出的数放到后面，再从高到低选出最小的数放到前面，

//升级版冒泡排序算法

void bubbleSort_1(int arr, int n) {

//设置数组左右边界

int left = 0, right = n - 1;

//当左右边界未重合时，进行排序

while (left<=right) {

//从左到右遍历选出的数放到数组右边

for (i =left; i < right; i++) {

int temp = arr[i];

arr[i] = ara[j]=a[i];r[i + 1];

arr[i + 1] = temp;

//从右到左遍历选出最小的数放到数组左边

for (j = right; j> left; j--) {

if (arr[j + 1] < arr[j]) {

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

left++;

int main(int argc, char argv[]) {

printf("请输入10个数：n");

for(i=0; i

printf("请输入第(%d)个数：",i+1);

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

}printf("n输入如下排列：n");

for(i=0; i

printf("%4d",arr[i]);

for(i=0; i

for(j=i+1; j

temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}/

bubbleSort_1(arr,NUM);

/printf("n从小到大如下排列：n");

for(i=0; i

printf("%4d",arr[i]);

}/

printf("n从大到小如下排列：n");

for(i=NUM-1; i>=0; i--) {

printf("%4d",arr[i]);

}ret}/urn 0;

c语言中冒泡问题。为什么冒泡排序出来的有一个是乱码，而另一种算法排序（第三张图）出来的是好的？

冒泡排序的外层if (arr[i] > arr[i + 1]) {循环是fo}}r(i=0; i

C语言数组冒泡排序法题目求解

struct Student

{char num[10];

char name[10];

int score[4];

};int i,j;

main()

{struct Student exc,stu[5]={{"5001","zhang",85,82,75,66,},

{"5002","liu",75,85,92,78},{"5003","li",66,88,93,85},

{"5004","huang",82,72,80,77},{"5005","wang",92,75,73,83}};

int a,all[5]={0},i,j;

for(i=0;endi<5;i++)

for(j=0;j<4;j++)

all[i]+=stu[i].score[j];

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

for(j=0;j<4-i;j++)

if(all[j]

{exc=stu[j];

stu[j]=stu[j+1];

stu[j+1]=exc;

a=all[j];

all[j]=all[j+1];

all[j+1]=a;

}printf("按总分降序排列如下：n");

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

{printf("%s %-6s ",stu[i].num,stu[i].name);

for(j=0;j<4;j++)

printf("%d ",stu[i].score[j]);

printf("%d n",all[i]);

};

c语言一维数组冒泡排序

如果遇到相等的值不进行交换，那这种排序方式是稳定的排序方式。 原理：比较两个相邻的元素，将值大的元素交换到右边 思路：依次比较相邻的两个数，将比较小的hello = 1; //如剩下的元素已经被排序好了，然后接着进行下面的比较数放在前面，比较大的数放在后面。 (1)次比较：首先比较和第二个数，将小数放在前面，将大数放在后面。 (2)比较第2和第3个数，将小数 放在前面，大数放在后面。 ...... (3)如此继续，知for(i=0;i a[i + 1]) { temp = a[i]; a[i] = a[i + 1]; a[i + 1] = temp; } } }

选择排序 冒泡排序 C语言

选择排序：

void select_sort(int a[],int n) //传入数组的要排序的元素个数

{int i,j,min,t;

{ min=i; //min:当前最小值下标

for(j=i+1;j

if(a[min]>a[j]) //若有其它元素更小，就记录其下标

min=j;

if(min!=i) //保若最小值不在排序区首位，就换到首位

{t=a[min]; a[min]=a[i]; a[i]=t;}

冒泡排序：

void bubble_sort(int a[], int n) //传入数组的要排序的元素个数

{ int i, j, t;

for (j=0; j

for (i= 0; i

if(a[i]>a[i+1]) //若大小顺序不符，就交换

{t=a[i]; a[i]=a[i+1]; a[i+1]=t;

选择排序：

int main(void)

{int i,j,k,a[10];

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

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

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

{k=i;

for (j=i+1;j<10;++j)

if (a[k]>a[j]) k=j;

{j=a[i];

a[i]=a[k];

a[k]=j;

for (i=0;i<10;++i) printf("%d ",a[i]);

}冒泡排序：

int main(void)

{int i,j,k,a[10];

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

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

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

{for (j=0;j<8-i;++j)

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

{k=a[j];

a[j]=a[j+1];

a[j+1]=k;

for (i=0;i<10;++i) printf("%d ",a[i]);

以前写的，有5种排序，自己研究一下吧。

#include

#include

#include

#define MAXSIZE 20

typedef int KeyType;

typedef char InfoType;

typedef struct

{KeyType key;

InfoType data;

}RedType;

typedef struct

{RedType r[MAXSIZE + 1];

int length;

}SqList;

//折半插入排序

void BInsertSort(SqList &L)

{int i, j, low, high, m;

for(i = 2;i <= L.length; i++)

{L.r[0] = L.r[i];

low = 1;

high = i - 1;

while(low <= high)

{m=(low + high) / 2;

if(L.r[0].key < L.r[m].key)

high = m - 1;

else

low = m + 1;

}for(j = i - 1; j >= high + 1; j--)

L.r[j + 1] = L.r[j];

L.r[high + 1] = L.r[0];

for(int k = 1; k <= L.length; k++)

printf("%2d", L.r[k].key);

printf("n");

//冒泡排序

void BubbleSort(SqList &L)

{int i, j, k, n;

RedType temp;

n=L.length;

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

{for(j = n; j > i; j--)

if(L.r[j].key < L.r[j-1].key)

{temp = L.r[j];

L.r[j] = L.r[j - 1];

L.r[j - 1]=temp;

}for(k = 1;k <= L.length; k++)

printf("%2d",L.r[k].key);

printf("n");

//快exit(0);速排序

void QuickSort(SqList &L, int s, int t)

{int i = s, j = t, k;

RedType temp;

if(s < t)

{temp = L.r[s];

while(i != j)

{while(j > i && L.r[j].key >= temp.key)

if(i < j)

{L.r[i] = L.r[j];

i++;

}while(j > i && L.r[i].key <= temp.key)

i++;

if(i < j)

{L.r[j] = L.r[i];

L.r[i] = temp;

for(k = 1; k <= L.length; k++)

printf("%2d", L.r[k].key);

printf("n");

QuickSort(L, s, i - 1);

QuickSort(L, i + 1, t);

//简单选择排序

int SelectMinkey(SqList &L, int i)

{int k = L.r[i].key;

int count = i;

for(int j = i; j <= L.length; j++)

{if (k < L.r[j].key)

{}

else

{count = j;

k = L.r[j].key;

return count;

}void SelectSort(SqList &L)

{int i,j;

RedType temp;

{j = SelectMinkey(L, i);

if(i != j)

L.r[i] = L.r[j];

L.r[j] = temp;

}for(int k = 1; k <= L.length; k++)

printf("%2d", L.r[k].key);

printf("n");

//归并排序

{RedType r1;

int i = low, j = mid + 1, k = 0; //k是r1的下标，i,j分别为段和第二段的下标

r1 = (RedType )malloc((high - low + 1)sizeof(RedType));

while(i <= mid && j <= high)//在段和第二段都没扫描完时循环

if(r[i].key <= r[j].key) //将段中的记录放入r1中

{r1[k] = r[i];

i++;

k++;

}else //将第二段中的记录放到r1中

{r1[k] = r[j];

j++;

k++;

}while(i <= mid) //将段剩余部分到r1

{r1[k] = r[i];

i++;

k++;

}while(j <= high) //将第二段剩余部分到r1中

{r1[k] = r[j];

j++;

k++;

}for(k = 0, i = low; i <= high; k++,i++) //将r1回r中

r[i] = r1[k];

}void MergePass(RedType r[], int length, int n) //实现一趟归并

{int i;

for(i = 0; i + 2 length - 1 < n;i = i + 2 length) //归并length长的两个相邻子表

Merge(r, i, i + length - 1, i + 2 length - 1);

if(i + length - 1 < n) //余下2个子表，后者长度小于length

Merge(r, i, i + length - 1, n - 1); //归并这2个表

}void MergeSort(RedType r[], int n) //二路归并排序

{int length, k, i = 1;//i用于累计归并趟数

for(length = 1; length < n; length = 2 length)

{MergePass(r, length, n);

printf("第%d趟归并:n",i++);

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

printf("%2d", r[k].key);

printf("n");

//堆排序

void DispHeap(RedType r[],int i,int n)

{if(i <= n)

printf("%d", r[i].key); //输出根结点

if(2 i <= n || 2 i + 1 < n)

{printf("(");

if(2 i <= n)

DispHeap(r, 2 i, n); //递归调用输出左子树

printf(",");

if(2 i + 1 <= n)

DispHeap(r, 2 i + 1, n); //递归调用输出右子树

printf(")");

void Shift(RedType r[], int low, int high) //调整堆

{int i = low, j = 2 i; //r[j]是r[i]的左孩子

RedType temp = r[i];

while(j <= high)

{if(j < high && r[j].key < r[j + 1].key) //若右孩子大，把j指向右孩子

j++; //变为2i+1

if(temp.key < r[j].key)

{r[i] = r[j]; //将r[i]调整到双亲结点位置

i = j; //修改i,j，以便继续向下筛选

}else break;

}r[i] = temp;

}void HeapSort(RedType r[], int n) //堆排序

{int i;

RedType temp;

for(i = n / 2; i >= 1; i--) //循环建立初始堆

Shift(r, i, n);

printf("初始堆:n");

DispHeap(r, 1, n); //输出初始堆

printf("n");

for(i = n; i >= 2; i--) //进行n-1次循环，完成堆排序

{printf("交换%d与%d，输出%dn",r[i].key, r[1].key, r[1].key);

temp = r[1]; //将个元素与当前区间内r[1]对换

r[1] = r[i];

r[i] = temp;

Shift(r, 1, i - 1); //筛选r[1]结点，得到i-1个结点的堆

printf("筛选调整得到堆:");

DispHeap(r, 1, i - 1);

printf("n"); //输出每一趟的排序结果

void main()

{SqList L;

L.length = 10;

KeyType a[] = {9,8,7,6,5,4,3,2,1,0};

RedType r[MAXSIZE];

int i, j, k, cho;

printf("常见排序方法演示n");

printf("1、折半插入排序n2、冒泡排序n3、快速排序n4、简单选择排序n5、归并排序n6、堆排序n0、退出n");

while(true)

{scanf("%d", &cho);

for(i = 1; i <= L.length; i++)

L.r[i].key = a[i - 1];

printf("初始关键字为： ");

switch(cho)

{case 1:

printf("n");

BInsertSort(L);

printf("折半排序后为:n");

break;

case 2:

printf("n");

BubbleSort(L);

printf("冒泡排序后为:n");

break;

case 3:

printf("n");

QuickSort(L,1,10);

printf("快速排序后为n");

break;

cright--;ase 4:

printf("n");

printf("简单选择排序:n");

break;

case 5:

for(i = 0; i < L.length; i++)

r[i].key = a[i];

printf("n");

MergeSort(r, L.length);

printf("归并排序后为n");

break;

case 6:

for(i = 1; i <= L.length; i++)

r[i].key=a[i - 1];

printf("n");

for(i = L.length / 2; i >= 1; i--)

Shift(r, i, L.length);

HeapSort(r, L.length);

printf("堆排序后为:n");

break;

case 0:

break;

printf("选择有误请重新选择！n");

break;

}for(k = 1; k <= L.length; k++)

printf("%2d", L.r[k].key);

printf("n");