基于数组的常用算法及其应用

读书笔记：数组的常用算法及其应用

1、顺序查找

顺序查找就是指从前向后或从后向前依次将数组元素与待查的数据进行比较。

若在查找过程中，遇到满足条件的元素，则返回其在数组中的位置，若查找结束，仍为查找到满足条件的数据，则返回查找失败的标志信息给主调函数

#include‘Arry.h’     　　　　　　　　　　　　　　　　　　　　　　　//上一篇中的头文件“Arry.h”
#define N 100

int seqSearch(int a[],int n,int key)
{
    int n = 0;
    while(i<n && a[i} != key)　　　　　　　　　　　　　　　　　　//由前向后依次查找
    {
　　　　i++;
　　 if (i<n)　　return i;
　　　　else　　　　return -1;　　　　　　　　　　　　　　　　　　　　　//未找到返回-1
　　}
}
int main()
{
　　int a[N],x,pos;
　　init(a,N);　　　　　　　　　　　　　　　　　　　　　　　　　　　　//构造测试数组
　　print(a,n);
　　printf("请输入要查找的数： 
");
　　scanf("%d
",&x);
　　pos = seqSearch(a,N,x);
　　if(pos != -1)
　　　　printf("a[%d] = %d
",pos,a[pos]);
　　else
　　　　printf("查找失败!");
　　return 0;
}

2、数据删除

为了保证数组的连续性，删除pos位置的元素后，其后续元素应依次向前移动一个位置，并向函数返回删除后数组中实际数组的个数

#include“Arry.h”
#define N 10

int delDate(int a[],int n,int pos)
{
　　int i;
　　if(pos>=0 && pos<n)
　　{　　for (i = pos +1;i<n;i++)　　　　　　　　　　//将待删除位置后的数据依次向前移
　　　　　　a[i-1] = a[i];
　　　　 return n-1　　　　　　　　　　　　　　　　　　　//返回元素个数
　　}
　　else　　return n;　　　　　　　　　　　　　　　　　　//未删除成功个数仍为n
}

int main()
{
　　int a[N],n,pos;
　　init(a,N);　　　　　　　　　　　　　　　　　　　　　　//构造测试数组
　　print(a,N);
　　printf("请输入要删除的位置: 
");
　　scanf("%d
",&pos);
　　n = delData(a,N,pos);　　　　　　　　　　　　　　　//在数组中删除a[pos]
　　print(a,n);
　　return 0;
}

/*3、数据插入
要在数组的某个位置插入一个元素，首先要确定数组是否还有空闲单元
若有，则可将待插入位置之后的所有元素由后向前依次向后移动一个位置。
之后将待插入的数据存入插入的位置即可
*/
#include"Arry.h"
#define N 15

int insertData(int a[],int n,int pos,int x)
{
    int i;
    if(pos>=0 && pos<=n)　　　　　　　　　　　　　　　　　　　　　//判断插入位置是否有效
　　{
　　　　for (i = n-1;i>=pos;i--)
　　　　　　a[i+1]=a[i];　　　　　　　　　　　　　　　　　　　　　　//元素后移
　　　　　　a[pos] = x;　　　　　　　　　　　　　　　　　　　　　　// 插入数据
　　　　　　n++;
　　}
　　return n;
}

int main()
{
　　int a[N],n,pos,x;
　　init(a,10);　　　　　　　　　　　　　　　　　　　　　　　　　　　//构造测试数组
　　print(a,10);
　　printf("请输入要插入的位置和数：
");
　　scanf("%d%d
",&pos,&x);
　　n = insertData(a,10,pos,x);　　　　　　　　　　　　　　　　　//pos处插入元素
　　print(a,n);
　　return 0;
}

4、寻找最大值

先定义一个变量maxdata存放最大的数，初始时可将a[0]赋值给maxdata

之后依次将a[1]~a[n-1]与maxdata值进行比较，若发现某元素的值大于maxdata的值

则将改值赋给maxdata，待将所有数据比较完成后，maxdata值则为数组中最大的值

#include“Arry.h”
#define N 10

int findMax(int a[],int n)
{
    int i,MaxData = a[0];　　　　　　　　　　//将a[0]赋值给maxdata
　　 for (i =1,i<n,i++)
　　 　　if (a[i]>MaxData)
　　　　　　 MaxData = a[i];　　　　　　　　　//若a[i]的值大于maxdata，将a[i]的值赋给maxdata
　　 return MaxData;
}
int main()
{
　　int a[N],MaxData;
　　init(a,N);　　　　　　　　　　　　　　　　　　//构建测试数组
　　print(a,N);
　　MaxData = findMax(a,N);
　　printf("MaxDta = %d
",MaxData);
　　return 0;
}

5、数据排序

(1)、简单选择排序法

每次从待排序的数据中选出一个最小数，将该数并入以排序的部分（可将该数与待排序数据最前面的元素交换位置），

重复这个过程n-1次，即完成排序过程

#include"Arry.h>"
#define N 10

void selectSort(int a[],int n)
{
　　int i,j,minIndex,temp;
　　for (i = 0;i < n-1;i++)　　　　　　　　　　//重复n-1次选择过程，i表示本次最小数应存放的位置
　　{　　minIndex = i;　　　　　　　　　　　　　　//初始最小值位置
　　　　 for(j = i+1;j < n;j++)　　　　　　　　//在a[i..n-1]中找最小数
　　　　 　　if (a[j]<a[minIndex])
　　　　　　　　　minIndex = j;
　　　　if (minIndex != i)　　　　　　　　　　　　//若最小数不在第i个位置，则交换
　　　　{　　temp = a[i];
　　　　　　a[i] = a[minIndex];
　　　　　　a[minIndex] = temp;
　　　　}
　　}
}
int main()
{
　　int a[N];
　　input(a,N);
　　selectSort(a,N);　　　　　　　　　　　　//排序
　　print(a,N);
　　return 0;
}

（2）、冒泡排序

假设数组a中共含有n个元素，我们对该数组由前向后，依次对相邻的两个元素两两比较，如发现前面的元素大于后面的元素，则交换两个两邻元素，否则两数相对位置保持不变，这一过程成为一趟冒泡，

可以重复n-1次一趟冒泡来实现排序

#include“Arry.h”
#include<stdbool.h>
#define N 10

void bubbleSort(int a[],int n)
{
　　int i,temp;
　　bool flag = true;　　　　　　　　　　　　//flag = ture表示数组尚未有序，使用bool型需要加载stbool.h文件
　　while (n>1 && flag)　　　　　　　　　　 //参与冒泡的元素个数大于1且数组尚未有序
　　{
　　　　flag = false;
　　　　for (i = 0;i < n-1;i++)
　　　　　　if (a[i] > a[i+1])
　　　　　　　{
　　　　　　　　　temp = a[i];
　　　　　　　　　a[i] = a[i+1];
　　　　　　　　　a[i+1] = temp;
　　　　　　　　　flag==true;
　　　　　　　}
　　　　n--;　　　　　　　　　　　　　　　　　　　//参与冒泡的数据个数减1
　　}
}

flag在每次冒泡前 被赋值为false，若本趟冒泡的过程出现了逆序，其值将被重新修改为true，否则本次冒泡结束后，其值仍未false

下趟冒泡会因为(n>1 && false)条件逻辑为假而提前结束排序过程

6、数据倒置

倒置过程可由外向内依次进行，定义两个变量i和j，初始时分别指示数组的最前面和最后面

当i<j时，交换a[i]与a[j],然后i加1，j减1，重复上述操作直至i>=j就可以完成数组的首尾倒置

#include"Arry.h"
#define N 10
void reverse(int a[],int n)
{
　　int i=0;j=n-1;temp;
　　while (i<j)
　　{
　　　　temp = a[i];
　　　　a[i++] = a[j];
　　　　a[j--] = temp;
　　}
}
int main()
{
　　int a[N];
　　input(a,N);
　　print(a,N);
　　reverse(a,N);
　　print(a,N);
　　return 0;
}
　

7、二分查找

二分查找是一种比较高效的数据查找算法

为实现二分查找过程，可以定义三个变量left right mid，分别指示待查找区间的左边界、右边界和当前查找位置

当待查找区间不为空时，用mid=(left+right)/2;计算当前查找的位置。若该位置的值等于待查找的位置的数据，则查找进程结束，并返回mid值。

若待查找的值小于mid的值，则将left置于mid+1。将搜索区间缩小到右半部分，直到查找成功或搜索区间为空为止，

若搜索区间为空时，则返回查找失败的标志

#include"Arry.h"
#define N 10
void Selectsort(int a[],int n);
int binSearch(itn a[],int n.int key)
{
　　int left=0,right=n-1;mid;
　　while(left<=right)
　　{
　　　　mid = (right+left)/2;　　　　　　　　　　　　　　//二分
　　　　if (a[mid]==key)　　　　　　　　　　　　　　　　　//查找成功
　　　　　　return mid;
　　　　else
　　　　　　if(key<a[mid])
　　　　　　　　right = mid - 1;　　　　　　　　　　　　//搜索区间为左半部分
　　　　　　else
　　　　　　　　left = mid + 1;　　　　　　　　　　　　　//搜索区间为右半部分
　　}
　　return -1;　　　　　　　　　　　　　　　　　　　　　　//查找失败
}

int mian()
{
　　int a[N],x,pos;
　　init(a,N);
　　selectSort(a,N);
　　printf("请输入需查数据：
");
　　scanf("%d",&x);
　　pos = binSearch(a,N,x);
　　if (pos != -1)
　　　　printf("a[%d]=%d
",pos,x);
　　else
　　　　printf("查找失败.
");
　　return 0;
}