数据结构——排序查找算法实现

最新推荐文章于 2024-10-04 13:07:40 发布

langtaol

最新推荐文章于 2024-10-04 13:07:40 发布

阅读量1.7k

点赞数 2

分类专栏：数据结构文章标签：数据结构排序算法查找算法

本文链接：https://blog.csdn.net/u010757264/article/details/52241538

版权

数据结构专栏收录该内容

24 篇文章 0 订阅

订阅专栏

排序和查找算法实现

前面转载了一篇讲排序算法的文章，这几天将排序和查找算法进行了实现，在这里贴出代码来。

1. 插入排序

插入排序——直接插入排序：将一个记录插入到已排序好的有序表中，就像打扑克牌揭到牌后插入在特定位置。

#include<iostream>
using namespace std;
void sort(int a[],int n)      //插入排序算法
{
         inti,j,temp;         //定义循环变量i,j以及临时变量temp
         for(i=1;i<n;i++)     //依次将数组中每一个a[i]插入到适当位置
         {
                   j=i-1;
                   temp=a[i];
                   while(temp<a[j])
                   {  
                            a[j+1]=a[j];   //交换a[j]往后移动
                            j--;
                   }
 
                   a[j+1]=temp;
 
/*     for(int i=0;i<n;i++)      //这里为了便于理解，打印出了每次for循环后的结果
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
*/              
         }
        
}
 
void print(int *a, int n)      //数组输出函数
{
         for(int i=0;i<n;i++)
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
 
}
int main()
{
         inta[]={43,1,9,54,32,17,88,24,72,48};
 
         print(a,10);
         sort(a,10);
         print(a,10);
 
         return 0;
}

下面这个冒泡排序代码和插入排序很相似

#include<iostream>
using namespace std;
void sort(int a[],int n)      //冒泡排序算法
{
         inti,j,temp;         //定义循环变量i,j以及用于交换的临时变量temp
         for(i=1;i<n;i++)     //依次将数组中每一个a[i]插入到适当位置
         {
                   for(j=0;j<i;j++)
                   {
                            if(a[j]>a[i])
                            {
                                     temp=a[j];         //交换a[j]与a[i]
                                     a[j]=a[i];
                                     a[i]=temp;
                            }
 
                   }
 
/*     for(inti=0;i<n;i++)       //这里为了便于理解，打印出了每次for循环后的结果
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
*/              
         }
        
}
 
void print(int *a, int n)        //数组输出函数
{
         for(int i=0;i<n;i++)
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
 
}
int main()
{
         inta[]={43,1,9,54,32,17,88,24,72,48};
 
         print(a,10);
         sort(a,10);
         print(a,10);
 
         return 0;
}

2. 插入排序——希尔排序

插入排序——希尔排序：将一个序列分成多次进行直接插入排序，当步长为1的时候，就是直接插入排序。

#include<iostream>
using namespace std;
 
void sort(int a[],int n)          //希尔排序算法
{   
         inti,j,k,h,temp;         //定义循环变量i,j和数组下标变量k以及用于交换的临时变量temp,h为步长
 
         for(h=n/2;h>0;h=h/2)     //h为序列分组步长，下一次步长是上一次的一半
         {
                   for(i=0;i<n/h;i++)            //依次插入数组中每一个数a[i],步长为h，循环n/h次就将数组遍历完了
                   {
                            k=i;                 //每次开始时，记录下标到k
                            for(j=i;j<n;j=j+h)   //j每次增加步长h，即序列中间隔步长比较
                            {
                                      if(a[k]>a[j])       //寻找它后面的数中最小的数
                                               k=j;       //交换下标，k记录了最小的数的下标
                            }
                            temp=a[k];                    //交换a[i]与a[i]后面最小的数的位置
                            a[k]=a[i];
                            a[i]=temp;       
                   }
 
/*               for(int i=0;i<n;i++)  //这里为了便于理解，打印出了每次for循环后的结果
                   { 
                            cout<<a[i]<<"";
                   }
                   cout<<endl;
*/
 
/*
原序列               43  1  9  54  32  17  88  24  72  48
 
第一次排序：         17  1  9  54  32  43  88  24  72  48        
 
第二次排序：         9      17     32      72      88        --直接插入排序
                        1      24      43      48      54    --直接插入排序
  
第三次排序：         1   9  17 24  32  43  48  54  72  88
*/
         }
        
}
 
