数据结构之回文字符串

1.什么是回文字符串？
回文是一种“从前向后读”和“从后向前读”都相同的字符串。

2.判断是否是回文字符串

//判断是否是回文字符串 回文字符串就是从前向后读和从后向前读是一样的
    public static boolean isHuiwenString(String str){
        boolean isHuiwen = true;
        for(int i = 0;i < str.length()/2;i++){
            //对称比较字符
            if(str.charAt(i) != str.charAt(str.length()-i-1)){
                isHuiwen = false;
            }
        }
        return isHuiwen;
    }

3.将非回文字符串变成回文字符串
思想：使用双链表存储最后返回的字符。从字符串的中间开始，对称比较字符，如果两个字符相等，直接将较小下标的字符追加到链表的头部，将较大下标的字符追加到链表的尾部。如果两个字符不相等，在头部先追加较大下标字符，后追加较小下标字符，在尾部先追加较大下标字符，后追加一个较小下标字符。
a.建立单链表结点类。

/**
 * 双链表结点
 * @date 2017-7-1
 * @author liufeifei
 * @description
 */
public class Node {

    public Object data;//值
    public Node next;//下一个结点
    public Node prev;//上一个结点

    public Node(Object data,Node next,Node prev){
        this.data = data;
        this.next = next;
        this.prev = prev;
    }

    public Node(){
        this(null,null,null);
    }
}

b.双链表

/**
 * @date 2017-7-2
 * @author liufeifei
 * @description 用于回文字符串的双链表
 */
public class SinglyList {

    public Node head;//头指针

    public SinglyList(Node head){
        this.head = head;
    }

    public SinglyList(){
        this(null);
    }

    //将结点插入在prev结点之后
    public Node insert(Node prev,Object data){
        Node next = prev.next;
        Node node =  new Node(data,next,prev);
        prev.next = node;
        if(next != null){
            next.prev = node;
        }
        return node;
    }

    //追加到链表最后
    public Node append(Object data){
        Node q = null;
        if(null == head.next){
            head.next = new Node(data,null,null);
        }else{
            Node p = this.head;
            while(p.next != null){
                p = p.next;
            }
            q = new Node(data,null,p);
            p.next = q;
        }
        return q;
    }

    //追加到链表头部
    public Node appendBefore(Object data){
        Node next = this.head.next;
        Node p = new Node(data,next,this.head);
        if(null != next){
            next.prev = p;
        }
        this.head.next = p;
        return p;
    }

    //输出链表元素
    public String toString(){
        StringBuffer sb = new StringBuffer("");
        Node p = this.head.next;
        while(null != p){
            sb.append(p.data);
            p = p.next;
        }
        return sb.toString();
    }

}

c.将非回文字符串变成回文字符串

public static String convertToHuiwenString(String str){
        //创建单链表，用单链表存放新的回文串
        Node head = new Node(null,null,null);
        SinglyList list = new SinglyList(head);
        int len = str.length();
        int i = len/2 - 1;//从中间开始判断
        while(i >= 0){
            if(str.charAt(i) != str.charAt(len-i-1)){
                if(i < len-i-1){
                    //将字符添加到链表中
                    list.appendBefore(str.charAt(len-i-1));
                    list.append(str.charAt(len-i-1));
                    list.appendBefore(str.charAt(i));
                    list.append(str.charAt(i));
                }else{
                    list.appendBefore(str.charAt(i));
                    list.append(str.charAt(i));
                    list.appendBefore(str.charAt(len-i-1));
                    list.append(str.charAt(len-i-1));
                }
            }else{
                if(i == len-i-1){
                    list.append(str.charAt(i));
                }else{
                    list.appendBefore(str.charAt(i));
                    list.append(str.charAt(len-i-1));
                }
            }
            i--;
        }
        return list.toString();
    }

d.测试

@Test
public void test(){
    String str1 = "abccba";
    String str2 = "abbdbd";
    System.out.println(isHuiwenString(str1));
    System.out.println(isHuiwenString(str2));

    String result1 = convertToHuiwenString(str2);
    System.out.println(result1);
    String result2 = convertToHuiwenString(str1);
    System.out.println(result2);
}

e.运行结果

true
false
adbbddbbda
abccba