算法导论笔记 | 易学教程

插入算法

将所需排序的数一个个通过循环找到相应位置插入已排序好的数列中
*时间复杂度：*O（n^2）

#include<stdlib.h>
#include<stdio.h>
int main()
{
 int i,j,a,key;
 scanf("%d",&a);
 int A[100];
 for (i=0;i<a;i++)
 scanf("%d",&A[i+1]);
 for (j=2;j<=a;j++)
 {
  key=A[j];
  i=j-1;
  while(i>0&&A[i]>key)
  {
   A[i+1]=A[i];
   i=i-1;
   A[i+1]=key;
  }
 }
 return 0;
}

归并排序

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表。
时间复杂度：O（nlog（n））

#include<stdio.h>
#include<math.h>
#include<string.h>
void MERGE(int*A,int left,int mid,int right)
{
    int n1=mid-left+1;
    int n2=right-mid;
    int L[100],R[100];
    int i,j,k;
    for(i=1;i<=n1;i++)
        L[i]=A[left+i-1];
    for (j=1;j<=n2;j++)
        R[j]=A[mid+j];
    L[n1+1]=100000;
    R[n2+1]=100000;
    i=1;
    j=1;
    for (k=left;k<=right;k++)
    {
        if (L[i]<=R[j])
        {
            A[k]=L[i];
            i++;
        }
        else{
            A[k]=R[j];
            j++;
        }
    }
    return;
}
void MERGE_SORT(int*A,int left,int right)
{
    int mid;
    if(left<right)
     {mid=(left+right)/2;
    MERGE_SORT(A,left,mid);
    MERGE_SORT(A,mid+1,right);
    MERGE(A,left,mid,right);}
    return;
}
int main()
{
    int n,i,left,right;
    int A[100];
    scanf("%d",&n);
    for(i=1;i<=n;i++)
    {
        scanf("%d",&A[i]);
    }
    printf("请输入要排序左右");
    scanf("%d%d",&left,&right);
    MERGE_SORT(A,left,right);
    for(i=1;i<=n;i++)
        printf("%d ",A[i]);
    return 0;
}

分治算法

分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。
其实归并排序也是用到分治算法的思想，接下来的样例是求解一组数列中最大子数列，采用二分思想，分三类情况讨论：1：最大子数列在二分后的左边。2最大子数列在二分后的右边。3最大子数列在二分后跨越中介（由左半边一部分和右半边一部分构成）
时间复杂度：O（nlog（n））

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,n,low,high;
    int A[100];
    scanf("%d",&n);
    for (i=1;i<=n;i++)
        scanf("%d",&A[i]);
    printf("请输入范围low，high\n");
    scanf("%d%d",&low,&high);
    printf("%d",find_max_subarray(A,low,high));
    return 0;
}
int find_crossing_max_subarray(int *A,int low,int mid,int high)
{
    int left=-1000000;
    int sum=0;
    int i,j;
    for (i=mid;i>=low;i--)
    {
        sum+=A[i];
        if (sum>left)
        {
            left=sum;
        }
    }
        int right=-1000000;
        sum=0;
        for(j=mid+1;j<=high;j++)
        {
            sum+=A[j];
            if (sum>right)
                right=sum;
        }
        return (right+left);



}
int find_max_subarray(int *A,int low,int high)
{
    int mid;
    if (high==low)
        return A[low];
    else  mid=(low+high)/2;
    int leftans=find_max_subarray(A,low,mid);
    int rightans=find_max_subarray(A,mid+1,high);
    int crossans=find_crossing_max_subarray(A,low,mid,high);
    if (leftans>=rightans&&leftans>=crossans)
        return leftans;
    else if(rightans>=leftans&&rightans>=crossans)
        return rightans;
    else return crossans;

}

堆排序

此代码有C++语言实现
堆这种数据结构首先是一种特殊的完全二叉树，且满足子节点值大于父节点点值的大或小。然后此堆排序使用最大堆，是先通过将数组创建为一个二叉树，保证每一个节点元素要比他的子节点元素要大，构成一个大顶堆。则该纾解点的根节点元素是所有元素中最大的元素。只要按照把根节点一次提取出来即可。
*时间复杂度：*O（nlog（n））

#include<iostream>

using namespace std;
void heapify(int A[],int n,int i)
{
	int largest=i;
	int l=2*i;
	int r=2*i+1;
	if (l<n&&A[l]>A[i])
	 largest=l;
	if (r<n&&A[r]>A[i])
      largest=r;
    if (largest!=i)
       {
           swap(A[i],A[largest]);
           heapify(A,n,largest);
       }

}
void heapsort (int A[],int n)
{
    for(int i=n/2;i>0;i--)
        heapify(A,n,i);
    for (int i=n;i>1;i--)
    {
        swap (A[1],A[i]);
        heapify(A,i,1);
    }
}
void printA(int A[],int n)
{
    for(int i=n;i>0;i--)
        cout<<A[i]<<" ";
    cout<<endl;
}
int main()
{
    int n;
    int A[20];
    cin>>n;
    for (int i=1;i<=n;i++)
        cin>>A[i];
        heapsort(A,n);
        printA(A,n);
        return 0;
}

后续请看更新

来源：CSDN

作者：infinitysjy

链接：https://blog.csdn.net/infinitysjy/article/details/104590686

标签

算法导论