精华内容
下载资源
问答
  • _12级2011-11-06 回答#include #include #include int IsPalindrome(const char *cScr);void main(void){char cStr[21];while(1){gets(cStr);printf("%d\n",IsPalindrome(cStr));}}int IsPalindrome(const char *cS...

    _

    12级

    2011-11-06 回答

    #include

    #include

    #include

    int IsPalindrome(const char *cScr);

    void main(void)

    {

    char cStr[21];

    while(1)

    {

    gets(cStr);

    printf("%d\n",IsPalindrome(cStr));

    }

    }

    int IsPalindrome(const char *cScr)

    {

    int iLen = strlen(cScr);

    //预留数组首元素,栈顶从第二元素开始

    int top = 1;

    char *cMyStack = (char *)malloc( (iLen/2+1)*sizeof(char) );

    //定位对原始数组的检测索引初始位置

    cMyStack[0] = iLen/2;

    if ( 1 == iLen%2 )

    {

    ++cMyStack[0];

    }

    //将原始数组的一半元素入栈

    for ( top=1; top<=iLen/2; top++ )

    {

    cMyStack[top] = *(cScr+top-1);

    }

    //从栈顶开始依次匹配

    while ( *(cScr+cMyStack[0]) == cMyStack[--top] && cMyStack[0]++ < iLen ){}

    if ( 0 == top )

    {//是回文数

    free(cMyStack);

    return 1;

    }

    else

    {//不是回文数

    free(cMyStack);

    return 0;

    }

    }

    追问:

    用的数组,这是顺序存储的栈吧?我要的是链栈

    展开全文
  • 题目:给定一个链表的头结点是head,请判断该链表是否为回文结构例如:1->2->1,返回true1->2->2->1,返回true1->2->3,返回false分析:在链表问题中,时间复杂度一般都是O(n)的,所以链表的...

    题目:

    给定一个链表的头结点是head,请判断该链表是否为回文结构

    例如:

    1->2->1,返回true

    1->2->2->1,返回true

    1->2->3,返回false

    分析:

    在链表问题中,时间复杂度一般都是O(n)的,所以链表的优化一般在空间复杂度上的优化,在笔试和面试中,面对链表的问题,我们的策略是不一样的,如果是在笔试中,不用考虑优化的问题,应该赶紧将当前的题目过掉,不需要考虑空间如何优化的问题,但是在面试的过程中,就应该建立在时间复杂度为O(1),尽可能的去降低额外的空间复杂度。

    代码实现1(时间复杂度O(1),额外空间复杂度O(n)):

    package com.isea.brush;

    import java.util.Stack;

    /**

    * 判断一个链表是否是回文结构

    * 实现思路:

    * 使用一个辅助的栈结构,第一次遍历链表的时候将所有的元素都放入到栈中

    * 第二次遍历链表的时候,依次取出栈中的元素,然后对比元素的值是否相等。

    *

    */

    public class Palindrome {

    private class Node{

    private int data;

    private Node next;

    public Node(int data){

    this.data = data;

    }

    }

    public static boolean isPalindrome(Node head){

    Stack stack = new Stack();

    Node cur = head;

    while (cur != null){

    stack.push(cur);

    cur = cur.next;

    }

    while (head != null ){

    if (head.data != stack.pop().data) {

    return false;

    }

    head = head.next;

    }

    return true;

    }

    }

    代码实现二:(时间复杂度O(1),额外空间复杂度O(n))

    package com.isea.brush;

    import java.util.Stack;

    /**

    * 判断一个链表是否是回文结构

    * 实现思路:

    * 使用一个辅助的栈结构,再使用两指针 ,一个快指针,一个慢指针,当快指针走完整个链表的时候,慢指针刚好来到链表。

    * 中间的位置,此时从中间的位置开始将剩余链表中的元素放入到栈中;然后重头开始遍历链表,栈中的元素也依次弹出。

    * 如果栈为空的时候,还没有出现元素不相等的情况的话,那么该链表是回文结构。

    * 相比较于第一种方法,这样的方法能够节省一半的空间,但是额外空间复杂度还是O(n)的。

    * 这里值得注意的是:无论链表的长度是奇数还是偶数,都需要保证慢指针在后半部分的起点

    *

    */

    public class Palindrome {

    private class Node{

    private int data;

    private Node next;

    public Node(int data){

    this.data = data;

    }

    }

    public static boolean isPalindrome(Node head){

    if (head == null && head.next == null){

    return true;

    }

    Node right = head.next;

    Node cur = head;

    while(cur.next != null && cur.next.next != null){

    right = right.next;

    cur = cur.next.next;

    }

    Stack stack = new Stack();

    while(right != null){

    stack.push(right);

    right = right.next;

    }

    while(!stack.isEmpty()){

    if (head.data != stack.pop().data){

    return false;

    }

    head = head.next;

    }

    return true;

    }

    }

    代码实现三:(时间复杂度O(1),额外空间复杂度O(1))

    第三种实现方案,实现的思路是将后半部分的链表倒置,然后这个链表链表分别从两点开始遍历,对比元素是否是相等的,然后再将链表还原。

    ---------------------

    作者:isea_you

    来源:CSDN

    原文:https://blog.csdn.net/qq_31807385/article/details/86254979

    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 回文数:从左读到右与从右读到左一样的正整数。如12321,112211,99。利用队和栈来做这样的一个判断是非常容易理解的。我们运用的就是他们各自的性质。栈为先进后出 如输入 1 2 3 出3 2 1队尾先进先出 如输入 1 2 3 ...

    栈:一种只能从一端进出元素的具有先进后出性质的线性表。

    队:一种只能在一端进另一端出的具有先进先出性质的线性表。

    链栈与链队其储存方式是链式的。

    回文数:从左读到右与从右读到左一样的正整数。如12321,112211,99。

    利用队和栈来做这样的一个判断是非常容易理解的。

    我们运用的就是他们各自的性质。

    栈为先进后出 如输入 1 2 3 出3 2 1

    队尾先进先出 如输入 1 2 3 出1 2 3

    假若输入的是一个回文数 把该数分别入队入栈再输出 两个线性表的输出结果便是一样的。由此来判断一个数是否为回文数。

    这里我只是单用队与栈来实现这么一个功能所以写的ADT(抽象数据类型)只是我所需要的

    #pragma once//Stack.h 栈头文件

    #include

    #include

    typedef char elemtype;

    typedef struct stack {

    elemtype date;

    struct stack* former;

    }Stack,*PStack;

    typedef struct

    {

    PStack top;

    PStack base;

    int lenth;

    }linStack;

    int Initstack(linStack *p)//初始化

    {

    p->top = p->base = (PStack)malloc(sizeof(Stack));

    if (p->base == NULL) return 0;

    p->lenth = 0;

    p->base->former = NULL;

    return 1;

    }

    void Destroy(linStack* p) //销毁

    {

    while (p->top)

    {

    p->base = p->top->former;

    free(p->top);

    p->top = p->base;

    }

    }

    int Push(linStack* p, elemtype e) //入栈

    {

    PStack q;

    q= (PStack)malloc(sizeof(Stack));

    if (q == NULL) return 0;

    q->former = p->top;

    p->top->date = e;

    p->top = q;

    p->lenth++;

    return 1;

    }

    int Pop(linStack* p, elemtype* e) //出栈

    {

    Stack* q;

    if (p->base == p->top)

    {

    printf("栈为空!");

    return 0;

    }

    else

    {

    q = p->top->former;

    *e = q->date;

    free(p->top);

    p->top = q;

    p->lenth--;

    }

    }

    void PrintStack(linStack* p) //全栈输出

    {

    elemtype e;

    while (p->base != p->top)

    {

    Pop(p, &e);

    printf("%c->", e);

    }

    }

    我的栈节点是由date数据域和former指针域组成

    这里为什么要用前指针呢,是因为栈的输出性质是由栈顶输出,

    当栈顶项输出后便要循着指针往下走,所以得记录上一个元素的地址,从而队列由栈顶至栈底被连起来。

    typedef struct stack {

    elemtype date;

    struct stack* former;

    }Stack,*PStack;

    另一个是储存栈顶与栈底地址的结构体

    当你创建一个链栈的时候 栈就了有栈顶和栈底,这个结构体只储存这两个数据的地址,完事后的插入与删除只需要移动栈顶的位置就好了。

    typedef struct

    {

    PStack top;

    PStack base;

    int lenth;

    }linStack;

    链式队列的构建其实和链式栈真的差不多,对比着看代码就明了了。

    #pragma once//队头文件

    #include

    #include

    typedef char elemtype;

    typedef struct Queue {

    elemtype date;

    struct Queue* next;

    } Queue, *PQueue;

    typedef struct {

    PQueue rear;

    PQueue front;

    int lenth;

    }linQueue;

    int InitQueue(linQueue* Q) //初始化队列

    {

    Q->front = Q->rear = (PQueue)malloc(sizeof(Queue));

    if (Q->front == NULL) return 0;

    Q->rear->next = NULL;

    Q->lenth = 0;

    }

    void Destroy(linQueue* Q) //销毁队列

    {

    while (Q->front)

    {

    Q->rear = Q->front->next;

    free(Q->front);

    Q->front = Q->rear;

    }

    }

    int InsertQueue(linQueue* Q,elemtype e) //入队

    {

    PQueue p;

    p= (PQueue)malloc(sizeof(Queue));

    if(p==NULL)return 0;

    p->date=e;

    p->next = NULL;

    Q->rear->next = p;

    Q->rear = p;

    Q->lenth++;

    }

    void DeQueue(linQueue* Q, elemtype* e)//出队

    {

    PQueue p;

    if (Q->front->next)

    {

    p = Q->front->next;

    *e = p->date;

    free(Q->front);

    Q->front = p;

    Q->lenth--;

    }

    }

    void PrintQueue(linQueue* Q)//打印全队

    {

    elemtype e;

    while (Q->front->next)

    {

    DeQueue(Q, &e);

    printf("%c->", e);

    }

    //printf("\n");

    }

    #include

    #include

    #include"Stack.h"

    #include"Queue.h"

    int Palinnum(linStack* p, linQueue*q)//输入与判断

    {

    elemtype n=' ',e,e2;

    printf("please enter a string of number,let me judge palindormic number:");

    while (1)

    {

    scanf_s("%c",&n);

    if (n == '\n')break; //不让换行进栈和队

    Push(p, n);

    InsertQueue(q,n);

    }

    while (p->lenth != 0)

    {

    Pop(p, &e);

    DeQueue(q, &n);

    if (e != n)

    {

    printf("你有没有搞错,它不回文数列!\n");

    return 1;

    }

    }

    printf("没错就是他了,回文数列!\n");

    return 0;

    }

    int main()

    {

    int i = 3;

    elemtype n=0;

    linStack Sa;

    linQueue Qe;

    InitQueue(&Qe);

    Initstack(&Sa);

    Palinnum(&Sa,&Qe);

    system("pause");

    }

    由于要判断一个数是否为回文数,我把数字拆成一个个字符输入。

    最后要强调的是链式线性表的空间问题,在出队或出栈时一定记得释放空间,否则会导致空间碎片(即存在这样的空间但不能被使用)的出现。

    有问题、有想法,请留言讨论!

    展开全文
  • 回文java_回文 Java

    2021-02-12 10:02:38
    import java.util.Scanner;public class HWString {//判断字符串public static void hwReverse(String str){//方法一;将字符串倒置后逐一比较,StringBuffer sb =new StringBuffer(str);//System.out.println(sb);sb....

    package test.HWtest;

    import java.util.Scanner;

    public class HWString {//判断字符串

    public static void hwReverse(String str){//方法一;将字符串倒置后逐一比较,

    StringBuffer sb =new StringBuffer(str);

    //System.out.println(sb);

    sb.reverse();

    //System.out.println(sb);

    String newStr =new String(sb);

    if(str.equals(newStr)){

    System.out.println("1是回文");

    }

    else{

    System.out.println("1不是回文");

    }

    }

    public static void hwlength(String str){

    StringBuffer sb =new StringBuffer(str);

    //System.out.println(sb);

    sb.reverse();

    //System.out.println(sb);

    int count=0;

    for(int i=0;i

    //数组中有length属性,没有length()方法

    if(str.charAt(i)==sb.charAt(i)){

    count++;

    }

    }

    if(count == str.length()){

    System.out.println("2是回文");

    }

    else{

    System.out.println("2不是回文");

    }

    }

    public static void main(String[] args) { //方法二 将字符串倒置后创建新字符串直接比较,

    // TODO Auto-generated method stub

    Scanner sc =new Scanner(System.in);

    String str ="";

    str =sc.nextLine();

    hwReverse(str);

    hwlength(str);

    /*iamai

    1是回文

    2是回文*/}

    }

    展开全文
  • 展开全部 public static void main(String[] args) { System.out.print("input:");... } } 两种实现 看你喜欢哪种 忘了判断32313133353236313431303231363533e4b893e5b19e31333431346439字符长度100了......
  • 判断用户输入的字符串是否为回文回文是指正反拼写形式都是一样的词,譬如“racecar”。package com.commontest.pro1;/*** @author jiangfuqiang* @version 2016/6/24.* @see com.commontest.pro1*/public class ...
  • import java.nio.file.DirectoryStream.Filter;import javax.swing.JOptionPane;public class PalindromeIgnoreNonAlphanumeric {public static void main(String[] args) {// TODO Auto-generated method stubStrin...
  • java判断回文字符串几种简单的实现:1.将字符串倒置后逐一比较,实现如下:public class HuiWenTest {/*** @SERLIN*/public static void main(String[] args) {String str = "";System.out.println("请输入一个字符串")...
  • java 实现判断回文数字的实例代码发布于 2020-3-21|复制链接摘记: 前言:有这样一类数字,它们顺着看和倒着看是相同的数,例如:121、656、2332等,这样的数字就称为回文数字。编写一个Java程序,判断从键盘接收的...
  • java 判断回文

    2021-02-05 12:51:21
    StringBuilder 判断回文 左右比较字符判断回文 2. 考点解析 原始方法,len / 2 public boolean judge (String str) { // write code here int len = str.length(); for (int i = 0; i < len/2; i++) { if ...
  • java 如何判断回文数字 java 如何判断回文数字
  • 判断回文串-Java

    2021-03-21 10:10:41
    判断回文串-Java 验证回文串。编写程序,验证一个字符串是否为回文串:是否从前读它和从后读它都是一样的。例如,mom,dad是回文串。该程序接收用户输入的字符串,判断是否为回文串,然后将判断的结果输出。在验证...
  • 判断回文素数 java

    千次阅读 2018-10-31 16:32:23
    代码 private static void funtion ( int a ) { // TODO Auto-generated method stub final int NUMBER_OP = 10 ; ...判断回文代码 判断素数代码 动态增加数组代码
  • 第一种:面向过程:从字符串Str.length()/2开始向两端移动进行对比 ,boolean用来确定一个返回值判断是否回文Scanner input = new Scanner(System.in);try{System.out.println("Enter a three-digit interger:");...
  • Java判断回文

    2014-08-13 20:34:54
    正读和反读都相同的字符序列为“回文”,在Java判断回文是一道
  • 利用java如何实现判断回文数字发布时间:2020-11-11 16:49:59来源:亿速云阅读:96作者:Leah本篇文章给大家分享的是有关利用java如何实现判断回文数字,小编觉得挺实用的,因此分享给大家学习,希望大家阅读完这篇...
  • java判断回文

    2019-11-22 22:04:00
    回文:把相同的词汇或句子,...用Java判断一个句子是否是回文 public static boolean isHuiWen(String s1) { boolean flag = true; for (int i = 0; i < s1.length() / 2; i++) { if (s1.charAt(i) != s...
  • Java 判断回文字符串

    2021-04-01 14:39:02
    Java 判断回文字符串
  • 主要介绍了java判断回文数示例,需要的朋友可以参考下
  • 最终对比头尾指针时,偶数情况下只需要比较左边指针等于右边指针即可,奇数情况下相当于左边指针多走一步,需要判断右边指针不能等于空 /** * Definition for singly-linked list. * public class ListNode { *...
  • java判断是否是回文数下面介绍一种简单的判断方法,具体实现代码中已经说明了:import java.util.*;public class StringBufferDemo {public static void main(String[] args) {// TODO Auto-generated method stub//...
  • java判断回文程序

    2008-11-20 14:25:27
    java作业 用java实现判断回文程序免费下载
  • 解题思路:1. 先将链表一分为二,再... 将后半段链表反转,再依次比较即可// 判断是否为回文字符串public boolean isHuiwen(){Node dummy = findMid();dummy = reverse(dummy);while(dummy != null){if(dummy.data ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,667
精华内容 666
关键字:

判断回文java

java 订阅