排序算法，KMP字符串处理

最新推荐文章于 2023-02-25 15:02:19 发布
最新推荐文章于 2023-02-25 15:02:19 发布
阅读量222 收藏
点赞数 1
文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44917429/article/details/127182517
版权

一 排序算法

1.插入排序 

 思想：假如有n个元素，我们从第二个元素开始，依次与前面的元素比较，如果小于，前面的元素往后挪，但注意的是往后挪的过程中会覆盖后面的元素，所以我们要定义一个变量保存后面的元素。

然后再把保存的变量赋给空出来的位置，外层循环注意是从第二个元素开始，内层循环注意的是外层循环的上一个元素开始比较。

附加数组宏函数打印

#define  LOG_CARRY   1

#ifdef LOG_CARRY//打印数组 
#define log_carry(BUFSIZ,len) \
    do  \
    { \
        for(int i = 0;i<len;i++) \
        { \
            printf("%4d ",BUFSIZ[i]); \
        } \
    }while(0); \
    printf("\n")
#endif
int  insert_sort( int* source,int length){
    if(!*source) return -1;
    for(int i = 1 ; i < length ;i++){
        int temp =source[i];
        int j=i-1;
        while (j >= 0 && temp < source[j])
        {
            source[j+1] = source[j];
            j--;
        }
        source[j+1] = temp;
    }
    return 1;

}

1.希尔排序

  思想：希尔排序是对直接插入排序的改进，建立在直接排序的基础上实现的。希尔排序只是增加了一个增量，增量是递减的我们可以每次都除以2来作为增量，注意最后的增量必须是1。说白了就是插入排序的一种改进为什们这么说呢，插入排序其实就是每一次都移动一个位置进行比较，而希排序就是把一个位置变成一个增量来比较排序的。

int shell_sort(int* source,int length){
    if(!*source) return -1;
    for(int key=length / 2;key > 0; key /= 2)
    {
        for(int i=key; i < length; i += key)
        {
            int temp = source[i];
            int j=i-key;
            while(j >= 0 && temp < source[j])
            {
                source[j+key] = source[j];
                j -=key;
            }
            source[j+key] = temp;
        }        
    }
    return 1;
}

}

3.快速排序   思想：快速排序分两步

a.找中轴（属于它的位置）

b.递归

首先我们要找中轴，找中轴比如说第一次把第一个元素作为要要找的元素，通过前后交换对比找到它应有的位置，就是让他左边的元素都小于它，右边的元素都大于他。这样第一趟完后数组基本上有序。

同样的方法，然后我们以中轴为中心对它左边的元素递归排序，同样对它右边的右的元素进行递归排序

 


int Find_axis(int* source, int left ,int right){
    int temp=source[left];
    while (left < right)
    {
        while(left < right && temp <= source[right]) right--;
        if(left <right)
        {
            source[left] = source[right];
        }
        while(left <right && temp >= source[left]) left++;
        if(left < right)
        {
            source[right] = source[left];
        }
           
    }
     source[left] = temp;
     return left;
    
}

int Quick_Sort(int* source, int left,int right){
    if(!*source)    return -1;
    if(left <right){
            int axis=Find_axis(source, left, right);//找中轴
            Quick_Sort(source,left,axis-1);//左边递归
            Quick_Sort(source,axis+1,right);//右边递归
    }
}


int main(){

    int Array[]={21,34,33,11,1,123,3,23,90,2};
    int length = sizeof(Array)/sizeof(Array[0]);
    log_carry(Array,length);    
#if 0
    insert_sort(Array,length);
    shell_sort(Array,length);
#else 
    Quick_Sort(Array,0,length-1);
#endif
    log_carry(Array,length);    
    return 0;
}