void print(int *a, int n)      //数组输出函数
{
         for(int i=0;i<n;i++)
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
 
}
int main()
{
         inta[]={43,1,9,54,32,17,88,24,72,48};
 
         print(a,10);
         sort(a,10);
         print(a,10);
 
         return0;
}

3. 冒泡排序

冒泡排序：让较大的数往下沉，较小的往上冒。

#include<iostream>
using namespace std;
void sort(int a[],int n)       //冒泡排序算法
{
         inti,j,temp;          //定义循环变量i,j用于交换的临时变量temp
         for(i=0;i<n;i++)      //依次比较数组中每一个数a[i]
         {
                   for(j=i+1;j<n;j++)//将a[i]后的每一个a[j]与其进行比较
                   {
                            if(a[i]>a[j])     //如果a[j]比a[i]小，交换a[i]与a[j]，使a[j]往上冒泡
                            {
                                     temp=a[i];        
                                     a[i]=a[j];
                                     a[j]=temp;
                            }       
                   }
 
/*               for(int i=0;i<n;i++)         //这里为了便于理解，打印出了每次for循环后的结果
                   {
                            cout<<a[i]<<"";
                   }
                   cout<<endl;
*/
         }
}
 
void print(int *a, int n)   //数组输出函数
{
         for(int i=0;i<n;i++)
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
 
}
int main()
{
         inta[]={43,1,9,54,32,17,88,24,72,48};
 
         print(a,10);
         sort(a,10);
         print(a,10);
 
         return0;
}

4. 快速排序

快速排序：首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。然后递归调用此函数

#include<iostream>  
using namespace std;  
void print(int *a, int n)   //数组输出函数  
{  
         for(int i=0;i<n;i++)  
         {  
                   cout<<a[i]<<" ";  
         }  
         cout<<endl;  
}

void sort(int a[], int left, int right)
{
    if(left >= right)
    {
        return;
    }
    int i = left;
    int j = right;
    int key = a[i];      /*用第一个记录作为关键字*/

    while(i < j)
    {
        while(i < j && a[j] >= key)   j--;
        a[i] = a[j];          /*将比第一个小的移到低端*/

        while(i < j && a[i] <= key)   i++;
        a[j] = a[i];          /*将比第一个大的移到高端*/

    }

    a[i] = key;               /*关键字记录到位*/
    //print(a,10);  

    sort(a, left, i-1);
    sort(a, i+1, right);
}
    
int main()  
{  
         int a[]={43,1,9,54,32,17,77,24,72,48};  
   
         print(a,10);  
         sort(a,0,9);        //注意：这里参数传递的是数组的下标，所以最大到9  
         print(a,10);  
   
         return 0;  
}

5. 选择排序——简单选择排序

选择排序——简单选择排序：在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换；依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

#include<iostream>
using namespace std;  
void sort(int a[],int n)                         //简单排序算法
{ 
         inti,j,k,temp;                          //定义循环变量i,j和数组下标变量k以及用于交换的临时变量temp
         for(i=0;i<n-1;i++)                      //依次插入数组中每一个数a[i]
         {
                   k=i;                          //每次开始时，记录下标到k
                   for(j=i+1;j<n;j++)
                   {
                            if(a[k]>a[j])       //寻找它后面的数中最小的数
                                     k=j;       //交换下标，k记录了最小的数的下标
                   }
                   temp=a[k];                   //交换a[i]与a[i]后面最小的数的位置
                   a[k]=a[i];
                   a[i]=temp;
/*     for(int i=0;i<n;i++)                      //这里为了便于理解，打印出了每次for循环后的结果
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
*/              
         }
        
}
 
void print(int *a, int n)   //数组输出函数
{
         for(int i=0;i<n;i++)
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
 
}
int main()
{
         inta[]={43,1,9,54,32,17,88,24,72,48};
 
         print(a,10);
         sort(a,10);
         print(a,10);
 
         return0;
}

6. 归并排序

归并排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

