蓝桥杯java（单链表和双链表）

最新推荐文章于 2024-01-26 19:00:05 发布

航航航hang

最新推荐文章于 2024-01-26 19:00:05 发布

阅读量109

点赞数

文章标签：蓝桥杯 java 职场和发展算法

本文链接：https://blog.csdn.net/weixin_62564687/article/details/131625648

版权

826. 单链表

实现一个单链表，链表初始为空，支持三种操作：

向链表头插入一个数；
删除第 k� 个插入的数后面的数；
在第 k� 个插入的数后插入一个数。

现在要对该链表进行 M 次操作，进行完所有操作后，从头到尾输出整个链表。

注意:题目中第 k个插入的数并不是指当前链表的第 k个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 11 个插入的数，第 22 个插入的数，…第 n 个插入的数。

输入格式

第一行包含整数 M，表示操作次数。

接下来 M 行，每行包含一个操作命令，操作命令可能为以下几种：

H x，表示向链表头插入一个数 x。
D k，表示删除第 k 个插入的数后面的数（当 k 为 00 时，表示删除头结点）。
I k x，表示在第 k 个插入的数后面插入一个数 x（此操作中 k 均大于 00）。

输出格式

共一行，将整个链表从头到尾输出。

数据范围

1≤M≤100000
所有操作保证合法。

输入样例：

H 9

I 1 1

D 1

D 0

H 6

I 3 6

I 4 5

I 3 4

D 6

输出样例：

6 4 6 5

程序：

import java.util.*;
public class Main{
    public static final int M = 100010;
    static int head,idx;
    static int []e = new int[M];
    static int []ne = new int[M];
    public static void init()
    {
        head =-1;
        idx = 0;
    }
    public static void add_to_head(int x)
    {
        e[idx]= x;
        ne[idx] = head;
        head = idx++;
    }
    public static void add(int k,int x)
    {
        e[idx] = x;
        ne[idx] = ne[k];
        ne[k] = idx++;

    }
    public static void remove(int k)
    {
        ne[k] =ne[ne[k]];
    }
    public static void main(String args[])
    {
        Scanner N = new Scanner(System.in);
        int m = N.nextInt();
        init();
        while(m-->0)
        {
            String s = N.next();
            char op = s.charAt(0);
            if(op=='H')
            {
            int x = N.nextInt();
            add_to_head(x);
            }
           else if(op=='D')
            {
                int k = N.nextInt();
                if(k == 0) head = ne[head];
               else remove(k-1);
            }
            else
            {
                int k = N.nextInt();
                int x = N.nextInt();
                add(k-1,x);
            }
        }
        for(int i = head ;i!=-1;i = ne[i])
        {
            System.out.print(e[i]+" ");
        }

    }

}

总结：

1.采用静态链表

2.单链表需要两个数组，一个是存储自身元素值得数组，一个是指向下一个元素的数组。

3. String s = N.next();

char op = s.charAt(0);

通过输入一个字符串，再获取字符串中的第一个字符的值。

3709. 单链表节点交换

输入一个单链表，将奇数位置上的节点与偶数位置上的节点进行交换，然后输出交换之后的链表。

输入格式

第一行包含整数 n，表示节点数量。

第二行包含 n 个整数，表示每个节点的值。

输出格式

共一行，输出交换后的链表。

数据范围

1≤n≤100,
节点取值范围 [1,100]。

输入样例：

1 2 3 4 5

输出样例：

2 1 4 3 5

程序：

import java.util.*;
public class Main {
    public static int M = 1010;
    static int []e = new int[M];
    static int []ne = new int[M];
    static int head,idx;
    public static void main(String args[])
    {
        init();
        Scanner N = new Scanner(System.in);
        int n = N.nextInt();
       for(int i =1;i<=n;i++)
        {
            int m = N.nextInt();
            if(i == 1)
                add_to_head(m);
            else
                add(m);
        }
           swap(n);
           for(int i=head;i!=-1;i=ne[i])//注意链表的输出for循环的写法
            System.out.print(e[i]+" ");
    }
    public static void init()
    {
        head =-1;
        idx = 0;
    }
    public static void swap(int n)
    {
        if(n<=1)
            return;
        int t;
        int oushu = head;
        int jishu = ne[oushu];
        while(jishu!=-1&&ne[jishu]!=-1)
        {
            t= e[oushu];
            e[oushu] = e[jishu];
            e[jishu] = t;
            oushu = ne[jishu];
            jishu = ne[oushu];
        }
        if(n%2 ==0)
        {
            t= e[oushu];
            e[oushu] = e[jishu];
            e[jishu] = t;
        }

    }
    public static void add_to_head(int x)
    {
        e[idx] = x;
        ne[idx] = head;
        head = idx++;
    }
    public static void add(int x)
    {
        e[idx] = x;
        ne[idx] = ne[idx-1];
        ne[idx-1] = idx++;
    }
}