4.折半插入排序  思想：其实折半插入排序算法就是插入算法的改进。插入算法是，从第二个元素开始后面的每一个元素往前面插入，然而我们在插入的时候从开始插入的上一个元素开始每一个元素都要比较直到找到要插入的位置。但是前面的元素都是有顺序的，我们每一个元素都要比较。这样就降低了效率。他前面所有的元素都有序。那我们可不可以找一个元素先跟要插入的元素进行比较。如果小就在他的前面找插入的位置。反之如果大于就在他的后面找要插入对的位置。这就是折半折半插入排序的思想。所以只是改变了一下前面要插入的方式。是先找，在比较，在插入。而不是每一个都要比较。则那样去找那个要比较的元素。

我们定义一个left变量让他指向第一个元素，及left =0 .定义一个right指向要插入的前面的位置及，right=i-1;

我们在定义一个变量middle 每次它指向left 和right的中间的元素，所以这样就好办了。比较。如果小就在他的前面找插入的位置middle=right-1。反之如果大于就在他的后面找要插入对的位置middle=left+1；然后在移动进行插入后面的跟插入排序一样。

int In_Half_Sort(int *source,int length)
{
       if(!*source)    return -1;
       int tmp, left, right,middle;
       for (int i = 1; i < length; i++)
       {
               tmp = source[i];
               left = 0;
               right = i - 1;
               while (left <= right)
               {
                       middle = (left + right) / 2;
                       if (source[middle] > tmp)
                       {
                              right = middle - 1;
                       }
                       else
                       {
                              left = middle + 1;
                       }
               }
               for (int j = i-1; j >= right + 1; j--)
               {
                       source[j + 1] = source[j];
               }
               source[right + 1] = tmp;
       }
       return 1;
}

6.二路 归并排序 

思想：

二路归并排序是采用分而至之的思想，先把序列分成两部分，然后在采用递归的方法对它排序。递归就是对两边的序列依次分成两个序列然后在递归，这样依次下去，然后在对排序好的数组并归，最后对两个子序列合并就好了。这样就对这个数组排序好了。


int  Merge(int * Array, int low, int mid, int high)
{
       int i = low, j = mid + 1, p = 0;//对应Array数组的下标
       int * r = new int[high - low + 1];//申请另一个对应大小的数组来存放排好序的数据
       while (i <= mid && j <= high)
       {
              r[p++] = (Array[i] <= Array[j]) ? Array[i++] : Array[j++];
       }
       //最后左边子序列剩余的元素依次拷入到临时的数组中
       while (i <= mid)
              r[p++] = Array[i++];
       //最后右边子序列剩余的元素依次拷入到临时的数组中
       while (j <= high)
              r[p++] = Array[j++];
       for (p = 0, i = low; i <= high; p++, i++)
              Array[i] = r[p];//最后再把有序数据存入到原先的数组中，使得Array数组对应部分数据有序
       delete[] r;
       return 1;
}
//自顶向下(递归实现)
int MSort(int *Array, int low, int high)
{
       if (low<high)
       {
              int mid = (low + high) / 2;//取中间值
              MSort(Array, low, mid);//左边递归
              MSort(Array, mid + 1, high);//右边递归
              Merge(Array, low, mid, high);//最后合并两个序列
       }
    return 1;
}

7.冒泡排序 思想：每一趟两个相邻的元素进行比较，找出一个最大的放在后面，外层循环要注意的是，如果是n个元素，要n-1趟，内层循环注意的是n-1-i,因为每一趟找出一个最大的放在后面，后面的不用比较


int Bubbing(int *source,int length){

     for(int i=0;i<length-1;i++) {
        int key = -1;
        for(int j = 0; j < length - 1 - i; j++){
           if(source[j]>source[j+1])
            {
                int tmp=source[j];
                source[j]=source[j+1];
                source[j+1]=tmp;
                key = 1;
            }
        }
        if(key == -1) return 1;
    }
    return 1;
}

