【003】链表或字符串的【反转】【左旋转】

最新推荐文章于 2024-11-12 10:16:24 发布
最新推荐文章于 2024-11-12 10:16:24 发布
阅读量255 收藏 1
点赞数
文章标签： 数据结构与算法 c/c++ 面试
原文链接：http://www.cnblogs.com/codemylife/p/3781262.html
版权
反转链表/反转链表的某一段/左旋转链表/k长度反转/
反转字符串当中的单词/左旋转字符串
============================================
 
面试题16：反转链表
反转单链表，返回新链表的头指针。
 
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
ListNode *ReverseList(ListNode *pHead)
{
    ListNode *pReversedHead =  NULL;
    ListNode *cur = pHead;
    ListNode *prev =  NULL;
     while(cur !=  NULL)
    {
        ListNode *pNext = cur->next;

         //最后一个节点，让新的头指针指向他
         if(pNext ==  NULL)
        {
            pReversedHead = cur;
        }
         //头插法
        cur->next = prev;
         //更新头
        prev = cur;
        cur = pNext;
    }
     return pReversedHead;
}
 
 

Reverse Linked List II

反转链表的某一段[m, n]。1 ≤   m  ≤   n  ≤ length of list
 
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution
{
public:
    ListNode *reverseBetween(ListNode *head,  int m,  int n)
    {
         /*dummy结点为了统一prev操作*/
        ListNode dummy(- 1);
        dummy.next = head;

        ListNode *prev = &dummy;
         for( int i =  0; i < m -  1; ++i)
        {
            prev = prev->next;
        }
        ListNode * const subHead = prev;
         /*prev指向最终"m...n子字符串"的末尾结点*/
        prev = subHead->next;
         /*subhead...prev&& cur...n*/
         /* cur指向当前要头插的结点，
         * 注意保持prev->next和后面还未处理的结点的连通性
         */
        ListNode *cur = prev->next;
         for( int i = m; i < n; ++i)
        {
             //要保证这个末尾结点和m...n后面的结点不断开
            prev->next = cur->next;
             /*头插法*/
            cur->next = subHead->next;
            subHead->next = cur;
            cur = prev->next;
        }
         return dummy.next;
    }
};
 
 
 


Rotate List

左旋转链表

Given a list, rotate the list to the right by k places, where k is non-negative.

For example:
Given 1->2->3->4->5->NULL and k = 2,
return 4->5->1->2->3->NULL.

 
先遍历一遍，得出链表长度 len，注意 k 可能大于 len，因此令 k% = len。将尾节点 next 指针
指向首节点，形成一个环，接着往后跑 len k 步，从这里断开，就是要求的结果了。
 
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution
{
public:
    ListNode *rotateRight(ListNode *head,  int k)
    {
         if(head ==  NULL || k ==  0)
        {
             return head;
        }
         /*到这里说明至少有一个结点*/
         int len =  1;
        ListNode *p = head;
         while(p->next)
        {
            len++;
            p = p->next;
        }
         /*算出移动步数*/
        k = len - k % len;

        p->next = head;
         for( int step =  0; step < k; step++)
        {
            p = p->next;
        }
         /*更新head*/
        head = p->next;
         /*尾结点指针指向空*/
        p->next =  NULL;
         return head;
    }
};
 
 