总结：

1.该题应用了链表的基本操作，主要考了一个链表节点值的交换。

2.由于链表里存储了下一个节点的位置，所以可不用循环来遍历，直接用向后指针即可。

3.注意偶数节点数量，最后两个数由于判断条件后只进行了节点的更替，但值并没有交换，我又判断了n是否为偶数，如果是偶数，则再进行一次交换，保证了数据的正确，感觉有更好的办法，但我没有想到。

827. 双链表

实现一个双链表，双链表初始为空，支持 55 种操作：

在最左侧插入一个数；
在最右侧插入一个数；
将第 k 个插入的数删除；
在第 k 个插入的数左侧插入一个数；
在第 k 个插入的数右侧插入一个数

现在要对该链表进行 M 次操作，进行完所有操作后，从左到右输出整个链表。

注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 11 个插入的数，第 22 个插入的数，…第 n 个插入的数。

输入格式

第一行包含整数 M，表示操作次数。

接下来 M 行，每行包含一个操作命令，操作命令可能为以下几种：

L x，表示在链表的最左端插入数 x。
R x，表示在链表的最右端插入数 x。
D k，表示将第 k 个插入的数删除。
IL k x，表示在第 k 个插入的数左侧插入一个数。
IR k x，表示在第 k 个插入的数右侧插入一个数。

输出格式

共一行，将整个链表从左到右输出。

数据范围

1≤M≤100000
所有操作保证合法。

输入样例：

R 7

D 1

L 3

IL 2 10

D 3

IL 2 7

L 8

R 9

IL 4 7

IR 2 2

输出样例：

8 7 7 3 2 9

程序：

import java.util.*;
public class Main{
    static int idx;
    static int M = 1010;
    static int []l = new int[M];
    static int []r = new int[M];
    static int []e = new int[M];
    public static void main(String args[])
    {
        init();
        Scanner N = new Scanner(System.in);
        int m = N.nextInt();
        for(int i =1;i<=m;i++)
        {
            String op = N.next();
            if("L".equals(op))//表示在链表的最左端插入数 x
            {
                int x = N.nextInt();
                add(0,x);
            }
                if("R".equals(op))//表示在链表的最右端插入数 x
                {
                    int x = N.nextInt();
                    add(l[1],x);
                }
                    if("D".equals(op))//表示将第 k 个插入的数删除
                    {
                        int k = N.nextInt();
                        remove(k+1);
                    }
                        if("IL".equals(op))//表示在第 k 个插入的数左侧插入一个数
                        {
                            int k = N.nextInt();
                            int x = N.nextInt();
                            add(l[k+1],x);
                        }
                            if("IR".equals(op))//表示在第 k 个插入的数右侧插入一个数
                            {
                                int k =N.nextInt();
                                int x = N.nextInt();
                                add(k+1,x);
                            }
        }
        for(int i=r[0];i!=1;i = r[i])
           System.out.print(e[i]+" ");
    }
    public static void init()
    {
        r[0] = 1;
        l[1] = 0;
        idx = 2;
    }
    public static void add(int k,int x)
    {
        e[idx] = x;
        l[idx] = k;
        r[idx] = r[k];
        l[r[k]] = idx;
        r[k] =idx;
        idx++;
    }
    public static void remove(int k)
    {
        r[l[k]] = r[k];
        l[r[k]] = l[k];
    }
}

总结：

1.双链表和单链表操作很相似，就是多了前向指针。

2.还是注意输出

for(int i=r[0];i!=1;i = r[i])
System.out.print(e[i]+" ");