8.选择排序  思想：如果有n个元素，我们要固定n-1次，因为最后面一个元素不用比较。每一次固定一个元素后面的所有元素都要进行比较，如果小于就交换。外层循环注意的是固定n-1次，内层循环注意得是从固定元素的下一个元素开始比较

int Select(int* source ,int length){
    for(int i=0; i < length - 1; i++)
    {
        for(int j=i+1;j < length;j++)
        {
            if(source[i]>source[j])
            {
                int tmp=source[i];
                source[i]=source[j];
                source[j]=tmp;
             }
        }
    }
    return 1;
}

二，KMP 字符串处理

kmp 算法第一 先求出next的数组，next是求出最大公共元素单元的素组

 



// pattern 

// 

// abcabcd

// k = 0

// q = 1

void make_next(const char *pattern, int *next) {



    int q, k; //q 

    int m = strlen(pattern);



    next[0] = 0; // 

    for (q = 1,k = 0;q < m; q ++) {



        while (k > 0 && pattern[q] != pattern[k]) {

            k = next[k-1];

        }

        if (pattern[q] == pattern[k]) { // 如果前缀与后缀有相同的字符

            k ++;

        }

        next[q] = k;
    
    }

}



int kmp(const char *text, const char *pattern, int *next) {



    int n = strlen(text);

    int m = strlen(pattern);

    make_next(pattern, next);

    int i, q;

    for (i = 0, q = 0;i < n;i ++) { //i --> text, q --> pattern

#if 1

        while (q > 0 && pattern[q] != text[i]) {

            q = next[q-1];

        }

#endif 

        if (pattern[q] == text[i]) {

            q ++;

        }

        // q == m --->  

        if (q == m) {

            return i-q+1;

        }

    }

    return -1;

}

二. 代码部分

//Sort.c   文件

//Sort.c   文件
 
#include <stdio.h>
#include <stdlib.h>
#include "malloc.h"
#include "Prinf.h"
/*
 for（int i=1;i<n;i++）
{
        int tmp=a[i];
    int j=i-1;
    while(j>0&&tmp>a[j])
    {  a[j+1]=a[j];
        j--;    
     }
         a[j+1]=tmp;
}
*/

int  insert_sort( int* source,int length){
    if(!*source) return -1;
    for(int i = 1 ; i < length ;i++){
        int temp =source[i];
        int j=i-1;
        while (j >= 0 && temp < source[j])
        {
            source[j+1] = source[j];
            j--;
        }
        source[j+1] = temp;
    }
    return 1;

}

int shell_sort(int* source,int length){
    if(!*source) return -1;
    for(int key=length / 2;key > 0; key /= 2)
    {
        for(int i=key; i < length; i += key)
        {
            int temp = source[i];
            int j=i-key;
            while(j >= 0 && temp < source[j])
            {
                source[j+key] = source[j];
                j -=key;
            }
            source[j+key] = temp;
        }        
    }
    return 1;
}
#if 0

int find_axis(int *arr,int left,int right)
{
       int tmp = arr[left];
       while (left < right){
              while (arr[right] >= tmp&&left < right)   right --;
              if (left<right)
              {
                      arr[left] = arr[right];
              }
              
              while (arr[left]<=tmp&&left<right)    left++;
              if (left<right)
              {
                      arr[right] = arr[left];
              }
       }
       arr[left] = tmp;
       return left;
}
void quick_sort(int *arr, int left, int right)
{
       if (left<right)
       {
              int axis = find_axis(arr, left, right);//找中轴
              quick_sort(arr,left, axis-1);//左边递归
              quick_sort(arr, axis + 1, right);//右边递归
       }
}

#endif

int Find_axis(int* source, int left ,int right){
    int temp=source[left];
    while (left < right)
    {
        while(left < right && temp <= source[right]) right--;
        if(left <right)
        {
            source[left] = source[right];
        }
        while(left <right && temp >= source[left]) left++;
        if(left < right)
        {
            source[right] = source[left];
        }
           
    }
     source[left] = temp;
     return left;
    
}

