数组的排序&查找

排序

0.冒泡排序（Bubble Sort）
也称为沉降排序（Sinking Sort），之所以称其为冒泡排序，是因为算法中值相对较小的数据会像水中的气泡一样逐渐上升到数组的最顶端。与此同时，较大的数据逐渐地下沉到数组的底部。这个处理过程需在整个数组范围内反复执行多遍。每一遍执行时，比较相邻的两个元素。若顺序不对，则将其位置交换，当没有数据需要交换时，数据也就排好序了。编程将排序函数DataSort()改用冒泡法实现。
输入格式要求："%d" 提示信息：“Input n:” “Input %d numbers:”
输出格式要求：“Sorting results:” “%4d”
程序运行示例如下：
Input n:10
Input 10 numbers: 2 9 3 4 0 6 8 7 5 1
Sorting results: 0 1 2 3 4 5 6 7 8 9

#include<stdio.h>
#define N 10
/*函数功能:使用冒泡法实现数组a的n个元素的升序排序*/
void BubbleSort (int a[], int n)
{
    int i, j,temp;
    for (i=0; i<n-1; i++){//趟数，n个数据n-1趟
        for (j=1; j<n-i; j++){//执行1~总个数-当前趟数次，后方已确定
            if (a[j] < a[j-1]){//相邻的数据比大小
                temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    } 
}
int main() 
{
    int i, n, a[N];
    printf ("Input n:");
    scanf ("%d", &n) ;
    printf ("Input %d numbers:", n);
    for (i=0; i<n; i++){
        scanf ("%d", &a[i]) ;
    }
    BubbleSort(a,n);
    printf ("Sorting results:");
    for (i=0; i<n; i++){
        printf ("%4d", a[i]);
    }
    printf("\n") ;
    return 0;
}

1.交换法排序（Exchange Sort）
借鉴了求最大、最小值的思想。以降序排列为例，首先进行第一轮比较,参与比较的数有n个，将第一个数分别与后面所有的数进行比较,若后面的数较大，则交换后面这个数和第一个数的位置;这一轮比较结束以后,就求出了一个最大的数放在了第一个数的位置。然后进入第二轮比较,参与比较示 的数变为n-1个,在这n-1个数中再按上述方法求出一个最大的数放在第二个数的位置。然后进人第三轮比较…依此类推,直到第n-1轮比较,参与比较的数变为2个，求出一个最大数放在第n-1个数的位置，剩下的最后一个数自然就为最小的数放在最后。 n个数总共需要n-1轮比较
按交换法进行成绩降序排序的算法描述如下：

for(i = 0;i<n-1;i++){//趟数，n个数据n-1趟
	for(j = i+1;j<n;j++){//从当前趟数后一个开始比较，前方已确定
		若score[j]>score[i]
		则交换score[j] > sccore[i]的值 
	}
} 

2.选择法排序（Selection Sort）
可以在找出余下的数中的最大值后再与第i+1个数交换位置，整个算法最多有n-1次两数交换

void DataSort(int num[],int n)
{
    int i,j,k,temp;
    for(i=0;i<n-1;i++){
    	k = i;  //游标 
        for(j=i+1;j<n;j++){
            if(num[j]>num[k]){  //按数组num元素值从高到低排序 
                k = j;  //记录最大数下标位置 
            }
        }
        if(k != i){  //若最大数所在的下标位置不在下标位置i 
        	temp = num[k];
            num[k] = num[i];
            num[i] = temp;
		}
    }
}

3.花式排序
写一个程序，输入十个整数到数组unsorted中。程序将循环遍历unsorted数组十遍，
每遍选择最小的值拷贝到sorted数组中的下一个可用元素位置，
并将unsorted中对应的最小值替换为一个大值（例如9999）。示例如下：
开始时的unsorted：14 22 67 31 89 11 42 35 65 49
开始时的sorted：

第一遍后的unsorted：14 22 67 31 89 9999 42 35 65 49
第一遍后的sorted：11

第二遍后的unsorted：9999 22 67 31 89 9999 42 35 65 49
第一遍后的sorted：11 14
……
显示sorted数组的值。

**输入格式要求："%d" 提示信息：“请输入十个整数：\n” “第%d个数：”
**输出格式要求："%d " 提示信息：“完成后sorted数组的值为：”

#include <stdio.h>
 
int main()
{                 
    int unsorted[10], sorted[10];
    int i, j, min, pmin;
 
    printf("请输入十个整数：\n");
    for (i = 0; i < 10; i++)
    {                 
        printf("第%d个数：", i + 1);
        scanf("%d", &unsorted[i]);
    }
 
    for (i = 0; i < 10; i++)
    {                 
        min = unsorted[0];
        pmin = 0;
        for (j = 0; j < 10; j++)
        {                 
            if (unsorted[j] < min)
            {                 
                min = unsorted[j];
                pmin = j;
            }
        }
        unsorted[pmin] = 9999;
        sorted[i] = min;
    }
 
    printf("完成后sorted数组的值为：");
    for (i = 0; i < 10; i++)
    {                 
        printf("%d ", sorted[i]);
    }
 
    return 0;
}               

4.插入排序（Insertion Sort）
用函数编程实现在一个按升序排序的数组中查找x应插入的位置，将x插入数组中，使数组元素仍按升序排列。
**输入格式要求："%d"
提示信息：“Input array size:” “Input array:” “Input x:”
**输出格式要求：“After insert %d:\n” “%4d”
程序运行示例如下：
Input array size:5
Input array:1 3 5 7 9
Input x:4
After insert 4:
1 3 4 5 7 9

#include<stdio.h>
int main()
{
	printf("Input array size:");
	int size,i,x,t;
	scanf("%d",&size);
	printf("Input array:");
	int a[size+1];
	for(i=0;i<size;i++){
		scanf("%d",&a[i]);
	}
	printf("Input x:");
	scanf("%d",&x);
	
	int pos;
	for(i=0;i<size;i++){
		if(x<a[i]){
			pos=i;
			break;
		}
	}
	for(i=size;i>=pos;i--){
		 a[i]=a[i-1];
	}
	a[pos]=x;
	printf("After insert %d:\n",x);
	for(i=0;i<=size;i++)
		printf("%4d",a[i]);
	return 0;
 } 

查找
0.线性查找（Linear Search）
也叫顺序查找（Sequential Search），算法简单直观，但效率较低。不要求被查找数组元素是否有序。
基本思想：扫描整个数组

1.折半查找（Binary Search）
也叫对分搜索，算法稍微复杂，但效率很高。当代查找信息有序排列时，折半查找法比顺序查找法的平均查找速度要快的多。
基本思想：首先选取位于数组中间的元素，将其与查找键进行比较。若果它们的值相同，则找到，返回数组中间元素的下标；将查找区间缩小为原来的一半，即在一般的数组元素中查找。

//按折半查找法查找值为x的数组元素，若找到则返回x在数组中的下标位置，否则返回-1
int BinSearch(long num[],long x,int n)
{
	int low = 0,high = n-1,mid;  //区间左端点low置为0，右端点high置为n-1 
	int pos = -1;  //若循环结束还未找到，则返回pos的初始值-1 
	int find = 0;  //置找到的标志变量flag为假 
	while(!find && low<=high){  //若未找到且左端点<=右端点，则继续找 
		mid = low + (high - low)/2;//取数据区间的中点，减法代替加法，防止数值溢出
		if(x>num[mid]){  
			low = mid +1;  //若x>num[mid]，则修改左端点 
		}else if(x<num[mid]){
			high = mid -1;  //若x<num[mid]，则修改右端点 
		}else{
			pos = mid;  //若找到，则置下标值为mid 
			find = 1;  //置找到标志变量flag为真 
		}
	}
	return pos;
} 

二分法求方程的根