#include<iostream>
using namespace std;
void print(int *a, int n)     //数组输出函数
{
         for(int i=0;i<n;i++)
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
 
}
 
//将a[i…m]和a[m +1 …n]归并到辅助数组b[i…n]
void merge(int *a,int *b, int i, int m, intn) 
{ 
   int j,k; 
   for(k=i,j=m+1; i<=m && j <=n ; k++)
         { 
       if(a[j] < a[i])
                            b[k]= a[j++]; 
       else
                            b[k]= a[i++]; 
    }
        
   //如果a[i…m]和a[m +1 …n]的长度不一样，在上面的for循环中有一个提前终止，则用下面的while循环继续移动
   while(i <= m)  b[k++] =a[i++]; 
   while(j <= n)  b[k++] =a[j++]; 
 
   print(b,n+1);    //代码测试，输出结果
} 
 
void sort(int *a, int *b, int lenght) 
{  
   int len = 1; 
   int *temp ; 
   while(len < lenght)
         { 
       int s = len; 
       len = 2 * s ; 
       int i = 0; 
       while(i+ len <lenght)
                   { 
           merge(a, b,  i, i+ s-1, i+ len-1);  //对等长的两个子表合并 
           i = i+ len; 
       } 
 
                   //按照上面等长合并后，序列最后的几个数可能不能按照等长合并，则将最后几个数和其前面一组等长合并的子序列统一合并
     
           merge(a, b,  i, i+ s-1, lenght-1); //对不等长的两个子表合并，此时合并到了序列最末端 
    
       temp = a;    //交换a,b，以保证下一趟归并时，仍从a归并到b 
                   a= b;
                   b= temp;
 
   } 
} 
 
 
int main()
{
         inta[]={43,1,9,54,32,17,88,24,72,48};
   int b[10]; 
 
         print(a,10);
         sort(a,b,10);
         print(a,10);
 
         return0;
}

7. 基数排序

基数排序：简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。然后收集数据，再放入桶中，循环此操作。

例如，在整理扑克牌顺序时，先按红、黑、方、花的顺序分成4摞（分配），再按此顺序再叠放在一起（收集）；然后按面值的顺序分成13摞（分配），再按此顺序叠放在一起（收集），如此进行二次分配和收集即可将扑克牌排列有序。

#include<iostream>
using namespace std;
void print(int *a, int n)   //数组输出函数
{
         for(int i=0;i<n;i++)
         {
                   cout<<a[i]<<"";
         }
         cout<<endl;
 
}
 
int maxbit(int a[], int n)    //辅助函数，求数据的最大位数，即后面最外层循环的次数
{
   int d = 1;                 //保存最大的位数
   int p = 10;
   for(int i = 0; i < n; ++i)
    {
       while(a[i] >= p)
       {
           p *= 10;
           d++;
       }
    }
   return d;
}
 
void sort(int a[], int n)     //基数排序
{
   int d = maxbit(a, n);
   int *box= new int[n];      //箱子，桶
   int *count = new int[10];  //计数器
   int i, j, k;
   int radix = 1;             //倍率
 
   for(i=0; i<d; i++) //进行d次排序
    {
       for(j = 0; j < 10; j++)     //每次分配前清空计数器
           count[j] = 0;
 
       for(j = 0; j < n; j++)      //统计每个桶中的记录数
       {
           k = (a[j] / radix) % 10;
           count[k]++;
       }
 
for(j = 0; j < 10; j++)            //代码测试，观看每个桶中数的个数count[j]
    cout<< count[j] <<"     ";
cout<<endl;
       
                   for(j= 1; j < 10; j++)      //将box中的位置依次分配给每个桶
           count[j] = count[j - 1] + count[j];
 
for(j = 0; j < 10; j++)                        //代码测试
    cout<< count[j] <<"     ";
cout<<endl;
 
       for(j = n - 1; j >= 0; j--)             //将所有记录依次放到桶中
                   {
           k = (a[j] / radix) % 10;
           box[count[k] - 1] = a[j];
           count[k]--;
       }
 
for(j = 0; j < 10; j++)                        //代码测试
    cout<< box[j] <<"     ";
cout<<endl;
 
       //将已分配好的桶中数据再倒出来(收集数据)，此时已是对应当前位数有序的表
       for(j = 0; j < n; j++) //将box复制到a中，为下一次分入不同桶做准备
           a[j] = box[j];
 
       radix = radix * 10;   
                   print(a,10);
    }
   delete[]box;
   delete[]count;
}
 
