C++数据结构的一些代码（线性表与串部分）

最新推荐文章于 2023-10-20 04:08:05 发布
最新推荐文章于 2023-10-20 04:08:05 发布
阅读量281 收藏
点赞数 1
文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/in_void/article/details/109295469
版权

一、线性表

1.链表

1.1 链表原地反转

#include <iostream>
using namespace std;

typedef struct node
{
    int data;
    struct node *next;
} NODE;

NODE *createlist( int n )
{
    NODE *head = NULL;
    
    while ( n-- )
    {
        NODE *p = new NODE;
        cin >> p->data;
        p->next = head;
        head = p;
    }

    return head;
}

void print( NODE *h )
{
    NODE *p;
    for (p = h; p;p=p->next)
    {
        cout << p->data;

        if( p->next != NULL)
            cout << ' ';
    }
    cout << endl;
}

void del( NODE *h)
{
    NODE *p;
    do
    {
        p = h;
        h = p->next;
        delete p;
    } while (h != NULL);
}

int main()
{
    int t;
    cin >> t;
    while ( t-- )
    {
        int n;
        cin >> n;

        NODE *head;
        head = createlist(n);
        print(head);
        del(head);
    }
    
    return 0;
}

1.2 单链表节点交换

#include <iostream>
using namespace std;

class Node
{
public:
    int data;
    Node *next;

    Node() { next = NULL; }
    Node(int x) : data(x) { next = NULL; }
};
class LinkList
{
public:
    Node *head;

    LinkList() { head = new Node(0); }
    void CreateList(int arr[], int n)
    {
        while (--n >= 0)
        {
            Node *temp = new Node(arr[n]);
            temp->next = head->next;
            head->next = temp;
            head->data++;
        }
    }
    bool Swap(int pos1, int pos2)
    {
        if (pos1 < 1 || pos1 > head->data ||
            pos2 < 1 || pos2 > head->data)
            return false;

        Node *p = head;
        while (--pos1)
        {
            p = p->next;
            pos2--;
        }
        Node *q = p;
        while (--pos2)
        {
            q = q->next;
        }

        //此时p为第一个需要交换节点的前驱，q为第二个需要交换节点的前驱
        //第一步，交换前驱
        Node *temp = p->next; //先用临时指针指向第一个需要交换节点
        p->next = q->next;    //p的next变为第二个节点
        q->next = temp;       //q的next变为第一个节点
        //第二步，交换后继
        temp = q->next->next;          //先用临时指针指向第一个需要交换节点的后继节点
        q->next->next = p->next->next; //第一个节点的next变为第二个节点的后继节点
        p->next->next = temp;          //第二个节点的后继节点变为第一个节点的后继节点
        return true;
    }
    void Show()
    {
        Node *p = head->next;
        while (p)
        {
            cout << p->data << ' ';
            p = p->next;
        }
        cout << endl;
    }
};

int main(int argc, char const *argv[])
{
    int n;
    cin >> n;
    int *arr = new int[n];
    for (int i = 0; i < n; i++)
        cin >> arr[i];

    LinkList ll;
    ll.CreateList(arr, n);
    ll.Show();

    delete[] arr;

    int t = 2;
    while (t--)
    {
        int pos1, pos2;
        cin >> pos1 >> pos2;
        if (ll.Swap(pos1, pos2))
            ll.Show();
        else
            cout << "error" << endl;
    }

    return 0;
}

1.3 双向链表祖玛

#include <iostream>
using namespace std;

class Node
{
public:
    char data;
    Node *front, *next;

    Node() { front = next = NULL; }
    Node(char ch) : data(ch) { front = next = NULL; }
};
class LinkList
{
public:
    Node *head;
    int length;

