数据结构(Java版) 线性表的实现与应用完整版
第02章 线性表(Java版)

p
… an-1 ∧
ai-1
ai
ai+1
(b)中间/尾删除,不改变head
ai ai+1 … an-1 ∧
head
(b)中间/尾删除,不改变head
《数据结构(Java版)(第3版)》
5.带头结点的单链表
p 头结点 head ∧ head a0 … an-1 ∧
q (a)空单链表 p head a0 a1
len element lista 5 A B C len element listb 5 null D E listb len element 5 null null (b)执行lista.remove(4);删除元素导致错误 D lista len element 4 A B C
(a)浅拷贝,lista.element与listb.element引用同一个数组
a0 a1 … ai ② q x ai+1 ①
(b)头插入,在原第1个结点之前插入q结点,改变head p … an-1 ∧
head
(c)中间插入,在p结点之后插入q结点,不改变head p q head a0 a1 … an-1 x ∧
(d)尾插入,在原最后一个结点p之后插入q结点,不改变head
public boolean append(T x) { return insert(this.length(), x); //需遍历单链表两次,效率较低 } return insert(Integer.MAX_VALUE, x); //遍历一次
《数据结构(Java版)(第3版)》
作用于顺序表的时间复杂度是O(n), 2 但作用于单链表的时间复杂度则是 O(n )
第2章
• •
《数据结构》实验报告模板(附实例)--实验一线性表的基本操作实现

《数据结构》实验报告模板(附实例)---实验一线性表的基本操作实现实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现,其中以熟悉各种链表的操作为重点。
2、巩固高级语言程序设计方法与技术,会用线性链表解决简单的实际问题。
二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书,提前做好实验预习与准备工作。
2、加“*”题目必做,其他题目任选;多选者并且保质保量完成适当加分。
3、严格按照数据结构实验报告模板和规范,及时完成实验报告。
四、实验步骤(说明:依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作(成员函数)的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码)㈠、数据结构与核心算法的设计描述(程序中每个模块或函数应加注释,说明函数功能、入口及出口参数)1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释,说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释,说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针,返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针,本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计(可用函数的调用关系图说明)㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图:2、程序清单(程序过长,可附主要部分)说明:以后每次实验报告均按此格式书写。
(完整版)数据结构线性表的主要程序代码

数据结构顺序表的主要代码(LIZHULIN)1./***有头结点的单链表的初始化、建立(表头插入、表尾插入)、求长度、插入、删除、输出***//***********单链表的初始化、建立、输出*****************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = NULL;}/*************建立一个带头结点的单链表,在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p,*q; int i;Initlist(L); /*单链表初始化*/q=L;printf("input the value\n");for(i = n;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));scanf("%d",&p->data); /*输入元素值*/q->next = p;p->next = NULL;q=p;/*插入到表尾*/}} /* Create_L *//*************建立一个带头结点的单链表,在表头插入**************Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化/*需要注意第一个数据插入时的情况/*Insert the Firset nodep = (LinkList*)malloc(sizeof(struct Lnode));printf("input the value\n");scanf("%d",&p->data); /*输入元素值L->next = p;p->next = NULL;/*将第二个及后面的数据插入for(i = n-1;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));printf("input a value\n");scanf("%d",&p->data); /*输入元素值p->next = L->next;L->next = p;/*插入到表头}} /* Create_L *//*************************求单链表的长度***********************/int Length_LinkList(LinkList *L){LinkList *p;int i=0;p=L->next;while(p!=NULL){i++;p=p->next;}return i;}/*Length_LinkList*//*************************在第i个结点前插入数据x *********************/ Insert_LinkList(LinkList *L, int i, int x){LinkList *p,*s;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i,则无意义*//*插入元素x */s=(LinkList *)malloc(sizeof(struct Lnode));s->data=x;s->next=p->next;p->next=s;}/*********************删除第i个元素,并用y将其值返回************************/ int Delete_LinkList(LinkList *L, int i){LinkList *p,*q;int y;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i,则无意义*/q=p->next;y=q->data;p->next=q->next;free(q) ;return y;} /*Delete_LinkList*//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p!=NULL){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int len;int n=0;int x=15;int y;int i=4;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =NULL;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);Insert_LinkList(L, i, x);/* y=Delete_LinkList(L,i);printf("the delete elment is y=%d\n",y);len=Length_LinkList(L);printf("the length of L is %d",len);*/display(L);getch();}2./***无头结点的单链表建立、插入、求长度、插入、删除、输出*****/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;while(p!=NULL){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}3./*********顺序表的建立、查找、插入运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/*******Creat SqList********/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input SqList.data\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Position Error");return;}elsereturn L->data[i-1];}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *L;/*printf("input the length of SqList\n");scanf("%d",&len);*/Create_SqList(L);Display_SqList(L);getch();}4./*********顺序表的归并运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/************ Creat SqList*************/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input the data of SqList\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Getelem Position Error");return;}return L->data[i-1];}/************ Insert Operation *********/void ListInsert(SqList *L,int i, int x){SqList *q, *p;if(i<1 || i>L->length){printf("the insert position error");return ;}q = &(L->data[i-1]); /*q为插入位置*/for(p=&(L->data[L->length-1]); p>=q; --p)*(p+1) = *p;L->data[i-1] = x;++L->length;}/********* LA and LB Merged LC ***************/ void MergeList(SqList *LA,SqList *LB,SqList *LC) {int La_len,Lb_len,ai,bj;int i,j;int k;i=j=1;InitList(LC);La_len = ListLength(LA);Lb_len = ListLength(LB);LC->length = La_len+Lb_len;/*for(k=0;k<LC->length;k++)LC->data[k] = 0; */k=0;while((i<=La_len)&&(j<=Lb_len)){ai= GetElem(LA, i);bj= GetElem(LB, j);if(ai<bj){++k;ListInsert(LC,k,ai);++i;}elseif(ai==bj){++k;ListInsert(LC,k,ai);++k;ListInsert(LC,k,bj);++i;++j;}else{++k;ListInsert(LC,k,bj);++j;}}while(i<=La_len){/*Append the residual node into LA */ai= GetElem(LA, i);++i;++k;ListInsert(LC,k,ai);}while(j<=Lb_len){/*Append the residual node into LA */bj= GetElem(LB, j);++j;++k;ListInsert(LC,k,bj);}LC->length = La_len+Lb_len;}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *LA , *LB, *LC;Create_SqList(LA);Create_SqList(LB);MergeList(LA,LB,LC);Display_SqList(LC);getch();}5./**** 用带头结点的循环单链表解决约瑟夫问题***********/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = L;}/*************建立一个带头结点的循环单链表,数据值为1,2,3,...n,在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化p=L;for(i = n;i>0;--i){q = (LinkList*)malloc(sizeof(struct Lnode));q->data = i; /*输入元素值p->next =qq->next = L;/*插入到表尾}} /* Create_L *//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p->next!=L){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int n;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =L;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);display(L);getch();}6./******** 无头结点的循环单链表的建立**************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}p->next = L;/*尾结点指向第一个结点*/}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;printf("%d ",p->data);p=p->next;while(p->next !=L){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/ main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}。
数据结构实验报告-实验:1线性表的顺序存储和操作实现

}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空,即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度:"+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);
数据结构_java实现线性表的部分操作