Reverse Nodes in k-Group

 Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,
Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

 

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution
{
public:
    ListNode *reverseKGroup(ListNode *head,  int k)
    {
         if(head ==  NULL || head->next ==  NULL || k <  2)
        {
             return head;
        }
        ListNode dummy(- 1);
        dummy.next = head;
         for(ListNode *prev = &dummy, *end = head; end !=  NULL; end = prev->next)
        {
             /*移动一步表示两个结点的范围，移动三步表示三个结点的返回*/
             for( int i =  1; i < k && end !=  NULL; i++)
            {
                end = end->next;
            }
             /*如果end为空说明不满足k个了直接break不做reverse啦*/
             if(end ==  NULL)
            {
                 break;
            }
             /*用返回值更新prev，然后在用prev更新end*/
            prev = reverse(prev, prev->next, end);
        }
         return dummy.next;
    }

    ListNode *reverse(ListNode *prev, ListNode *begin, ListNode *end)
    {
         /*保存[begin, end]后面连接的指针*/
        ListNode *end_next = end->next;
         /*p指向的是头插法当前的头*/
        ListNode *p = begin;
         /*cur指向当前要处理的节点*/
        ListNode *cur = p->next;
         /*pNext指向下一次迭代要处理的节点*/
        ListNode *pNext = cur->next;
         while(cur != end_next)
        {
            cur->next = p;
            p = cur;
            cur = pNext;
            pNext = (pNext ? pNext->next :  NULL);
        }
        begin->next = end_next;
        prev->next = end;
         return begin;
    }
};
 
 
 

Reverse Words in a String

反转字符串当中的单词，
前导和后导空格都去掉，中间多余的空格保留一个，可以认为任何非空的字符构成一个单词。
 
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
class Solution
{
public:
     /*翻转*/
     void reverse( char *pBegin,  char *pEnd)
    {
         while (pBegin < pEnd)
        {
             char tmp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = tmp;
            pBegin ++;
            pEnd --;
        }
    }

     /*去除前导空格后导空格以及中间多余的空格*/
     void removeDuplicates(string &s)
    {
         int index =  0;
         int num = s.length();

         /*忽略前面和后面的空格*/
         while (s[index] !=  '\0' && s[index] ==  ' ')
        {
            index ++;
        }
         int rIndex = num -  1;
         while (s[rIndex] ==  ' ')
        {
            s[rIndex] =  '\0';
            rIndex --;
        }

         int cur =  0;
         /*去除中间多余的空格*/
         while(index < num)
        {
             if(s[index] ==  '\0')
            {
                 break;
            }
             if (s[index] ==  ' ')
            {
                 /*保留中间的第一个空格*/
                s[cur] = s[index];
                cur++;
                 /*忽略中间的其他空格*/
                 while (s[index] !=  '\0' && s[index] ==  ' ')
                {
                    index ++;
                }
            }
             else
            {
                s[cur] = s[index];
                cur++;
                index++;
            }
        }
         /*保证后面都是'\0'*/
         while (cur < num)
        {
            s[cur] =  '\0';
            cur++;
        }
         /*计算去除多余空格后字符串的长度*/
        num =  0;
         while (s[num] !=  '\0')
        {
            num ++;
        }
        s.resize(num);
         return ;
    }

     void reverseWords(string &s)
    {
         if(s.length() ==  0)
        {
             return ;
        }

         /*去除多余空格*/
        removeDuplicates(s);
         char *pBegin = &s[ 0], *pEnd = &s[ 0];
         while (*pEnd !=  '\0')
        {
            pEnd ++;
        }
        --pEnd;
         /*整体翻转*/
        reverse(pBegin, pEnd);
        pBegin = pEnd = &s[ 0];
         while (*pBegin !=  '\0')
        {
             if (*pBegin ==  ' ')
            {
                pBegin ++;
                pEnd ++;
            }
             else  if (*pEnd ==  ' ' || *pEnd ==  '\0')
            {
                 /*局部翻转*/
                reverse(pBegin, --pEnd);
                pBegin = ++pEnd;
            }
             else
            {
                pEnd++;
            }
        }
    }

};
 
 
 
面试题042：翻转单词顺序VS左旋转字符串
题目一：
    输入一个英文句子，反转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。
    例如输入字符串“I am a student.”,则输出“student. a am I”。
思路一：
    反转字符串的顺序，这样子每个单词的顺序也反转了，然后再次反转每个单词，这样子就做到了题目要求。
——关键是实现一个函数以反转字符串中的一段。
 
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
#include <iostream>

