数据结构题目训练记录（Java书写） One

此篇笔记，涉及到 数据结构中 序列，链表的使用

一、最大子列和问题

给定K个整数组成的序列{ N​1​​, N​2​​, ..., N​K​​ }，“连续子列”被定义为{ N​i​​, N​i+1​​, ..., N​j​​ }，其中 1。“最大子列和”则被定义为所有连续子列元素的和中最大者。例如给定序列{ -2, 11, -4, 13, -5, -2 }，其连续子列{ 11, -4, 13 }有最大的和20。现要求你编写程序，计算给定整数序列的最大子列和。

本题旨在测试各种不同的算法在各种数据情况下的表现。各组测试数据特点如下：

• 数据1：与样例等价，测试基本正确性；
• 数据2：102个随机整数；
• 数据3：103个随机整数；
• 数据4：104个随机整数；
• 数据5：105个随机整数；

输入格式:

输入第1行给出正整数K (≤)；第2行给出K个整数，其间以空格分隔。

输出格式:

在一行中输出最大子列和。如果序列中所有整数皆为负数，则输出0。

输入样例:

6
-2 11 -4 13 -5 -2

 

输出样例:

20

第一种方法：三重循环法，时间复杂度为 O(n3)

/**
 *  这里用的第一种方法是三重循环方法 时间复杂度为 O（n^3）
 *  法一：三重循环。第一重标记子列最左端，第二重标记子列最右端，第三重由子列左端累加到子列右端。
 */
public class MaxSum1{
    public static int MaxSum1s(int A[])
    {
        int ThisSum = 0, MaxSum = 0;
        int i, j ,k;
        for(i = 0; i < A.length; i++)  // i 是子列最左端
        {
            for(j = i; j < A.length; j++)  
            {
                ThisSum = 0;  // 每次都要将 ThisSum 归零，累加新一轮的子列和
                for (k = i; k < j; k++)  // 将 A[i] 到 A[j] 累加，得到子列和
                    ThisSum += A[k];
                if(ThisSum > MaxSum)  // 如果这一轮的子列和比最大子列和还大，存入 MaxSum
                    MaxSum = ThisSum;
            }
        }
        return MaxSum;
    }

    public static void main(String[] args)
    {
        int  lists[] = new int[] {-2 ,11, -4, 13, -5, -2};
        System.out.println(MaxSum1s(lists));
    }   
}

第二种方法：二重循环法

/**
 *  法二：二重循环。对于相同的子列左端位置 i ，不同的右端位置 j ，我们只要每次在右端累加一项，即可求得每一个子列和。
 */
public class MaxSum2{
    public static int MaxSums(int [] A)
    {
        int MaxSum = 0, ThisSum = 0;
        int i, j;
        for(i = 0; i < A.length; i++)
        {
            ThisSum = 0;
            for(j = i; j < A.length; j++)
            {
                ThisSum += A[j];
                if (ThisSum > MaxSum)  // 这里改成了，从 i 到 任意一处 j 来进行比较
                {
                    MaxSum = ThisSum;
                }
            }
        }
        return MaxSum;
    }

    public static void main(String [] args)
    {
        int  lists[] = new int[] {-2 ,11, -4, 13, -5, -2};
        System.out.println(MaxSums(lists));
    }
}

第三种方法：分而治之

/**
 * @author 小喵钓鱼
 * @date 2020-02-02 13:53
 * @veision 1.10
 *  方法三：分而治之。
 * 将序列从中分为左右两个子序列。
 * 递归求得两个子列的最大和。
 * 从中分点分头向左、右两边扫描，找出跨过分界线的最大子列和。
 * 输出这三个子列和最大的一个。
 */
public class MaxSum3 {
    // 比较三个数的
    public static  int Max3(int A, int B, int C)
    {
        return (A>B)?(A>C?A:C):(B>C?B:C);
    }