int Quick_Sort(int* source, int left,int right){
    if(!*source)    return -1;
    if(left <right){
            int axis=Find_axis(source, left, right);//找中轴
            Quick_Sort(source,left,axis-1);//左边递归
            Quick_Sort(source,axis+1,right);//右边递归
    }
}

int In_Half_Sort(int *source,int length)
{
       if(!*source)    return -1;
       int tmp, left, right,middle;
       for (int i = 1; i < length; i++)
       {
               tmp = source[i];
               left = 0;
               right = i - 1;
               while (left <= right)
               {
                       middle = (left + right) / 2;
                       if (source[middle] > tmp)
                       {
                              right = middle - 1;
                       }
                       else
                       {
                              left = middle + 1;
                       }
               }
               for (int j = i-1; j >= right + 1; j--)
               {
                       source[j + 1] = source[j];
               }
               source[right + 1] = tmp;
       }
       return 1;
}
int Bubbing(int *source,int length){

     for(int i=0;i<length-1;i++) {
        int key = -1;
        for(int j = 0; j < length - 1 - i; j++){
           if(source[j]>source[j+1])
            {
                int tmp=source[j];
                source[j]=source[j+1];
                source[j+1]=tmp;
                key = 1;
            }
        }
        if(key == -1) return 1;
    }
    return 1;
}
int Select(int* source ,int length){
    for(int i=0; i < length - 1; i++)
    {
        for(int j=i+1;j < length;j++)
        {
            if(source[i]>source[j])
            {
                int tmp=source[i];
                source[i]=source[j];
                source[j]=tmp;
             }
        }
    }
    return 1;
}
int main(){

    int Array[]={21,34,33,11,1,123,3,23,90,2};
    int length = sizeof(Array)/sizeof(Array[0]);
    log_carry(Array,length);    
#if 0
    insert_sort(Array,length);
    shell_sort(Array,length);
    Quick_Sort(Array,0,length-1);
    In_Half_Sort(Array,length);
#else 
   Bubbing(Array,length);
    
#endif
    log_carry(Array,length);    
    return 0;
}

 // Print.h 文件

// Print.h 文件
#ifndef _PRINF_H_
#define _PRINF_H_

#define  LOG_CARRY   1

#ifdef LOG_CARRY//打印数组 空位补0
#define log_carry(BUFSIZ,len) \
    do  \
    { \
        for(int i = 0;i<len;i++) \
        { \
            printf("%4d ",BUFSIZ[i]); \
        } \
    }while(0); \
    printf("\n")
#endif
#endif //_PRINF_H_

 // Merge.cpp 文件

// Merge.cpp 文件

#include<iostream>
#include<stdlib.h>
using namespace std;

#include "Prinf.h"

int  Merge(int * Array, int low, int mid, int high)
{
       int i = low, j = mid + 1, p = 0;//对应Array数组的下标
       int * r = new int[high - low + 1];//申请另一个对应大小的数组来存放排好序的数据
       while (i <= mid && j <= high)
       {
              r[p++] = (Array[i] <= Array[j]) ? Array[i++] : Array[j++];
       }
       //最后左边子序列剩余的元素依次拷入到临时的数组中
       while (i <= mid)
              r[p++] = Array[i++];
       //最后右边子序列剩余的元素依次拷入到临时的数组中
       while (j <= high)
              r[p++] = Array[j++];
       for (p = 0, i = low; i <= high; p++, i++)
              Array[i] = r[p];//最后再把有序数据存入到原先的数组中，使得Array数组对应部分数据有序
       delete[] r;
       return 1;
}
//自顶向下(递归实现)
int MSort(int *Array, int low, int high)
{
       if (low<high)
       {
              int mid = (low + high) / 2;//取中间值
              MSort(Array, low, mid);//左边递归
              MSort(Array, mid + 1, high);//右边递归
              Merge(Array, low, mid, high);//最后合并两个序列
       }
    return 1;
}
int main(void)
{
       int Array[] = { 12,32,11,4,6,34,43,88,78,1 };
       int length=sizeof(Array)/sizeof(Array[0]);
       log_carry(Array,length);
       MSort(Array,0,length-1);
       log_carry(Array,length);
     
       return  0;
}