    LinkList() : length(0) { head = new Node('-'); }
    void CreateList(string str)
    {
        while (!str.empty())
        {
            Node *temp = new Node(str.back());
            str.pop_back();
            if (head->next)
                head->next->front = temp;
            temp->next = head->next;
            head->next = temp;
            temp->front = head;
            length++;
        }
    }
    void Insert(int pos, char ch)
    {
        Node *p = head;
        while (pos--)
        {
            p = p->next;
        }
        Node *temp = new Node(ch);
        temp->front = p;
        temp->next = p->next;
        if (p->next)
            p->next->front = temp;
        p->next = temp;
        length++;
        ZM(p->next);
    }
    void DeleteNode(Node *p, int n) //传入需要删除的第一个位置的前一个位置与删除个数
    {
        while (n--) //删除n个p->next节点
        {
            Node *temp = p->next;
            p->next = p->next->next;
            if (p->next)
                p->next->front = p;
            delete temp;
            length--;
        }

        //确保传入的不是头节点，而是其余有值的节点
        if (p->front != NULL)
            ZM(p);
        else if (p->next)
            ZM(p->next);
    }
    void ZM(Node *p)
    {
        int n = 1;   //记录需要删除的节点个数
        Node *q = p; //在p的前后移动寻找相同值
        Node *temp;  //指向需要开始删除节点的前一个节点的指针
        while (q->front)
        {
            if (q->front->data == p->data)
            {
                n++;
                q = q->front;
            }
            else
                break;
        }

        temp = q->front;

        q = p;
        while (q->next)
        {
            if (q->next->data == p->data)
            {
                n++;
                q = q->next;
            }
            else
                break;
        }

        if (n >= 3)
            DeleteNode(temp, n);
    }
    void Show()
    {
        Node *p = head->next;
        while (p)
        {
            cout << p->data;
            p = p->next;
        }
        if (length)
            cout << endl;
        else
            cout << head->data << endl;
    }
};

int main(int argc, char const *argv[])
{
    string str;
    cin >> str;

    LinkList ll;
    ll.CreateList(str);
    //ll.Show();

    int t;
    cin >> t;
    while (t--)
    {
        int pos;
        char ch;
        cin >> pos >> ch;
        ll.Insert(pos, ch);
        ll.Show();
    }

    return 0;
}

二、串

1.字符串翻转

这里收录两种简便方法

//方法一：利用algorithm头文件中的reverse函数翻转字符串
#include <algorithm>
string s1;
reverse(s1.begin(), s1.end());

//方法二：利用string自带的assign函数
string s1, s2;
s2.assign(s1.rbegin(), s1.rend());

2.KMP算法

#include <iostream>
using namespace std;

void SetNext(int *next, string pat)
{
    next[0] = 0;
    int len = 0;
    int i = 1;
    while (i < pat.length())
    {
        if (pat[len] == pat[i])
        {
            len++;
            next[i++] = len;
        }
        else
        {
            if (len > 0)
                len = next[len - 1]; //让len等于前一个的
            else
                next[i++] = len; //就是零
        }
    }
}

void MoveNext(int *next, int n)
{
    for (int i = n - 1; i > 0; i--)
        next[i] = next[i - 1];

    next[0] = -1;
}

void KMP(string text, string pattern)
{
    int *next;
    next = new int[pattern.length()];
    SetNext(next, pattern);
    MoveNext(next, pattern.length());

    int m = text.length();
    int n = pattern.length();
    int i = 0, j = 0;
    while (i < m)
    {
        if (j == n - 1 && text[i] == pattern[j])
        {
            cout << "FOUND at " << i - j << endl;
            j = next[j];
            i++;
        }

        if (text[i] == pattern[j])
        {
            i++;
            j++;
        }
        else
        {
            j = next[j];
            if (j == -1)
            {
                i++;
                j++;
            }
        }
    }

    delete[] next;
}

int main()
{
    string text;
    string pattern;

    cin >> text >> pattern;

    KMP(text, pattern);

    return 0;
}

3.最长重复子串

求串的最长重复子串长度（子串不重叠）。例如：abcaefabcabc的最长重复子串是串abca，长度为4。

#include <iostream>
using namespace std;

int FindMaxSubStr(string str)
{
    for (int len = str.length() / 2; len > 0; len--)
    {
        for (int i = 0; i < str.length() - len; i++)
        {
            string s1 = str.substr(i, len);
            string s2 = str.substr(i + len);
            if (s2.find(s1) != string::npos)
                return len;
        }
    }
    return -1;
}

int main(int argc, char const *argv[])
{
    int t;
    cin >> t;
    while (t--)
    {
        string str;
        cin >> str;
        cout << FindMaxSubStr(str) << endl;
    }
    return 0;
}

3.子串循环问题

给定一个字符串，求需要添加至少几个字符到字符串末尾才能使得整个字符串串由某一个不为本身的子串循环构成？
如"abca"，添加"bc"后构成"abcabc"，其由子串"abc"循环构成;也可以添加"abca"后构成"abcaabca"，其由子串"abca"循环构成，相比之下"bc"只有2个字符，添加的字符量最少。