    /**
     * 分治 list[left] 和 list[right] 的最大子列和
     * @param List
     * @param left
     * @param right
     * @return
     */
    public static int DivideAndConquer(int List[], int left, int right)
    {
        int MaxLeftSum, MaxRightSum;    //存放左右子问题的解。
        int MaxLeftBorderSum, MaxRightBorderSum;    //存放跨分界线的结果。

        int LeftBorderSum, RightBorderSum;
        int center, i;

        /*递归的终止条件，子列只有1个数字*/
        if ( left == right ) {
            if ( List[left] > 0 )    return List[left];
            else return 0;
        }

        /* “分”的过程 */
        center = ( left + right ) / 2;    //找到中分点。
        MaxLeftSum = DivideAndConquer ( List, left, center );    //递归求左子列和。
        MaxRightSum = DivideAndConquer ( List, center+1, right );    //递归求右子列和。

        /*求跨分界线的最大子列和*/
        MaxLeftBorderSum = 0;    LeftBorderSum = 0;
        for ( i = center; i >= left; i-- ) {
            LeftBorderSum += List[i];
            if ( LeftBorderSum > MaxLeftBorderSum )
                MaxLeftBorderSum = LeftBorderSum;
        }//左边扫描结束。

        MaxRightBorderSum = 0;    RightBorderSum = 0;
        for ( i = center+1; i <= right; i++ ) {
            RightBorderSum += List[i];
            if ( RightBorderSum > MaxRightBorderSum )
                MaxRightBorderSum = RightBorderSum;
        }//右边扫描结束。

        /*返回“治”的结果*/
        return Max3(MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum );
    }

    /*此函数用于保持接口相同*/
    public static int MaxSum3 ( int List[], int N ) {
        return DivideAndConquer(List, 0, N - 1);
    }

    public static void main(String[] args) {
        int  lists[] = new int[] {-2 ,11, -4, 13, -5, -2};
        System.out.println(MaxSum3(lists, lists.length));
    }
}

二、Maximum Subsequence Sum （最大序列和，此题和上题比较类似）

Given a sequence of K integers { N​1​​, N​2​​, ..., N​K​​ }. A continuous subsequence is defined to be { N​i​​, N​i+1​​, ..., N​j​​ } where 1. The Maximum Subsequence is the continuous subsequence which has the largest sum of its elements. For example, given sequence { -2, 11, -4, 13, -5, -2 }, its maximum subsequence is { 11, -4, 13 } with the largest sum being 20.

Now you are supposed to find the largest sum, together with the first and the last numbers of the maximum subsequence.

Input Specification:

Each input file contains one test case. Each case occupies two lines. The first line contains a positive integer K (≤). The second line contains K numbers, separated by a space.

Output Specification:

For each test case, output in one line the largest sum, together with the first and the last numbers of the maximum subsequence. The numbers must be separated by one space, but there must be no extra space at the end of a line. In case that the maximum subsequence is not unique, output the one with the smallest indices i and j (as shown by the sample case). If all the K numbers are negative, then its maximum sum is defined to be 0, and you are supposed to output the first and the last numbers of the whole sequence.

Sample Input:

10
-10 1 2 3 4 -5 -23 3 7 -21

 

Sample Output:

10 1 4

/**
 * @author 小喵钓鱼
 * @date 2020-02-02 14:28
 * @veision 1.10
 */
public class Maximum {
    public static void Maximums(int list[], int N)
    {
        int ThisSum, MaxSum, Forntdata, Enddata;
        int sublen;  // 设置 子列差
        sublen = Forntdata = Enddata = ThisSum = 0;
        MaxSum = -1;
        for (int i = 0; i < N; i++)
        {
            ThisSum += list[i];
            sublen ++;  // 差 + 1
            if (ThisSum > MaxSum)  // 如果子列和大于最大子列和
            {
                MaxSum = ThisSum;  // 最大和
                Enddata = list[i];  // 结尾子序列数据
                Forntdata = list[i - sublen + 1];  // 开始子序列数据
            }
            if (ThisSum < 0)  // 如果子列和 < 0
            {
                ThisSum = 0;
                sublen = 0;
            }
        }

        if (MaxSum < 0)
        {
            System.out.println(0 + " " + list[0] + " " + list[N - 1]);
        }
        else
        {
            System.out.println(MaxSum + " " + Forntdata + " " + Enddata);
        }
    }

    public static void main(String[] args) {
        int list [] = new int[]{-10, 1, 2, 3, 4, -5, -23, 3, 7, -21};
        int N = list.length;
        Maximums(list, N);
    }
}

三、二分查找

  顾名思义，就是从中间比较，不断分，来进行查找的一种方法，但是缺点是查找的子序列必须是已经排好序了的

/**
 * @author 小喵钓鱼
 * @date 2020-02-02 14:38
 * @veision 1.10
 */