int main()
{
         inta[]={43,1,9,54,32,17,88,24,72,48};
 
         print(a,10);
         sort(a,10);
         print(a,10);
 
         return0;
}

8. 堆排序

此程序来自百科百度，因为写的相对比较简练，所以拿过来了。

大根堆：所有子节点都小于父节点。

小根堆：所有子节点都大于父节点。

堆排序：将a[n]看作一棵完全二叉树的存储结构，先将a[n]建成一个大堆，此时是无序的，再将a[1]和无序区的最后一个元素a[n]交换，得到新无序区a[1...n-1]和有序区a[n]，调整无序区a[1...n-1]为大根队，与无序区的最后一个元素a[n-1]交换；重复上述操作。

#include <iostream>
using namespace std;
//交换函数,参数传入为地址
void swap(int *a,int *b)
{       
         inttemp;
         temp=*a;
         *a=*b;
         *b=temp;
}
 
 
//本函数功能是：根据数组array构建大根堆
void HeapAdjust(int array[],int i,intnLength)     //array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度
{
   int nChild;
   for(;2*i+1<nLength;i=nChild)
    {
       nChild=2*i+1;           //子结点的位置=2*（父结点位置）+1
 
       if(nChild<nLength-1 && array[nChild+1]>array[nChild]) 
             ++nChild;         //得到子结点中较大的结点
 
       if(array[i]<array[nChild])                 //如果子结点大于父结点那么交换子结点和它的父结点
             swap(array[i],array[nChild]);
       else
             break;           //否则退出循环
    }
}
 
 
//堆排序算法
void HeapSort(int array[],int length)
{
   int i;
   for(i=length/2-1;i>=0;--i)         //调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素 length/2-1是最后一个非叶节点，此处"/"为整除
                   HeapAdjust(array,i,length);
   
   for(i=length-1;i>0;--i)            //从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
    {
                   swap(array[i],array[0]);        //把第一个元素和当前的最后一个元素交换，
       
       HeapAdjust(array,0,i);         //不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
    }
}
 
 
int main()
{
   int i;
   int num[]={9,3,0,2,5,4,8,6,1,7};
 
   HeapSort(num,sizeof(num)/sizeof(int));
 
   for(i=0;i<sizeof(num)/sizeof(int);i++)
       cout<<num[i]<<"  ";
 
   return 0;
}

9. 二叉树排序

二叉树排序：将一个无序记录插入到建立的二叉树中，二叉树采用左低右高形式，然后用中序遍历二叉树排序。

#include<iostream>
using namespace std;
class node             //树节点类
{
public:
         intdata;          //数据
         node*parent;      //根指针
         node*left;        //左子树指针
         node*right;       //右子树指针
public:
         node(intnum):data(num),parent(NULL),left(NULL),right(NULL) {};     //构造函数，初始化数据成员
 
};
 
class tree            //树类
{
public:
         tree(intnum[],int len);                      //构造函数
         voidinsertNode(int data);                   //插入结点
         voidinOrderTree();                           //中序遍历
 
private:
         voidinsertNode(node *current,int data);     //插入结点的递归函数
         voidinOrderTree(node *current);             //中序遍历递归函数
 
         node*root;                                  //树根
};
 
tree::tree(int num[],int len)                   
{
         root=newnode(num[0]);              //构造函数中初始化树根
         for(int i=1;i<len;i++)              //循环插入树节点
                   insertNode(num[i]);
}
 