using  namespace std;

void Reverse( char *pBegin,  char *pEnd)
{
     if (pBegin ==  NULL || pEnd ==  NULL)
    {
         return ;
    }
     while(pBegin < pEnd)
    {
         char temp = *pBegin;
        *pBegin = *pEnd;
        *pEnd = temp;

        pBegin ++;
        pEnd --;
    }
}

char *ReverseSentence( char *pData)
{
     if(pData ==  NULL)
         return  NULL;

     char *pBegin = pData;

     char *pEnd = pData;
     while(*pEnd !=  '\0')
        pEnd ++;
    pEnd--;

     // 翻转整个句子
    Reverse(pBegin, pEnd);

     // 翻转句子中的每个单词
    pBegin = pEnd = pData;
     while(*pBegin !=  '\0')
    {
         if(*pBegin ==  ' ')
        {
            pBegin ++;
            pEnd ++;
        }
         else  if(*pEnd ==  ' ' || *pEnd ==  '\0')
        {
            Reverse(pBegin, --pEnd);
            pBegin = ++pEnd;
        }
         else
        {
            pEnd ++;
        }
    }

     return pData;
}

int main()
{
     char str[] =  "I am a student.";

    ReverseSentence(str);
    printf( "%s\n", str);

     return  0;
}
 
 
题目二：
    字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的末尾。请定义一个函数实现字符串左旋转操作的功能。
比如输入字符串“abcdefg”和数字2，该函数将返回左旋转2位得到的结果“cdefgab”。
 
思路一：
    前两个字符ab为一部分，后面五个字符为一部分cdefg，然后两次反转，即可达到目的。
 
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
#include <iostream>
#include <string>
using  namespace std;


void Reverse( char *pBegin,  char *pEnd)
{
     if (pBegin ==  NULL || pEnd ==  NULL)
    {
         return ;
    }
     while(pBegin < pEnd)
    {
         char temp = *pBegin;
        *pBegin = *pEnd;
        *pEnd = temp;

        pBegin ++;
        pEnd --;
    }
}

char *LeftRotateString( char *pStr,  int n)
{
     if (pStr !=  NULL)
    {
         int nLength =  static_cast< int>(strlen(pStr));
         if (nLength >  0 && n >  0 && n < nLength)
        {
             char *pFirstStart = pStr;
             char *pFirstEnd = pStr + n -  1;
             char *pSecondStart = pStr + n;
             char *pSecondEnd = pStr + nLength -  1;

            Reverse(pFirstStart, pFirstEnd);
            Reverse(pSecondStart, pSecondEnd);
            Reverse(pFirstStart, pSecondEnd);
        }
    }
     return pStr;
}

