用Java实现的数据链表翻转程序

发布网友 发布时间：2022-04-22 02:16

我来回答

共4个回答

热心网友 时间：2022-07-10 14:30

public class Main {
static class Node<T>{
T data;
Node<T> next;
private Node(T data,Node<T> next) {
this.data = data;
this.next = next;
}
}

public static void main(String[] args) {
Node<Integer> l = new Node<Integer>(null, new Node<Integer>(1, new Node<Integer>(2, new Node<Integer>(3, new Node<Integer>(4, new Node<Integer>(5, null))))));
Node<Integer> curr = l;
if(reverseAt(l, 3)){
while((curr = curr.next) != null)
System.out.println(curr.data);
}
}

@SuppressWarnings("unchecked")
public static <T> boolean reverseAt(Node<T> h, int p){ // had head node
       if(p<1) // invalid position
           return false
Object[] l =new Object[p];
Node<T> curr = h.next;
for(int i=0;i<p && curr!=null;i++,curr=curr.next){//save
l[i] = curr;
}
if(curr == null){// p bigger than the list length;
return false;
}
for(int i=p-1; i>0;i--){//reverse
((Node<T>)l[i]).next = ((Node<T>)l[i-1]);
}
((Node<T>)l[0]).next = curr;//link
h.next = (Node<T>) l[p-1];//head
return true;
}

}

热心网友 时间：2022-07-10 14:30

只是我的实现，应该不是最好的，毕竟使用了类库里的排序方法。

public class Demo {
    public static void main(String[] args) {
        // 初始化链表
        List<Object> list = new ArrayList<Object>();
        for (int i = 1; i < 7; i++) {
            list.add(i);
        }
        Object[] arrys = list.toArray();
        int length = arrys.length;

        // 存放结果的数组
        Object[] result = new Object[length];
        // int len = 2; 
        // int len = 3; 
        int len = 4;

        for (int i = 0; i < length; i = i + len) {
            // 最后一次
            if (length - i < len) {
                len = length - i;
                System.arraycopy(arrys, i, result, i, len);
                break;
            }
            Object[] arry = new Object[len];
            System.arraycopy(arrys, i, arry, 0, len);
            Demo.sortDesc(arry);
            System.arraycopy(arry, 0, result, i, len);
        }
        System.out.println(Arrays.toString(result));
    }

    /**
     * 自定义比较器反向排序
     * @param arrys
     * @return
     */
    public static Object[] sortDesc(Object[] arrys) {
        Arrays.sort(arrys, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                if (i1 > i2) {
                    return -1;
                } else if (i1 < i2) {
                    return 1;
                } else {
                    return 0;
                }
            }
        });
        return arrys;
    }
}

热心网友 时间：2022-07-10 14:31

思路：创建链表对象为{int num; Link link;}或者{int num; Object link;} k为你说的步长，增加变量index为当前下标，链表为link。
排序方法为:(只是思路，具体方法具体分析吧)
k = 获得的步长
index = k;
if( link.length > 1 && k >1){
while(index < link.length){
if(index > link.length){
k = k - (index - link.length);

index = link.length;
}

int width= 0;
while(index -width > index - k +width){
int temp = link[index -width -1];
link[index - width -1] = link[index - k + width];

link[index - k + width] = temp;

width += 1;
}

}

}

热心网友 时间：2022-07-10 14:31

public static void main(String[] args) {
LinkedList<Integer> linkList = new LinkedList<Integer>();
// 初始化，咋写都行
int len = 8;
for (int i = 0; i < len; i++) {
linkList.add(i + 1);
}

System.out.println("原始:" + linkList.toString());
int element = 3;
reverse(linkList, element);
}

/**
 * 翻转，总体思路就是分区翻转，看结果，效率应该是O(n)
 * @param list 原始链表
 * @param reverseInt 给出的元素
 */
static void reverse(LinkedList<Integer> list, int reverseInt) {
if (!list.contains(reverseInt)) {
return;
}
// 链表总长
int len = list.size();
// 翻转区域长
int areaLenth = list.indexOf(reverseInt) + 1;
// 翻转区域数，分区域翻转（一开始没看清，眼瘸了）
int reverseAreaCount = len / areaLenth;
for (int areaIndex = 0; areaIndex < reverseAreaCount; areaIndex++) {
// 单个区域翻转次数，为啥除2，翻转，你懂得。
int reverseCount = areaLenth / 2;
for (int reverseIndex = 0; reverseIndex < reverseCount; reverseIndex++) {
int aIndex = areaIndex * areaLenth + reverseIndex;
int bIndex = (areaIndex + 1) * areaLenth - 1 - reverseIndex;
int a = list.get(aIndex);
int b = list.get(bIndex);
list.set(bIndex, a);
list.set(aIndex, b);
}
}
System.out.println("翻转:" + list.toString());
}

 不知道是不是你想要的，跟链表不链表没啥关系，也许你想要的是通过链表特性来实现，那我就没用了。