实现线性表
线性表有下标/位序的概念，可以提供根据下标的操作(根据下标的增删改查)，以及根据内容的增删改查。
基于单链表实现
package com.qxk.www.LinkedList;
public class MyLinkedList<T> {
private class Node{
public Node next;
public T val;
public Node(T val,Node next){
this.val = val;
this.next = next;
}
}
private int size;
private Node head;
//增加
public boolean add(T value){
//默认向链表的表尾添加元素
//若链表为空
if(isEmpty()){
head = new Node(value,null);
size++;
return true;
}
Node mid = head;
while(mid.next != null){
mid = mid.next;
}
mid.next = new Node(value,null);
size++;
return true;
}
//删除
public boolean remove(T value){
if(isEmpty()){
throw new RuntimeException("The List is empty");
}
//查找要删除元素的前一个元素
if(value == null){
if(head.val == value){
head = null;
size--;
return true;
}
Node mid = head;
while(mid.next != null && mid.next.val != value){
mid = mid.next;
}
//若一直查找到了链表尾说明没有这个元素
if(mid.next == null){
return false;
}
//找到了要删除元素的前一个
mid.next = mid.next.next;
size--;
return true;
}else {
if(head.val.equals(value)){
head = null;
size--;
return true;
}
Node mid = head;
while(mid.next != null && mid.next.val.equals(value)!= true ){
mid = mid.next;
}
//若一直查找到了链表尾说明没有这个元素
if(mid.next == null){
return false;
}
//找到了要删除元素的前一个
mid.next = mid.next.next;
size--;
return true;
}
}
//查找
public boolean contains(T value){
if(isEmpty()){
throw new RuntimeException("list is empty");
}
Node mid = head;
while(mid != null && !mid.val.equals(value)){
mid = mid.next;
}
if(mid == null){
return false;
}
return true;
}
// olValue 要修改的值 newValue 传入的值
public boolean set(T oldValue , T newValue){
if(isEmpty()){
throw new RuntimeException("list is empty");
}
Node mid = head;
while(mid != null && !mid.val.equals(oldValue)){
mid = mid.next;
}
if(mid == null){
return false;
}
mid.val = newValue;
return true;
}
//在下标为i 的位置添加元素
public boolean add(T value,int index){
if(index < 0||index > size){
throw new IllegalArgumentException("illegal index");
}
//如果在头插入
if(index == 0){
head = new Node(value,head);
size++;
return true;
}
//找下标为index - 1的节点 0 - index 比从1到index多一个 所以让tag =1 等到tag等于index 遍历到index前一个节点
int tag = 1;
Node mid = head;
while(tag != index){
mid = mid.next;
tag++;
}
mid.next = new Node(value,mid.next);
return true;
}
//删除下标为index 的节点 并返回其值。
public T remove(int index){
if(index < 0||index >= size){
throw new IllegalArgumentException("illegal index");
}
if(index == 0){
T valueOfRemove = head.val;
head = head.next;
size --;
return valueOfRemove;
}
int tag = 1;
Node mid = head;
while(tag != index){
tag++;
mid = mid.next;
}
T valueOfRemove = mid.next.val;
mid.next = mid.next.next;
size --;
return valueOfRemove;
}
//获得下标为index 的元素
public T get(int index){
if(index < 0||index >= size){
throw new IllegalArgumentException("illegal index");
}
Node mid = head;
int tag = 0;
while(tag != index){
tag++;
mid = mid.next;
}
return mid.val;
}
//修改下标为iindex的节点的值
public T set(int index , T newValue){
if(index < 0||index >= size){
throw new IllegalArgumentException("illegal index");
}
Node mid = head;
int tag = 0;
while(tag != index){
tag++;
mid = mid.next;
}
T oldValue = mid.val;
mid.val = newValue;
return oldValue;
}
public boolean isEmpty(){
return size == 0;
}
public int size(){
return size;
}
}
基于双链表实现
package com.qxk.www.LinkedList;
public class MyDBLinkedList<T> {
private class Node {
Node next;
Node pre;
T val;
public Node(Node pre, Node next, T val) {
this.next = next;
this.pre = pre;
this.val = val;
}
}
private Node head;
private Node tail;
private int size;
//向尾部添加元素
public boolean add(T val) {
if (isEmpty()) {
head = tail = new Node(null, null, val);
size++;
return true;
}
tail.next = new Node(tail, null, val);
tail = tail.next;
size++;
return true;
}
public boolean remove(T val) {
if (isEmpty()) {
throw new RuntimeException("list is empty");
}
//若要删除头结点需要看是否只剩只一个节点
if (head.val.equals(val)) {
if (size == 1) {
head = null;
tail = null;
} else {
head = head.next;
head.pre = null;
}
size--;
return true;
}
//若要删除的是尾节点
if (tail.val.equals(val)) {
tail = tail.pre;
tail.next = null;
size--;
return true;
}
//删除中间节点
Node mid = head;
while (mid.next != null && !mid.next.val.equals(val)) {
mid = mid.next;
}
if (mid.next == null) {
return false;
}
Node removeNode = mid.next;
removeNode.next.pre = mid;
mid.next = removeNode.next;
size--;
return true;
}
public boolean contains(T val) {
//空直接返回false
if (isEmpty()) {
return false;
}
Node mid = head;
while (mid != null && !mid.val.equals(val)) {
mid = mid.next;
}
if (mid == null) {
return false;
}
return true;
}
public boolean set(T oldValue, T newValue) {
if (isEmpty()) {
return false;
}
Node mid = head;
while (mid != null && !mid.val.equals(oldValue)) {
mid = mid.next;
}
if (mid == null) {
return false;
}
mid.val = newValue;
return true;
}
//基于下标的添加 可用双链表的性质下标偏左从头开始遍历 偏右从尾向头遍历
public boolean add(T val, int index) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("illegal index");
}
if (isEmpty()) {
add(val);
}//头插入
if (index == 0) {
head.pre = new Node(null, head, val);
head = head.pre;
size++;
}//尾插入
if (index == size) {
add(val);
}//中间插入
Node mid, newNode;
if (index < size / 2) {
int tag = 1;
mid = head;
while (tag != index) {
tag++;
mid = mid.next;
}
newNode = new Node(mid, mid.next, val);
mid.next = newNode;
newNode.next.pre = newNode;
size++;
} else {
mid = tail;
int tag = size;
//size到查找元素之前的位置 画个图就知道了
while (tag != index) {
tag--;
mid = mid.pre;
}
newNode = new Node(mid, mid.next, val);
mid.next = newNode;
newNode.next.pre = newNode;
size++;
}
return true;
}
public T remove(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("illegal index");
}
if (isEmpty()) {
throw new IllegalArgumentException("list is empty");
}
//删除头结点
if (index == 0) {
if (size == 1) {
T removeVal = head.val;
head = tail = null;
size--;
return removeVal;
} else {
T removeVal = head.val;
head = head.next;
head.pre = null;
size--;
return removeVal;
}
}//删除尾节点
if (index == size - 1) {
T removeVal = tail.val;
tail = tail.pre;
tail.next = null;
size--;
return removeVal;
}
Node mid, newNode;
if (index < size / 2) {
int tag = 1;
mid = head;
while (tag != index) {
tag++;
mid = mid.next;
}
T removeVal = mid.next.val;
mid.next.next.pre = mid;
mid.next = mid.next.next;
size--;
return removeVal;
} else {
mid = tail;
int tag = size;
//size到查找元素之前的位置 画个图就知道了
while (tag != index) {
tag--;
mid = mid.pre;
}
T removeVal = mid.next.val;
mid.next.next.pre = mid;
mid.next = mid.next.next;
size--;
return removeVal;
}
}
//基于下标的获取
public T get(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("illegal index");
}
if (isEmpty()) {
throw new IllegalArgumentException("list is empty");
}
Node mid;
int tag;
if (index < size / 2) {
mid = head;
tag = 0;
while (tag != index) {
tag++;
mid = mid.next;
}
return mid.val;
}else {
mid = tail;
tag = size - 1;
while (tag != index) {
tag--;
mid = mid.pre;
}
return mid.val;
}
}//基于下标的修改
public T set(int index,T newData){
if (index < 0 || index >= size) {
throw new IllegalArgumentException("illegal index");
}
if (isEmpty()) {
throw new IllegalArgumentException("list is empty");
}
Node mid;
int tag;
if (index < size / 2) {
mid = head;
tag = 0;
while (tag != index) {
tag++;
mid = mid.next;
}
T oldData = mid.val;
mid.val = newData;
return oldData;
}else {
mid = tail;
tag = size - 1;
while (tag != index) {
tag--;
mid = mid.pre;
}
T oldData = mid.val;
mid.val = newData;
return oldData;
}
}
public boolean isEmpty() {
return size == 0;
}
public int size() {
return size;
}
}
基于数组实现
增加了扩容机制
package com.qxk.www.BST.linkedlist;
public class MyArrayList<T> {
private final int INIT_CAPACITY = 10;
private final int MAX_CAPACITY = Integer.MAX_VALUE - 8;
private Object[] objs;
private int size;
public MyArrayList() {
objs = new Object[INIT_CAPACITY];
size = 0;
}
public MyArrayList(int capacity) {
if (capacity < 1 || capacity > MAX_CAPACITY) {
throw new IllegalArgumentException("param is illegal");
}
objs = new Object[capacity];
size = 0;
}
//按内容的增加
public boolean add(T val) {
if (size == objs.length) {
//扩容
int newLen = getLen();
grow(newLen);
}
objs[size++] = val;
return true;
}
private void grow(int newLen) {
Object[] newObjs = new Object[newLen];
for (int i = 0; i < objs.length; i++) {
newObjs[i] = objs[i];
}
objs = newObjs;
}
private int getLen() {
int oldLen = objs.length;
int newLen = 2 * oldLen;
if (newLen > MAX_CAPACITY || newLen < 0) {
newLen = MAX_CAPACITY;
}
//扩完以后长度仍然相等 说明已经达到最大的长度不能在扩容
if (newLen == oldLen) {
throw new RuntimeException("The list is full");
}
return newLen;
}
//基于内容的删除
public boolean remove(T val) {
if (isEmpty()) {
throw new RuntimeException("the list is empty");
}
//找到val的下标
int i = 0;
for (; i < size; i++) {
if (objs[i].equals(val)) {
break;
}
}
//没找到val
if (i == size) {
return false;
}
//元素前移
for (int j = i + 1; j < size; j++) {
objs[j - 1] = objs[j];
}
size--;
return true;
}
public boolean contains(T val) {
if (isEmpty()) {
return false;
}
for (int i = 0; i < objs.length; i++) {
if(objs[i].equals(val)){
return true;
}
}
return false;
}
public boolean set(T oldValue,T newValue){
if(isEmpty()){
return false;
}
int i = 0;
while(i < objs.length && !objs[i].equals(oldValue)){
i++;
}
if(i == objs.length){
return false;
}
objs[i] = newValue;
return true;
}
//按照下标的增加
public boolean add(int index,T val){
if(index < 0|| index >size){
throw new IllegalArgumentException("illegal index");
}
if(size == objs.length){
int len = getLen();
grow(len);
}
int i;
for(i = size;i > index;i-- ){
objs[i] = objs[i-1];
}
objs[i] = val;
size++;
return true;
}
//按照下标删除
public T remove(int index,boolean isRemoveIndex){
if(isEmpty()){
throw new RuntimeException("the list is empty");
}
if(index < 0|| index >=size){
throw new IllegalArgumentException("illegal index");
}
int i = 0 ;
while(i < size && i!=index){
i++;
}
T removeVal = (T)objs[i];
//元素前移
for (int j = i + 1; j < size; j++) {
objs[j - 1] = objs[j];
}
size--;
return removeVal;
}
//按照下标查找
public T get(int index){
if(isEmpty()){
throw new RuntimeException("the list is empty");
}
if(index < 0|| index >=size){
throw new IllegalArgumentException("illegal index");
}
int i = 0 ;
while(i < size && i!=index){
i++;
}
return (T)objs[i];
}
//按照下标修改
public T set(int index,T newVal,boolean isIndexSet){
if(isEmpty()){
throw new RuntimeException("the list is empty");
}
if(index < 0|| index >=size){
throw new IllegalArgumentException("illegal index");
}
int i = 0 ;
while(i < size && i!=index){
i++;
}
//保存旧的值
T oldVal = (T)objs[i];
objs[i] = newVal;
return oldVal;
}
public boolean isEmpty() {
return size == 0;
}
public int size() {
return size;
}
@Override
public String toString(){
StringBuffer sb = new StringBuffer();
for(int i = 0;i < size;i++){
sb.append(objs[i]).append(" ");
}
return sb.toString();
}
}
743
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