int main()
{
     char str[] =  "abcdefg";
    LeftRotateString(str,  2);
    printf( "%s\n", str);

     return  0;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

转载于:https://www.cnblogs.com/codemylife/p/3781262.html

A201241302241
关注
【旋转字符串系列】
qq_36417014的博客
07-11 163
1、链表翻转。给出一个链表和一个数k，比如，链表为1→2→3→4→5→6，k=2，则翻转后2→1→6→5→4→3，若k=3，翻转后3→2→1→6→5→4，若k=4，翻转后4→3→2→1→6→5，用程序实现。 #include<iostream> using namespace std; struct List { int num; List* next; }; //创建链...
ACWing第十四次课-左旋转字符串，把字符串转换成整数，反转链表，两个链表的第一个公共节点，删除链表当中重复节点，第八章C++STL
VAN
05-25 113
8. 左旋转字符串 题目 提交记录 讨论 题解 视频讲解 字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。 请定义一个函数实现字符串左旋转操作的功能。 比如输入字符串"abcdefg"和数字 2，该函数将返回左旋转 2 位得到的结果"cdefgab"。 注意： 数据保证 n 小于等于输入字符串的长度。 数据范围 输入字符串长度 [0,1000]。 样例 输入：“abcdefg” , n=2 输出：“cdefgab” class Solution { public: string le
字符串反转和反转链表
SmallNancy的博客
10-07 372
1、字符串反转 public class Main { public static void main(String[] args) { String s = "hello"; String res = ""; for (int i = 0; i < s.length();i++) { res = s.charA...
【面试题】单链表逆转、字符串按单词逆转
weixin_33682719的博客
03-30 531
问题一：单链表反转，提供空间复杂度O(1)，时间复杂度O(n)， 解法：利用三个指针遍历一遍，下面用图来阐释。 图1，初始情况，给定head指针，链表末尾指向NULL。 图2，创建三个节点指针，分别为p指向head，q指向p->next，r指向q->next。并且将p指向NULL，因为逆转链表之后，最开始的头结点将变成尾节点，head->next = NULL ...
反转字符串 + 反转链表
qq_43413774的博客
03-22 296
链表 什么是链表，链表是一种通过指针串联在一起的线下结构，每个节点是由两部分组成的，一个是数据域，一个是指针域，指针域是存放下一个节点的指针，最后一个节点的指针域指向null。 单链表 双链表 双链表和单链表唯一的不同点就是，双链表有俩个指针域，一个指向上一个节点，一个指向下一个节点，既可以向前查，也可以向后查。 还有循环链表就是链表里面有个环，很容易想象的，就不在这里图示了。 链表的存储结构 链表是通过指针域的指针链接在内存的各个节点，所以链表在内存中不是连续分别的，而是散乱分布到内存的某个地址上，分
链表反转
热门推荐
xu491361421xiao的博客
08-03 1万+
转载：https://blog.csdn.net/fx677588/article/details/72357389  因本人日常是java开发，所以翻译成java语言代码，略有改动   链表的翻转是程序员面试中出现频度最高的问题之一，常见的解决方法分为递归和迭代两种。最近在复习的时候，发现网上的资料都只告诉了怎么做，但是根本没有好好介绍两种方法的实现过程与原理。所以我觉得有必要好好的整理一...
笔试算法题（13）：反转链表 & 左旋转字符串
weixin_34342578的博客
06-30 290
出题：反转链表（递归和非递归解法）； 分析：有递归跟非递归实现，注意对原始链表头节点的处理，因为其他节点都指向下一个节点，其需要指向NULL； 解题： 1 struct Node { 2 int v; 3 Node *next; 4 }; 5 Node* NonRecursiveListReverse(Node *head) { 6 ...
旋转字符串以及单词反转
小小小的骆驼的前端技术博客
08-05 879
旋转字符串以及单词反转
代码随想录算法训练营第九天 字符串| 反转单词、右旋字符串、字符串总结
2301_77580973的博客
10-24 892
代码随想录其实我们已经学习了十天的字符串了，从字符串的定义到库函数的使用原则，从各种反转到KMP算法，相信大家应该对字符串有比较深刻的认识了。那么这次我们来做一个总结。字符串是若干字符组成的有限序列，也可以理解为是一个字符数组，但是很多语言对字符串做了特殊的规定，接下来我来说一说C/C++中的字符串。在C语言中，把一个字符串存入一个数组时，也把结束符 '\0'存入数组，并以此作为该字符串是否结束的标志。a[i]!= '\0';i++) {
算法学习Js语言旋转字符串
MeiLuan_yahoho的博客
01-30 314
分析与解法 解法一：暴力移位法 针对长度为n的字符串来说，假设需要移动m个字符到字符串的尾部，那么总共需要 m*n 次操作，同时设立一个变量保存第一个字符，如此，时间复杂度为O(m * n)，空间复杂度为O(1)，空间复杂度符合题目要求，但时间复杂度不符合，所以，我们得需要寻找其他更好的办法来降低时间复杂度。 解法二：三步反转法 将一个字符串分成X和Y两个部分，在每部分字符串上定义反转操作，如XT...
day7反转链表&反转链表II替换空格&反转字符串里的单词&左旋转字符串
weixin_51558481的博客
09-28 2645
操作字符串的算法题
单链表操作之反转单链表
John的博客
06-08 3055
***单链表操作之反转单链表*** //反转单链表，只能遍历一遍链表 // 定义的结点结构体和头指针结构体： typedef int DataType; typedef struct LinkNode { DataType data; struct LinkNode* next; }LinkNode,*pLinkNode;//结点结构体 typed
数据结构与算法——将单链表向右旋转k个位置
beilizhang的博客
07-26 800
如何将单链表向右旋转k个位置 给定1->2->3->4->5->6->7，k=3，那么旋转后的链表变为5->6->7->1->2->3->4 主要思路： 首先找到链表倒数第k+1个结点的尾结点slow和尾结点fast 把链表断开为两个子链表，其中后半部分子链表结点的个数为k 使原链表的尾结点指向链表的第一个结点 使链表的头结点指向原链表倒数第k个结点 这种方法只需要对链表进行一次遍历，因此时间复杂度为O(n)，空间复杂度为O(1)
算法（反转）：字符串 链表 反转
小羊羊
07-23 521
1.字符串反转： /** 给定一个字符串 str 请假字符串反转输出 示例: 给定 str = @"I am a programmer" 返回 str = @"remmargorp a ma I" */ + (void)stringReverse{ char myStr[] = "I love my country"; char *left ...
字符串反转的两种方法
BLSpan的博客
07-09 3223
/* 名称：字符串反转的两种方法 说明：此处用了两种方法进行前后对称字符串互换，常规的方法是第一个字符和最后 一个字符互换，第二个字符和倒数第二个字符互换； 第二个方法是利用函数递归， 即str为abcde，每次递归使之处理的str为bcde、cde、de、e，然后e、ed、edc、edcb edcba，达到反转的效果。 虽然这个例子中递归
动态规划习题其七【力扣】【算法学习day.29】
2301_79232523的博客
11-11 293
##我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！！
OJ08题：876. 链表的中间结点
最新发布
吴先生的博客
11-12 298
过程简单，这题主要在于我们怎样让循环停下来，我们来分析一下：我们先来看一下有奇数个节点：我们可以看到，当slow指向中间节点的时候fast->next = NULL,这时候循环结束有偶数个节点：这个时候当slow指向中间节点的时候，fast指向NULL；对这两种情况分析我们知道，当fast指向NULL或fast->next=NULL时，循环结束，此时，slow指向的节点为中间节点，
栈的实现（数组实现+链表实现）+括号匹配
一个小孩博客
11-08 694
在计算机科学中，栈是一种基础且重要的数据结构，它以“后进先出”（LIFO）的方式存储和管理数据。栈的概念在许多算法和程序设计中扮演着关键角色，从函数调用的堆栈管理到浏览器的前进后退功能，栈的应用无处不在。本文将带你深入了解栈的概念、操作、实现方式以及它的实际应用。// 定义一个类型别名 StackType，等同于 int 类型。// 指向一个整型数组的指针，用于存储栈中的元素。int size;// 栈中当前元素的数量。// 栈的最大容量。} ST;// 定义一个结构体类型 ST，代表栈。
[FBCTF 2019]rceservice 详细题解
weixin_73904941的博客
11-09 1376
如果在字符串最末尾的 } 之前加上一个%0a {%0a"cmd":"/bin/cat /home/rceservice/flag"%0a}此时 \x00-\x1F 匹配了第一个%0a 但是最后的.* 不能匹配换行符,也匹配不到换行后的 }所以不能遍历完整字符串,返回值为空,完成正则绕过//而在单行模式下$ 似乎会忽略在句尾的 %0a 所以如果%0a 添加在字符串最后的} 的后面的话依然会被匹配构造?
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值