void tree::insertNode(int data)         //插入结点时，调用私有的插入函数
{
         if(root!=NULL)
                   insertNode(root,data);        
}
void tree::insertNode(node *current,intdata)
{
         if(data< current->data)
         {
                   if(current->left==    NULL)
                   {
                            current->left=new node(data);
                            current->left->parent=current;
                   }
                   else
                            insertNode(current->left,data);
        
         }
 
         elseif(data > current->data)
         {       
                   if(current->right== NULL)
                   {
                            current->right=new node(data);
                            current->right->parent=current;
                   }
                   else
                            insertNode(current->right,data);
        
         }
         return;
 
}
 
 
void tree::inOrderTree()     //中序遍历，调用私有中序遍历函数
{
         if(root==NULL)
                   return;
         inOrderTree(root);
 
}
void tree::inOrderTree(node *current)
{
         if(current!=NULL)
         {
                   inOrderTree(current->left);
                   cout<<current->data<<"  ";
                   inOrderTree(current->right);
         }
}
 
 
int main()
{
         inta[8]={5,3,7,2,4,6,8,1};
         treet(a,8);          //利用构造函数建立树
         t.inOrderTree();      //中序遍历
         return0;
}

10. 顺序查找

顺序查找（简单查找）：在一组无序数列中，查找特定某个数值，并返回其位置pos。

#include<iostream>
using namespace std;
#define MAX 20              //定义数组元素的个数
void randarray(int num[])   //随机产生数组元素并输出
{ 
   for(int i=0; i<MAX; i++) 
       cout<<(num[i]=rand()%100)<<"  "; 
} 
 
int find(int num[], int x)  //从数组开头依次查找，如果找到返回查找到的位置
{ 
   for(int i=0; i<MAX; i++) 
       if(x == num[i]) 
           return i; 
   return 0; 
} 
 
void main() 
{ 
   int x, pos, num[MAX]; 
   randarray(num); 
    
         cout<<endl<<"Enterfind num: ";
     
         cin>>x;
 
   pos=find(num, x);
 
   if(pos) 
      cout<<"OK! "<<x<<" is found in pos:"<<pos<<endl; 
   else 
            cout<<"Sorry!  "<<x<<" is not found inthe array"<<endl; 
 
}

11. 折半查找

折半查找(二分查找)：二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2]，则找到x，算法中止；如果x<a[n/2]，则只要在数组a的左半部分继续搜索x，如果x>a[n/2]，则只要在数组a的右半部搜索x。

#include<iostream>
using namespace std;
#define MAX 10                  //定义数组元素的个数
void randarray(int a[],int n)   //随机产生数组元素并输出
{ 
   for(int i=0; i<n; i++) 
       a[i]=rand()%100;
} 
 
void print(int a[], int n)      //数组输出函数
{
         for(int i=0;i<n;i++)
         {
                   cout<<a[i]<<"  ";
         }
         cout<<endl;
}
 
void sort(int a[], int low, int high)   //快速排序算法
{
         int i,j,pos;
         if(low< high)
         {
                   pos=a[low];
                   i=low;
                   j=high;
                   while(i<j)
                   {
                            while(i<j&& a[j]>pos)  j--;   //查找比pos小的数a[j]，往后放
                                a[i]=a[j];
                                                            
                            while(i<j&& a[i]<pos)  i++;    //查找比pos大的数a[i]，往前放
                                a[j]=a[i];
                   }
                   a[i]=pos;
                   sort(a,low,i-1);       //注意，这里是i-1
                   sort(a,i+1,high);
 
         }
 
}
 
int find(int a[], int n,int x)     //二分查找，如果找到返回查找到的位置
{
   int low=0,high=n;
   int mid;
         while(low<=high)
         {
                   mid=(low+high)/2;
                   if(a[mid]>x)
                         high=mid-1;
                   else if(a[mid]<x)
                         low=mid+1;
                   else 
	           {
			  return mid;   //这里有一个bug，如果找的数位于a[0],则找到后，mid=0，return 0后会返回没找到的假象
		          break;
	  <span style="white-space:pre">	</span>   }
		
         }
   return 0; 
} 
 
void main() 
{ 
   int x, pos, a[MAX]; 
 
   randarray(a,MAX); 
   print(a,MAX);
 
   sort(a,0,MAX-1);
   print(a,MAX);
        
   cout<<endl<<"Enterfind num: ";
   cin>>x;
 
   pos=find(a,MAX, x);
 
   if(pos) 
      cout<<"OK! "<<x<<" is found in pos after sorted: "<<pos<<endl; 
   else 
      cout<<"Sorry!  "<<x<<" is not found inthe array"<<endl; 
 
}