public class binary_search {
    public static int binary_search_pp(int list[], int searchKey)
    {
        int Center;  // 中间坐标
        int lower = 0;
        int upper = list.length - 1;
        while (true)
        {
            Center = (lower + upper) / 2;  // 更新
            if (list[Center] == searchKey){  // 如果第一次就找到，直接返回
                return Center;
            }

            else if(lower > upper)  // 如果最低坐标，比最高坐标大，那么代表这个数组就一个元素
            {
                return list.length;
            }
            else {
                if (list[Center] < searchKey)  // 如果 <
                    lower = Center + 1;
                else  // 如果 大
                    upper = Center - 1;
            }
        }
    }

    public static void main(String[] args) {
        int key [] = new int[]{1, 2, 3, 4 ,5 ,6};
        System.out.println(binary_search_pp(key, 3));
    }
}

四、两个有序链表序列的合并

　怎么说呢，感觉自己写的有点小问题，不过无伤大雅，虽然是倒叙就是了，不过思路还是可以借鉴的

    虽然是用 Java写的，但是并没有用到 相应的库，自行写的 单向链表类。

/**
 * @author 小喵钓鱼
 * @date 2020-02-02 14:59
 * @veision 1.10
 * L1和L2是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Merge要将L1和L2合并为一个非递减的整数序列。应直接使用原序列中的结点，返回归并后的带头结点的链表头指针。
 */
public class Link{
    public int iData;  // data item
    public double dData; // data item
    public Link next;  // next link in list
    public Link(int id, double dd)
    {
        iData = id;  // initializa data
        dData = dd;
    }
    public void displayLink()
    {
        System.out.println("{" + iData + ", " + dData + "}");
    }
}


class LinkList {
    private Link first; // ref to first link on list

    public void LinkList() {
        first = null;
    }

    public boolean isEmpty() {
        return (first == null);
    }

    public void insertFirst(int id, double dd) {
        Link newLink = new Link(id, dd);
        newLink.next = first; // newLink --> old first
        first = newLink;  // first --> newLink
    }

    public Link deleteFirst() {
        Link temp = first;
        first = first.next;
        return temp;
    }

    public void displayList() {
        System.out.println("List(first --> last)");
        Link current = first;  // start at beginning of list
        while (current != null) {
            current.displayLink();  // print data
            current = current.next;  // move to next link
        }
        System.out.println(" ");
    }

    public Link find(int Key) {
        Link current = first;
        while (current.dData != Key) {
            if (current.next == null)
                return null;  // didn't find it
            else
                current = current.next;
        }
        return current;
    }

    public void Merge(LinkList L1)
    {
        LinkList L =  new LinkList();
        Link pa, pb, pc;
        pa = first;
        pb = L1.first;
        pc = L.first;
        int count = 0;
        while (pa != null && pb != null)
        {
            System.out.println(pa.dData + "=" + pb.dData);
            if (pa.dData >= pb.dData)
            {
                if (count < 1)
                {
                    L.first = pa;
                    count ++;
                }
                else {
                    pc.next = pa;
                }
                pc = pa;
                pa = pa.next;
            }
            else {
                if (count < 1)
                {
                    L.first = pb;
                    count++;
//                    pc .next = pb;
                }
                else {
                    pc.next = pb;
                }
                pc = pb;
                pb = pb.next;
            }
        }

        pc.next = pa != null? pa: pb;
        L1.first = null;
        this.first = L.first;
    }
}

class LinkListApp{
    public static void main(String [] args)
    {
        LinkList theList = new LinkList();  // make new list

        theList.insertFirst(1, 2.29); // insert four items
        theList.insertFirst(4, 4.29);
        theList.insertFirst(6, 6.99);
        theList.insertFirst(7, 8.99);


        LinkList nextList = new LinkList();
        nextList.insertFirst(2, 2.30);
        nextList.insertFirst(3, 3.40);
        nextList.insertFirst(5, 5.33);


        theList.Merge(nextList);
        theList.displayList();
    }
}

五、一元多项式的乘法与加法运算

设计函数分别求两个一元多项式的乘积与和。

输入格式:

输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。

输出格式:

输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。

输入样例:

4 3 4 -5 2  6 1  -2 0
3 5 20  -7 4  3 1

 

输出样例:

15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 1
5 20 -4 4 -5 2 9 1 -2 0

代码示例

/**
 * @author 小喵钓鱼
 * @date 2020-02-02 18:18
 * @veision 1.10
 * 设计函数分别求两个一元多项式的乘积与和。
 *
 * 输入格式:
 * 输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。
 *
 * 输出格式:
 * 输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。
 */