#include <iostream>
using namespace std;

void SetNext(string p, int next[])
{
    next[0] = 0;
    int len = 0, i = 1;
    while (i < p.length())
    {
        if (p[i] == p[len])
        {
            len++;
            next[i++] = len;
        }
        else
        {
            if (len)
                len = next[len - 1];
            else //len=0
                next[i++] = len;
        }
    }
}

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        string str;
        cin >> str;
        int *next = new int[str.length()];
        SetNext(str, next);

        int len = str.length();
        int cirlen = len - next[len - 1];
        int add = cirlen - len % cirlen;
        if (cirlen != len && len % cirlen == 0)
            add = 0;

        cout << add << endl;

        delete[] next;
    }
}
in_void
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++ 数据结构线性表代码实现
10-17
本主题将深入探讨如何使用C++来实现线性表这一基本数据结构。 线性表是数据结构中最简单但又十分重要的类型，它是一组相同类型的元素按照特定顺序排列的集合。在C++中，线性表通常有两种常见实现：顺序表...
DS--字串循环问题
bjyh345的博客
11-15 1748
题目描述 给定一个字符串，求需要添加至少几个字符到字符串末尾才能使得整个字符串串由某一个不为本身的子串循环构成？ 如"abca"，添加"bc"后构成"abcabc"，其由子串"abc"循环构成;也可以添加"abca"后构成"abcaabca"，其由子串"abca"循环构成，相比之下"bc"只有2个字符，添加的字符量最少。 输入 第一行包括一个整数T(1 <= T <= 100)，代表测试组数 每组测试数据包括一行字符串，其长度范围为 [3, 104] 输出 对于每组测试数据 输出一个整
子串循环问题 (Ver. I)数据结构实验-串
Jenlibein的博客
10-20 270
也可以添加“abca”后构成“abcaabca”，其由子串“abca”循环构成，相比之下“bc”只有2个字符，添加的字符量最少。如果不能被整除，说明需要补上几个字母才行，需要补的字母个数为p_len-next[p_len]-(next[p_len]%(p_len-next[p_len]))个。如果p_len可以被p_len-next[p_len]整除(即p_len%(p_len-next[lenp_len)==0)，说明该字符串由循环字节组成。设该字符串为str，长度为p_len。先是字串循环的定律。
子串循环问题 (Ver. I)
笔记
10-19 587
KMP的子串循环定理
2021-08-10 字符串：子串问题——关于循环，递归，迭代，动归，记忆化，背包，减枝...
Can__er的博客
08-11 157
2021-08-09 字符串：子串拆分实现Trie单词拆分单词拆分Ⅱ 实现Trie 什么是trie？Trie，又称前缀树或字典树，是一棵有根树，其每个节点包含以下字段： 代码实现： class Trie: def __init__(self): self.children = [None] * 26 self.isEnd = False def insert(self, word: str) -> None: nownode =
[Daimayuan]循环子串（C++，字符串）
m0_74036684的博客
03-30 341
一道字符串问题 只需要证明最大的循环子串是符合条件的 在复制拼接后的字符串中寻找即可
数据结构线性表部分C++实现-包括一些习题代码
03-10
本压缩包中的资源主要关注C++实现的线性表，特别是与习题相关的代码实践。 1. **顺序表**： 顺序表是一种物理存储单元上连续存储的数据结构，其特点是通过数组来存储线性表中的元素。在C++中，可以使用动态数组来...
数据结构实验代码线性表的基本操作.rar
最新发布
05-01
在这个“数据结构实验代码线性表的基本操作.rar”压缩包中，包含的应该是实现线性表各种基本操作的源代码，这些操作对于理解和掌握数据结构至关重要。 首先，我们需要理解线性表的主要操作： 1. 初始化：创建一个...
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
C++ 数据结构线性表-数组实现
08-30
总的来说，C++中的线性表数组实现涉及到了动态内存分配、对象生命周期管理、数组操作以及基本数据结构的操作方法实现。这样的实现允许高效地访问和修改数组内的元素，但由于数组大小固定，插入和删除操作在表满或...
字符串：实现char *subStr(char *s,int n,int len)。
刘珂的博客
10-15 1021
#include<stdio.h> //char p[20];//设置为全局变量 char *subStr(char *s,int n,int len) { static char p[20];//或者设置为静态变量 int i,j=0; while(n--){ s++;//确定字符串的首位置 } for(i=n;i<n+len;i++){ p[j++]...
【New AKOJ】1052: 【回文数(二)】
cisordeng's space
05-22 488
1052: 【回文数(二)】 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 3  Solved: 1 原题链接 Description 若一个数（首位不为零）从左向右读与从右向左读都一样，我们就将其称之为回文数。  例如：给定一个10进制数56，将56加65（即把56从右向左读），得到121是一个回文
poj-2046-循环子串问题
Kang_TJU的博客
08-19 630
问题题目：[poj-2046]思路这个题目有个结论： 若s存在循环子串，当且仅当，len可以被len - prefix[len-1]整除。连接次数为len / len-prefix[len-1]. 充分性我不会证明，我就证明下必要性吧。 不放假设s = pattern * n; len = strlen(s); 显然prefix[ len - 1 ] = pattern*(n-1)，这个是最
ZZULIOJ:1169: 大整数（指针专题）
心之所向
12-15 1649
1169: 大整数（指针专题） 时间限制:1Sec内存限制:128 MB [状态] [讨论版] [提交] [命题人:admin] 题目描述 输入3个非负大整数，位数不超过100位，按从小到大的顺序输出这三个整数。要求定义并使用如下函数比较两个大整数的大小。 int cmp(char *a,char *b) { //若大整数a大于b，返回1； //若a小于b，返回-1； // 若a与b相等，返回0 } 输入 输入有3行，每行输入一个大整数，位数不超过100位，输入不含前导0。...
C语言函数题-取子串 (10分)
聪聪冲
12-29 3915
6-3取子串 (10分) 编写代码，完成从指定字符串中取指定子串的代码(不利用string.h类库)，给定的是子串起始位置和长度，返回一个新的子字符串的首地址。如果起始位置不妥，返回空串。如果后面的子串长度不足，则返回尽量长的子串。 操作接口说明： char* subStr(char *st,int pos,int len)； st是原字符串初址；pos是取子串的初始位置（pos>=0）；len是所取子串的最大长度(len>0)。要求创建并返回要求的子串首地址。 裁判测试程序样例： 在这里给
C. 字符串比较（指针与字符）
weixin_73868941的博客
05-14 625
编写一个函数比较两个字符串，参数是两个字符指针（要求显式定义，例如char *S, char *T)，比较字符串S和T的大小。如果S大于T，则返回1，如果S小于T则返回-1，如果S与T相等则返回0。2.在比较中，如果字符串S的字符大于字符串T的字符的数量超过小于的数量，则认为S大于T，如果等于则S等于T，如果小于则S小于T。例如S为aaccdd，T为eebbbb，每个位置比较得到S前两个字母都小于T，但后4个字母都大于T，最终认为S大于T。3.如果两个字符串长度不同，则更长的字符串为大。
指针函数的应用--输出一个字符中指定起始位置和长度的字符串
小白成长记
03-14 1912
题目： 编写一取某字符串子串的函数 char *substr(char *s,int startloc,int len),其中s为字符串，startloc为起始位置（0表示第一个字符的位置），len为子串的长度。要求返回值为求得的子串。 如：调用 substr(“12345678”,0,4),求得的子串为“1234” 以前的解法：先不考虑指针函数，用一种我们最容易想到的函数调用，代码如下： #in...
回文串问题
MrLuo8的博客
12-14 432
一个字符串，如果从左到右读和从右到左读是完全一样的，比如"aba"，我们称其为回文串。现在给你一个字符串，可在任意位置添加字符，求最少添加几个字符，才能使其变成一个回文串。 输入格式: 任意给定的一个字符串，其长度不超过1000. 输出格式: 能变成回文串所需添加的最少字符数。 输入样例: 在这里给出一组输入。例如： Ab3bd Abb 输出样例: 在这里给出相应的输出。例如： 2 1 #include<iostream> #include<cstring> using name
给定一个字符串，如果只能在后面添加字符，最少添加几个能让字符串整体都是回文串，并且把整个回文字符串输出。
z1171127310的博客
11-24 300
给定一个字符串，如果只能在后面添加字符，最少添加几个能让字符串整体都是回文串，并且把整个回文字符串输出。
C++实现数据结构：线性表操作示例
"数据结构(C++)描述 第二章 线性表" 在计算机科学中，数据结构是组织和管理数据的重要方式，它涉及到数据的逻辑结构、物理存储以及操作这些数据的算法。线性表是一种基本且常用的数据结构，其特点在于数据元素之间...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值