孤傲莫言
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ACM-字符串处理专练
01-13
在ACM竞赛中，字符串处理的题目往往需要结合其他数据结构和算法，如栈、队列、图、树、动态规划等，因此对程序员的综合能力有较高要求。通过这个“ACM-字符串处理专练”合集，你可以系统地学习并练习这些技巧，提高...
字符串相关算法.rar
09-22
本压缩包“字符串相关算法.rar”显然聚焦于字符串处理的算法，特别是针对面试场景中的热门问题。下面，我们将深入探讨这些算法的核心概念和常见应用场景。 1. **KMP（Knuth-Morris-Pratt）算法**：此算法用于在一个...
几大排序算法+ kmp 的理解和代码实现
刘小雨的博客
11-22 768
文章目录几种常见的排序（比较）冒泡排序 （百度百科）Code:选择排序 （百度百科）Code插入排序（百度百科）希尔排序（百度百科）Code快速排序（百度百科）Code归并排序（百度百科）Code堆排序（百度百科）Code:kmp算法在面试中的应用暴力做法Code优化做法 ： KMP 算法Code 几种常见的排序（比较） 冒泡排序 （百度百科） 这里就按照下面的两步模拟冒泡排序： 后面的类似，就不展示。 Code: #include <iostream> using namespace s
kmp算法和两种排序
最新发布
m0_73442004的博客
02-25 422
数据结构
排序与KMP
qq_37120588的博客
04-21 146
几种排序算法的复杂度 希尔排序 int shell_sort(int *data, int length) { if (!data || lenth <= 1) { return 0 } int gap = 0; int i = 0, j = 0; int temp; for (gap = length / 2;gap >= 1; gap /= 2) { for (i = gap;i < length;i ++) { temp = data[i];
最详细的KMP算法讲解
qq_31601743的博客
04-07 990
只要你学过数据结构与算法分析，相信你对KMP算法应该都不陌生吧？如果你没听过，不要紧，今天我们就来聊一聊这个算法。建议最好拿一张草稿纸，然后边看边理解，这样更有助于你对它的理解，更能理解它背后的精髓所在，相信你在理解完该算法之后，一定会大喊一声：妙啊！ KMP算法的诞生 KMP算法是三位大牛：Knuth、Morris和Pratt同时发现的，于是取了他们名字的首字母然后组合起来，就成了该算...
查找与排序-KMP算法
Birate的博客
12-16 180
C++常用的排序算法： 冒泡排序 void BubbleSort(int *a,int len) { int temp; for(int i=0; i<len; ++i){ for(int j=0; j<len-i-1; ++j){ if(a[j]>a[j+1]){ temp =a[j]; a[j] = a[j+1]; a[j+1] =
KMP.rar_KMP算法_字符串
09-24
KMP算法，全称为Knuth-Morris-Pratt算法，是一种在字符串中寻找子串的高效算法，由三位...理解并熟练掌握它们，将使你在处理字符串匹配和数据排序问题时游刃有余。无论是面试还是实际开发，这些技能都将助你一臂之力。
zifuchuan.rar_字符串处理
09-23
文件`zifuchuan`可能包含了各种字符串处理的实例或算法实现，比如字符串排序、字符串搜索算法（如KMP、Boyer-Moore等）或加密解密方法。学习和掌握这些内容对于提升编程能力、解决实际问题具有重要意义。 总的来说...
比KMP更快的字符串匹配算法——BM算法，排序算法数据结构 最快的排序算法
04-07
BM算法是比KMP更快的字符串匹配算法，它的理论时间复杂度也是O(n+m)，但实际上它的平均速度比KMP快很多。BM算法的原理是考虑O(nm)的暴力对比进进行字符串匹配，我们总是希望某次失配后能根据已有信息进行尽可能多的...
几大排序、查找算法、KMP
weixin_46694407的博客
07-04 108
八大排序
数据结构与算法------常见的排序与KMP
qq_34977671的博客
01-10 172
排序与KMP 1.插入排序 2.希尔排序 3.快速排序 4.KMP算法
KMP排序
dongyu_1989的博客
06-25 231
Implement strStr().Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.Example 1:Input: haystack = "hello", needle = "ll" Output: 2 Example 2:Input:...
KMP算法（研究总结，字符串）
dipinzhu4111的博客
07-17 5070
KMP算法（研究总结，字符串） 前段时间学习KMP算法，感觉有些复杂，不过好歹是弄懂啦，简单地记录一下，方便以后自己回忆。 引入 首先我们来看一个例子，现在有两个字符串A和B，问你在A中是否有B，有几个？为了方便叙述，我们先给定两个字符串的值 A="abcaabababaa" B="abab" 那么普通的匹配是怎么操作的呢？ 当然就是一位一位地比啦。（下面用蓝色表示已经匹配，黑色表示匹配...
【扩展kmp+优先队列(结构体)排序】匹配格式
It's the Climb
05-13 193
大致思路：耶这道我自己比较顺利地做出来了。为什么联想到要用拓展kmp呢？其实你看看，首先是有“头尾匹配”的，只不过花样多了点。这道题我是通过getnext()先把所有next值得到。需要注意“不重复”的题意要求，所以自己由此加了些限制条件：nextt[i]+1&lt;=i //中间部分与头不重复 n-q.top().len+1&gt;q.top().i+q.top().len-1 //...
查找与排序，KMP算法栈队列
weixin_45793120的博客
12-05 275
前言： 很多编程都离不开算法，那么作为linux服务器开发我们应该学哪些数据结构与算法呢？ 我觉得离不开以下这几个知识点 一：排序与查找 插入排序，快速排序，希尔排序，桶排序，归并排序 二：常用算法 布隆过滤器，字符串匹配KMP算法，回溯算法，贪心算法，推荐算法，深度优先，广度优先 三：常用数据结构 平衡二叉树，红黑树，B-树，kmp算法，栈/队列，布隆过滤器 四：常用的设计模式 单列模式，责任链...
排序算法（希尔排序、归并排序、快速排序、堆排序）、KMP算法
weixin_44416814的博客
05-31 1021
1、希尔排序 1.1排序原理 文字 图解 1.2代码实现 在这里插入代码片 int shell_sort(int* data, int length) { int gap = 0; int temp; int i = 0, j = 0; for (gap = length / 2; gap >= 1; gap /= 2) { //分组 对应步长 for (i = gap; i < length; i++) { temp = data[i]; //用临时变量存储
KMP字符排序
lflfreshlfl的专栏
03-28 469
// KMP(模式匹配）.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include using namespace std; int indexsimple(string str1,string str2)//方法一： 简单算法（朴素匹配法）， //对一般字符匹配时还可以，但对二进制匹配时时间很大，时间复杂度最
【KMP】kmp学习（个人知识点理解顺序）
寻找、发现、追求、获得———这就是狼的生活要素
04-10 865
学习kmp知识点顺序 1、字符串前缀和后缀的概念      如果给定的模式串是：“ABCDABD”，从左至右遍历整个模式串，其各个子串的前缀后缀分别如下表格所示：     也就是说，原模式串子串对应的各个前缀后缀的公共元素的最大长度表为（下简称《最大长度表》）： 2、kmp算法 　　一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是"AB
KMP算法—终于全部弄懂了
热门推荐
dark_cy的博客
03-22 43万+
详细讲解KMP算法，并对难点 k=next[k] 这条语句重点描述
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值