package com.zhy.sqlist;class Sqlist{int[] datas ;int length ;}public class SqlListOp{private static Sqlist sqlist ;static{sqlist = new Sqlist();sqlist.datas = new int[]{123,234,345,456,678,908,123,999};sqlist.length = sqlist.datas.length ;}/*** 删除数组中指定元素方法1* @author Administrator**/public void del_key_01(Sqlist sqlist, int key ){int k = 0 ;for(int i = 0 ; i< sqlist.length ; i++){if(sqlist.datas[i] != key){sqlist.datas[k++] = sqlist.datas[i] ;}}sqlist.length = k ;}/*** 删除数组中指定元素方法2* @author Administrator**/public void del_key_02(Sqlist sqlist, int key ){int k = 0 ;for(int i = 0 ; i< sqlist.length ; i++){if(sqlist.datas[i] == key){k++ ;}else{sqlist.datas[i-k] = sqlist.datas[i] ;}}sqlist.length -= k ;}/*** 输出所有元素* @param sqlist*/public void print(Sqlist sqlist){System.out.println("sqlist长度为:" + sqlist.length);for(int i = 0 ; i < sqlist.length ; i++){System.out.print(sqlist.datas[i]+" ");}}/*** 反转整个数组*/public void reverse(Sqlist sqlist ){int tmp ;for( int i = 0 ; i < sqlist.length/2; i++) //注意sqlist.length/2 {tmp = sqlist.datas[i] ;sqlist.datas[i] = sqlist.datas[sqlist.datas.length - i - 1] ;sqlist.datas[sqlist.datas.length - i -1 ] = tmp ;}}/*** 反转指定下标范围 [start , end )* @param sqlist* @param start* @param end*/public void reverse(Sqlist sqlist , int start , int end ){int tmp ;for( int i = start ; i < (start + end)/2 ; i++){tmp = sqlist.datas[i] ;sqlist.datas[i] = sqlist.datas[start + end - i - 1] ;sqlist.datas[start + end - i -1 ] = tmp ;}}/*** 数组循环左移k为* abcdefg 循环左移3位--> defgabc* 1、先反转得到gfedcba* 2、再分别反转前 length - k 位和后k位*/public void cleft(Sqlist sqlist , int k ){k = k % sqlist.length ;reverse(sqlist);reverse(sqlist , 0 , sqlist.length - k );reverse(sqlist , sqlist.length - k , sqlist.length );}public static void main(String[] args){SqlListOp listOp = new SqlListOp() ;listOp.print(sqlist);//listOp.del_key_02(sqlist, 123) ;//listOp.reverse(sqlist);listOp.cleft(sqlist, 9);//listOp.reverse(sqlist, 2, 6);System.out.println();listOp.print(sqlist);}}。
数据结构线性表ppt课件

01
02
03
04
插入操作
在链表的指定位置插入一个新 节点,需要修改相邻节点的指
针。
删除操作
删除链表的指定节点,需要修 改相邻节点的指针。
查找操作
从链表的头节点开始,顺序遍 历链表,直到找到目标元素或
遍历到链表末尾。
遍历操作
从链表的头节点开始,顺序访 问每个节点,直到遍历到链表
末尾。
04 线性表应用举例 与问题分析
多项式表示与计算问题
01
02
03
多项式表示方法
数组表示法和链表表示法 。
数组表示法
将多项式的系数按次序存 放在一个数组中,通过下 标表示对应的幂次。
链表表示法
每个节点包含系数和指数 两个数据域,以及一个指 向下一个节点的指针域。
一元多项式相加算法设计
• 算法思想:将两个多项式中的同类项系数相加,得到新的 多项式。
删除操作
删除指定位置i的元素,需要将i之后的元素都向前移动 一个位置。
03 链式存储结构及 其实现
链式存储结构原理及特点
链式存储结构原理
使用一组任意的存储单元存储线 性表的数据元素(这组存储单元 可以是连续的,也可以是不连续 的)。
链式存储结构特点
逻辑上相邻的元素在物理位置上 不一定相邻,元素之间的逻辑关 系是通过指针链接来表示的。
...,an组成的有序序列。
性质
集合中必存在唯一的一个“第一元素 ”。
集合中必存在唯一的一个“最后元素 ”。
除最后元素之外,均有唯一的后继。
除第一元素之外,均有唯一的前驱。
线性表与数组关系
数组是线性表的一种表现和实现形式。
线性表更侧重于逻辑概念,而数组则是这种逻辑概念在计算机中的一种存储方式。
数据结构实验二 线性表

数据结构实验二线性表数据结构实验二线性表一、实验目的本实验旨在帮助学生掌握线性表的基本概念、构造和基本操作,以及通过实际编程实现线性表的功能。
二、实验内容本实验包括以下几个部分:⑴线性表的定义和基本概念介绍线性表的定义,以及线性表中的元素、长度等基本概念。
⑵线性表的顺序存储结构介绍线性表的顺序存储结构的原理和实现方式,包括顺序表的定义、顺序表的初始化、插入和删除等操作。
⑶线性表的链式存储结构介绍线性表的链式存储结构的原理和实现方式,包括链表的定义、链表的插入和删除等操作。
⑷线性表的应用介绍线性表的应用场景和实际应用,如多项式的表示和运算等。
三、实验步骤⑴实验准备准备实验所需的编程环境和开发工具,如C语言编译器、集成开发环境等。
⑵实验设计根据实验要求和目标,设计实现线性表的相关功能,包括定义线性表、初始化线性表、插入和删除元素等。
⑶编码实现根据实验设计,编写程序代码实现线性表的功能。
⑷调试测试对编写的程序进行调试和测试,确保程序的正确性和可靠性。
⑸实验总结总结实验过程中遇到的问题和解决方案,对实验结果进行分析和评价。
四、实验注意事项⑴遵守实验守则在进行实验过程中,要遵守实验守则,注意安全和人身财产的保护。
⑵注意程序的健壮性在编写程序时,要考虑到各种异常情况的处理,保证程序的健壮性。
⑶注意代码的可读性和可维护性编写代码时,要注意代码的可读性和可维护性,使其易于阅读和修改。
⑷注意实验文档的完整性实验报告应包含所有实验内容的详细说明和实验过程的总结分析。
附件:本文档无附件。
法律名词及注释:本文档不涉及法律名词及注释。
数据结构实验线性表及其应用

数据结构实验线性表及其应用在计算机科学的领域中,数据结构是一门极其重要的基础学科,它为我们有效地组织和管理数据提供了理论和方法。
而线性表作为一种常见且基础的数据结构,在实际的程序设计和算法应用中有着广泛的应用。
线性表是一种最基本的数据结构,它是由零个或多个数据元素组成的有限序列。
在这个序列中,每个元素都有其特定的位置和值。
从存储结构上来看,线性表可以分为顺序存储和链式存储两种方式。
顺序存储的线性表,就像是一排紧密排列的格子,每个格子里存放着一个数据元素。
这种存储方式的优点是可以随机访问表中的任意元素,时间复杂度为 O(1)。
比如说,如果我们要获取顺序表中第 5 个元素的值,只需要通过简单的计算就能直接找到对应的位置并获取其值。
然而,顺序存储也有它的不足之处。
当需要插入或删除元素时,可能需要移动大量的元素,以保持数据的连续性,这会导致时间复杂度较高,为 O(n)。
相比之下,链式存储的线性表则更加灵活。
它就像是一串珍珠项链,每个珍珠(数据元素)通过一根线(指针)与下一个珍珠相连。
在链式存储中,插入和删除元素相对较为方便,只需要修改相关指针的指向即可,时间复杂度通常为 O(1)。
但是,由于无法直接通过计算得到某个元素的位置,所以随机访问的效率较低,时间复杂度为 O(n)。
在实际应用中,线性表有着多种多样的用途。
比如,我们可以用线性表来实现一个学生成绩管理系统。
将每个学生的成绩作为一个元素存储在线性表中,可以按照学号或者成绩进行排序。
当有新的学生成绩需要添加时,根据具体的存储方式选择合适的插入操作;当需要删除某个学生的成绩时,也能快速准确地进行删除。
再比如,在一个购物网站的商品列表中,也可以使用线性表来存储商品的信息。
用户可以按照价格、销量、评价等因素对商品进行排序和筛选。
而网站后台在处理商品的上下架、库存管理等操作时,也会频繁地对线性表进行插入、删除和修改等操作。
此外,在文本编辑软件中,我们输入的文字也可以看作是一个线性表。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告课程名称数据结构实验项目线性表的实现及应用实验仪器PC机一台学院_____ 专业班级/学号姓名实验日期成绩指导教师北京信息科技大学信息管理学院(数据结构课程上机)实验报告System、out、println("重新设置第5个元素为19:");list1、set(4, 19);list1、insert(2, 100);list1、append(20);System、out、println("删除8:"+list1、remove(8));System、out、print("修改后的顺序表:");System、out、println(list1、toString());list1、removeAll();System、out、println("删除后的顺序表:"+list1、toString()); //为空System、out、println("寻找元素50:"+list1、search(50));}}(2)a)package ex1;public class Del {public Del(int i,int k){String values[]={"A","b","C","d","e","f","g","h"};int n =values、length;for(int j=0;j<n;j++){System、out、print(values[j]+" ");}System、out、println();for(int j=i+k;j<n;j++){values[j-k]=values[j];}n=n-k;for(int j=0;j<n;j++){System、out、print(values[j]+ " " );}System、out、println();}public static void main(String args[]){new Del(2,3);}}b)package ex1;public class Del2 {public Del2(int i,int k){String values[]={"A","x","y","y","b","c","h"};SeqList<String> list=new SeqList<String>(values);System、out、println(list、toString());for(int j=1;j<=k;j++){ list、remove(i);}System、out、println(list、toString());}public static void main(String args[]){new Del2(2,3);}}c)package ex1;public class Merge {public Merge(){Integer values1[]={1,3,5,11};SeqList<Integer> list1=new SeqList<Integer>(values1);Integer values2[]={2,4,5,22,23};SeqList<Integer> list2=new SeqList<Integer>(values2);SeqList<Integer> list3=new SeqList<Integer>();int i=0,j=0;while(i<list1、length()&&j<list2、length()){if(list1、get(i)<list2、get(j)){list3、append(list1、get(i));i++;}else{list3、append(list2、get(j));j++;}}while(i<list1、length()){list3、append(list1、get(i));i++;}while(j<list2、length()){list3、append(list2、get(j)) ;j++;}System、out、println(list1、toString());System、out、println(list2、toString());System、out、println(list3、toString());}public static void main(String args[]){new Merge();}}d)package test;import ex1、SeqList;public class Intersection {public Intersection(){Integer values1[]={1,3,5,11,12,13,22,23,50};SeqList<Integer> list1=new SeqList<Integer>(values1);Integer values2[]={2,4,5,12,19,20,22,23,};SeqList<Integer> list2=new SeqList<Integer>(values2);SeqList<Integer> list3=new SeqList<Integer>();int i=0,j=0;while(i<list1、length()&&j<list2、length()){if(list1、get(i)<list2、get(j)){i++;}else if(list1、get(i)>list2、get(j)){j++;}else{ list3、append(list1、get(i));i++;j++;}}System、out、println(list1、toString());System、out、println(list2、toString());System、out、println(list3、toString());}public static void main(String args[]){new Intersection();}}3、(1)package ex1;public class Josephus {public Josephus(int n, int k, int m){System、out、println("Josephus("+n+","+k+","+m+"),");SeqList<String> list = new SeqList<String>(n);//创建顺序表实例,元素类型就是数字字符,只能排到n=9,否则达不到效果for (int i=0; i<n; i++)list、append((char)('1'+i)+""); //顺序表尾插入,O(1)// System、out、println(list、toString()); //输出顺序表的描述字符串,O(n)int i = k; //计数起始位置while (list、length()>1) //多于一个元素时循环,计数O(1){i = (i+m-1) % list、length(); //按循环方式对顺序表进行遍历,圆桌循环System、out、print("出列"+list、remove(i)、toString()+","); //删除i位置对象,O(n)// System、out、println(list、toString());}System、out、println("出列"+list、get(0)、toString());//get(0)获得元素,O(1)}public static void main(String args[]){new Josephus(9,1,3);}}(2)package test;import ex1、SeqList;public class JosephusA {public JosephusA(int n, int k, int m){System、out、println("Josephus("+n+","+k+","+m+"),");SeqList<Integer> list = new SeqList<Integer>(n);//创建顺序表实例,元素类型就是数字字符,只能排到n=9,否则达不到效果for (int i=0; i<n; i++)list、append(i); //顺序表尾插入,O(1) // System、out、println(list、toString()); //输出顺序表的描述字符串,O(n)int i = k; //计数起始位置while (list、length()>1) //多于一个元素时循环,计数O(1){i = (i+m-1) % list、length(); //按循环方式对顺序表进行遍历,圆桌循环System、out、print("出列"+list、remove(i)、toString()+","); //删除i位置对象,O(n)// System、out、println(list、toString());}System、out、println("出列"+list、get(0)、toString());//get(0)获得元素,O(1)}public static void main(String args[]){new JosephusA(15,2,9);}}第二部分:(4)、package ex2;public class Node<T> {public T data; //数据域public Node<T> next; //地址域,后继结点//构造结点public Node(T data,Node<T> next){this、data =data;this、next=next;}str += ","; //不就是最后一个结点时,加分隔符}return str+")";}}(5)、package ex2;public class SortedSinglyList<T extends Comparable <? super T>> extends SinglyList<T>{//构造空排序单链表public SortedSinglyList(){super(); //默认调用父类构造方法SinglyList()}public SortedSinglyList(SinglyList<T> list){super(); //构造空单链表for (Node<T> p=list、head、next; p!=null; p=p、next)//直接插入排序,每趟插入1个元素this、insert(p、data); //排序单链表按值插入}//构造 ,将values数组中的所有对象按值插入public SortedSinglyList(T values[]){super();for(int i=0;i<values、length;i++)this、insert(values[i]);}public void set(int i, T x) //设置第i个元素值为xpublic static void main(String[] args){new Del1(2,2);}}f、package ex2;public class Del2 {public Del2(int mink,int maxk){Integer[] values={1,3,9,17,34};SortedSinglyList<Integer> list = new SortedSinglyList<Integer>(values);System、out、println(list、toString());Node<Integer> p=list、head;int j=0;while(p、next!=null && p、next、data<=mink){p=p、next;j++;}while(p、next!=null &&p、next、data<maxk){list、remove(j);}System、out、println("list="+list、toString());}public static void main(String args[]){new Del2(2,18);}}g、package ex2;public class Meger{}(7)、package Poly;public interface Subible<T> //可相加接口,T表示数据元素的数据类型{public void sub(T t); //+=加法,约定两元素相加规则public boolean removable(); //约定删除元素条件}package Poly;//项类,一元多项式的一项,实现可比较接口与可相加接口public class TermX implements Comparable<TermX>, Subible<TermX>{protected int coef, xexp; //系数,x指数(可为正、0)public TermX(int coef, int xexp) //构造一项{this、coef = coef;this、xexp = xexp;}public TermX(TermX term) //拷贝构造方法{this(term、coef, term、xexp);}//以“系数x^指数”的省略形式构造一元多项式的一项。