链表逆置算法

顺序表的逆置算法

import java.util.Arrays;

public class Nizhi {
    private ListStatus front;

    public Nizhi(){
        front=new ListStatus();
    }

    protected void addElem(Object elem){
        if(elem==null) return;
        if(front.size>front.MAXSIZE) return;//满
        front.data[front.size++]=elem;
    }

    protected void print(){
        System.out.println(Arrays.toString(front.data));
        System.out.println(front.size);
    }

    /**
     * 顺序表逆置算法
     */
    protected void Revelt(){
        int p=0;
        while (p<(front.size/2)){
            Object temp;
            temp=front.data[p];
            front.data[p]=front.data[front.size-1-p];
            front.data[front.size-1-p]=temp;
            p++;
        }

    }

    public static void main(String[] args) {
        Nizhi nizhi=new Nizhi();
        for (int i=0;i<10;i++){
            nizhi.addElem(i);
        }
        nizhi.print();
        nizhi.Revelt();
        nizhi.print();

    }


}

public class ListStatus {
    protected  Object[] data;
    protected  int size;
    protected  int MAXSIZE;
    public ListStatus(){
        MAXSIZE=20;
        size=0;
        data=new Object[MAXSIZE];
    }
    protected ListStatus(int maxsie){
        this.MAXSIZE=maxsie;
        data=new Object[MAXSIZE];
        size=0;
    }

}

单链表倒置

/**
 * 单链表的存储结构
 */
public class LinkList {

    private NodeSql head;//定义头结点
    private NodeSql tail;//尾指针
    private static int size = 0;

    public LinkList() {
        head = new NodeSql();//
    }


    /**
     * 获取链表第一个数据的算法思路
     * 1.声明一个节点p,初始化j=1
     * 2.
     * 3.j<i 结点向后移动，j+1
     * 4.若p到到末尾没有找到元素，表示元素不存在
     * 5.返回指定元素
     *
     * @param i
     * @param elem
     */
    public Object getElem(int i, Object elem) {
        NodeSql p;//指向第一个元素
        int j = 1;
        p = head;
        while (p.next != null && j < i) {
            p = p.next;
            ++j;
        }
        elem = p.data;
        return elem;


    }

    /**
     * 思路：在i位置插入元素
     * 1.声明一个节点p,初始化讲
     * 2.p指向第一个结点‘
     * 3.p不为空j<i，进行移动 p=p.next j++
     * s.next=p.next
     * p.next=s
     */
    public void insertelem(int i, Object elem) {
        NodeSql p;//初始化一个结点p,指向第一个结点
        int j = 1;
        p = head;
        while (p.next != null && j < i) {
            p = p.next;
            ++j;
        }
        if (p == null || j > i) return;
        NodeSql s = new NodeSql(elem);
        s.next = p.next;
        p.next = s;


    }

    /**
     * 添加结点
     * 为空判断
     *
     * @param elem
     */
    public void addNode(NodeSql elem) {
        NodeSql temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = elem;
    }

    /**
     * 尾结点插入
     * 平均时间复杂度O(n)
     *
     * @param elem
     */
    public void addTailElem(Object elem) {
        NodeSql p;
        p = head;
        //找到插入点
        while (p.next != null) {
            p = p.next;
        }
        //找到最后一个点，在尾结点就行插入,new 一个新结点
        NodeSql s = new NodeSql(elem);
        s.next = p.next;
        p.next = s;
    }

    /**
     * 尾插入时间复杂度O(1)
     *
     * @param elem
     */
    public void addTailElemExtend(Object elem) {
        //尾指针指向头结点
        NodeSql r = null;

        if (tail == null) {
            tail = head;

        }
        r = tail;
        //插入元素 new 一个新的结点
        NodeSql s = new NodeSql(elem);
        s.next = r.next;
        r.next = s;
        tail = s;
    }

    /**
     * 头插入
     * 时间复杂度为O(1)
     */
    protected void addHeadElem(Object elem) {
        NodeSql r;
        r = head;
        NodeSql s = new NodeSql(elem);
        s.next = r.next;
        r.next = s;

    }

    public void print() {
        NodeSql temp = head.next;
        while (temp != null) {
            System.out.print(temp.data + "  ");
            if (temp.next == head) {
                temp = null;
            } else {
                temp = temp.next;
            }


        }

    }

    /**
     * 删除结点
     * 初始化j=1
     * 循环 找到第i个结点
     * 找到某个结点
     * 删除p->next=p->next->kkonext
     *
     * @param i
     * @return
     */
    public boolean deleteelem(int i) {
        NodeSql p, q;
        int j = 1;
        p = head;
        while (p.next != null && j < i) {
            p = p.next;
            ++j;

        }
        if (p == null || j > i) {
            return false;
        }
        q = p.next;
        p.next = q.next;
        q = null;
        return true;

    }

    /**
     * 单链表的逆置算法
     */
    protected void Revert() {
        NodeSql p, q;
        NodeSql r;
        p = head.next;
        q = head;
        q.next=null;
        //从第一个结点开始进行尾插入
        while (p != null) {
            r = p.next;
            p.next = q.next;
            q.next = p;
            p = r;
        }


    }


    public static void main(String[] args) {
        LinkList list = new LinkList();
        for (int i = 0; i < 10; i++) {
            list.addTailElem(i);
        }
        list.print();
        System.out.println();
        list.Revert();
        list.print();
    }

}