class Links
    {
        public int iData;
        public int dData;
        public Links next;  // next Link
        public Links(int id, int dd)
        {
            iData = id;
            dData = dd;
        }

        public void displayLink()
        {
            System.out.println("{" + iData + ":" + dData + "}");
        }

        public void setId(int id)
        {
            this.iData = id;
        }
    }
class LinkList{
    public Links first;  // ref to the first link
    public Links last;  // ref to the last link

    public void LinkList()
    {
        first = null;
        last = null;
    }

    public boolean isEmpty()
    {
        return (first == null);
    }

    public void insertFirst(int id, int dd)
    {
        Links newLink = new Links(id, dd);
        if (isEmpty())
        {
            last = newLink;   // newLink <-- last
        }
        newLink.next = first;  // newLink --> old first
        first = newLink;
    }

    public void insertAfter(int id, int dd)
    {
        Links newLink = new Links(id, dd);
        if (isEmpty())
        {
            first = newLink;  // first --> newLink
        }
        else
            last.next = newLink;  // old last --> newLink
        last = newLink;  // newLink <-- last
    }

    public void displayLink()
    {
        System.out.println("List(first --> last)");
        Links current = first;  // start at beginning of list
        while (current != null) {
            current.displayLink();  // print data
            current = current.next;  // move to next link
        }
        System.out.println(" ");
    }

}
public class Mult_Add {
    public static void ReadOnly(LinkList P1)
    {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();  // 位数
        for (int i = 0; i < N; i++)
        {
            int idata = scanner.nextInt();
            int ddata = scanner.nextInt();
            P1.insertAfter(idata, ddata);
    }
    }

    public static LinkList Add(LinkList T1, LinkList T2)
    {
        LinkList P = new LinkList();

        if (T1 == null || T2 == null)
        {
            return null;
        }
        // 分别指向 T1, T2 的第一个元素
        Links link1 = T1.first;
        Links link2 = T2.first;

        while (link1 != null && link2 != null) {  // 两者均不为空时
            if (link1.dData > link2.dData) {
                P.insertAfter(link1.iData, link1.dData);
                link1 = link1.next;
            }
            else if(link1.dData<link2.dData)
            {
                P.insertAfter(link2.iData, link2.dData);
                link2 = link2.next;
            }
            else {  // 两者指数相等时
                    if (link1.iData + link2.iData != 0) {
                        P.insertAfter(link1.iData + link2.iData, link1.dData);
                    }
                    link1 = link1.next;
                    link2 = link2.next;
            }
        }

        while (link1 != null)
        {
            P.insertAfter(link1.iData, link1.dData);
            link1 = link1.next;
        }
        while (link2 != null)
        {
            P.insertAfter(link2.iData, link2.dData);
            link2 = link2.next;
        }
        return P;
    }


    public static LinkList Mult(LinkList T1, LinkList T2)
    {
      LinkList P = new LinkList();
      // 分别指向第一个元素
      Links link1 = T1.first;
      Links link2 = T2.first;

        /**
         * 这里用的方法是先将两者每一个都像乘法那样相乘，然后进行同类项的合并
         */
        while (link1 != null)
      {
          while (link2 != null)
          {
              int idata = link1.iData * link2.iData;
              int ddata = link1.dData + link2.dData;
              P.insertAfter(idata, ddata);
              link2 = link2.next;
          }
          link1 = link1.next;
          link2 = T2.first;
      }

      // 合并同类项
      Links link3 = P.first;  // 指向 P 的 第一个元素
      Links tempPrevious = link3;  // 同指
      Links temp = link3.next;  // 指向第二个元素
      while (link3.next != null)  // 当Link3 不等于 last 时。。。
      {
          while (temp != null)
          {
              if (temp.dData != link3.dData)  // 如果 前一个和后一个的指数不同，则都向下进一个
              {
                  temp = temp.next;
                  tempPrevious = tempPrevious.next;
              }
              else  // 如果两者指数相同
              {
                  link3.setId(link3.iData + temp.iData);  // 更改前者系数
                  tempPrevious.next = temp.next; // 将 前者改成 temp
                  temp = temp.next;  // temp = temp.next
              }
          }
          link3 = link3.next;  
          tempPrevious = link3;
          temp = link3.next;
      }
      return P;
    }

    public static void main(String[] args) {
        LinkList p1 = new LinkList();
        ReadOnly(p1);
        p1.displayLink();

        LinkList p2 = new LinkList();
        ReadOnly(p2);
        p2.displayLink();
        LinkList P = Add(p1, p2);
        P.displayLink();

        LinkList P3 = Mult(p1, p2);
        P3.displayLink();
    }
}