数据结构03

最新推荐文章于 2024-07-25 17:43:13 发布
最新推荐文章于 2024-07-25 17:43:13 发布
阅读量346 收藏
点赞数
文章标签： 数据结构 链表 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MZdzt/article/details/122545166
版权

动态链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ibkay8oN-1642413558566)(C:\Users\qwe123\AppData\Roaming\Typora\typora-user-images\image-20220115093332359.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QaUMYZZ2-1642413558568)(C:\Users\qwe123\AppData\Roaming\Typora\typora-user-images\image-20220115093547237.png)]

package p3.链式结构;
//单向链表
import p1.接口.List;
import p2.线性结构.ArrayList;

import java.util.Comparator;
import java.util.Iterator;

public class LinkedSinglyList<E> implements List<E> {

    //定义节点类
    private class Node {
        E data;   // 数据域
        Node next;//指针域

        public Node() {
            this(null, null);
        }

        public Node(E data) {
            this(data, null);
        }

        public Node(E data, Node next) {
            this.data = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }

    private Node head; //头指针
    private Node tail;//尾指针
    private int size;//元素个数==节点个数

    public LinkedSinglyList() {
        head = null;
        tail = null;
        size = 0;
    }

    public LinkedSinglyList(E[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("arr null");
        }
        for (int i = 0; i < arr.length; i++) {
            add(arr[i]);
        }
    }

    @Override
    public void add(E element) {
        add(size, element);
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add index 越界");
        }
        Node n = new Node(element);

        if (size == 0) {
            head = n;
            tail = n;
        } else if (index == 0) {
            n.next = head;
            head = n;
        } else if (index == size) {
            tail.next = n;
            tail = n;
        } else {
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        size++;
    }

    @Override
    public void remove(E element) {
        int index = indexOf(element);
        if (index != -1) {
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove index 越界");
        }
        E ret = null;
        if (size == 1) {
            ret = head.data;
            head = null;
            tail = null;
        } else if (index == 0) {
            Node n = head;
            ret = n.data;
            head = n.next;
            n.next = null;
        } else if (index == size - 1) {
            Node p = head;
            while (p.next != tail) {
                p = p.next;
            }
            ret = tail.data;
            p.next = null;
            tail = p;
        } else {
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
                p = p.next;
            }
            Node n = p.next;
            ret = n.data;
            p.next = n.next;
            n.next = null;
        }
        size--;
        return ret;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index 越界");
        }
        if (index == 0) {
            return head.data;
        } else if (index == size - 1) {
            return tail.data;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            return p.data;
        }
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("get index 越界");
        }
        E ret = null;
        if (index == 0){
            ret = head.data;
            head.data = element;
        }else if (index == size - 1){
            ret = tail.data;
            tail.data = element;
        }else {
            Node p = head;
            for (int i = 0;i < index;i++){
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public int indexOf(E element) {
        Node p = head;
        int index = 0;
        while (!p.data.equals(element)) {
            p = p.next;
            index++;
            if (p == null) {
                return -1;
            }
        }
        return index;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
        return size == 0 && head == null && tail == null;
    }

    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if (c == null) {
            throw new IllegalArgumentException("Comparator not null");
        }
//        for (int i = 1;i < size;i++){
//            E e = get(i);
//            int j = 0;
//            for(j = i; j>0 && c.compare(get(j - 1),e) > 0;j--){
//                set(j,get(j - 1));
//            }
//            set(j,e);
//        }
        if (size == 0 || size == 1) {
            return;
        }
        Node nodeA = head;
        Node nodeB = nodeA.next;
        while (true) {
            while (true) {
                if (c.compare(nodeA.data, nodeB.data) > 0) {
                    swap(nodeA, nodeB);
                }
                if (nodeB == tail) {
                    break;
                }
                nodeB = nodeB.next;
            }
            if (nodeA.next == tail) {
                break;
            }
            nodeA = nodeA.next;
            nodeB = nodeA.next;
        }
    }

    private void swap(Node nodeA, Node nodeB) {
        E temp = nodeA.data;
        nodeA.data = nodeB.data;
        nodeB.data = temp;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        //0 <= fromIndex <= toIndex <= size - 1
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex <= size - 1");
        }
        LinkedSinglyList<E> list = new LinkedSinglyList<>();
        Node nodeA = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeA = nodeA.next;
        }

        Node nodeB = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeB = nodeB.next;
        }

        Node p = nodeA;
        while (true){
            list.add(p.data);
            if (p == nodeB){
                break;
            }
            p = p.next;
        }
        return list;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
        } else {
            Node p = head;
            while (true) {
                sb.append(p.data);
                if (p == tail) {
                    sb.append(']');
                    break;
                }
                sb.append(',');
                sb.append(' ');
                p = p.next;
            }
        }
        return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new LinkedSinglyListITerator();
    }

    class LinkedSinglyListITerator implements Iterator<E> {
        private Node cur = head;
        @Override
        public boolean hasNext() {
            return cur != null;
        }

        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            return ret;
        }
    }
}

单向循环链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1xxDrV7x-1642413558569)(C:\Users\qwe123\AppData\Roaming\Typora\typora-user-images\image-20220115140909106.png)]

package p3.链式结构;
//单向循环链表
import p1.接口.List;

import java.util.Comparator;
import java.util.Iterator;

public class LinkedSinglyCircularList<E> implements List<E> {

    //定义结点对象
    private class Node {
        E data;     //数据域
        Node next;  //指针域
        public Node(){
            this(null,null);
        }
        public Node(E data) {
            this(data,null);
        }
        public Node(E data, Node next) {
            this.data = data;
            this.next = next;
        }
        @Override
        public String toString() {
            return data.toString();
        }
    }
    private Node head;  //头指针
    private Node tail;  //尾指针
    private int size;   //元素的个数

    public LinkedSinglyCircularList() {
        head = null;
        tail = null;
        size = 0;
    }

    public LinkedSinglyCircularList(E[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("arr is null");
        }
        for (int i = 0; i < arr.length; i++) {
            add(arr[i]);
        }
    }

    @Override
    public void add(E element) {
        add(size,element);
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size){
            throw new IllegalArgumentException("add index 越界");
        }
        Node n = new Node(element);
        if (size == 0){
            head = n;
            tail = n;
            tail = n;
            tail.next = head;
        }else if (index == 0){
            n.next = head;
            head = n;
            tail.next = head;
        }else if (index == size){
            n.next = tail.next;
            tail.next = n;
            tail = n;
        }else {
            Node p =head;
            for (int i = 0; i < index - 1;i++){
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        size++;
    }

    @Override
    public void remove(E element) {
        int index = indexOf(element);
        if (index != -1){
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("remove index 越界");
        }
        E ret = null;
        if (size == 1){
            ret = head.data;
            head = null;
            tail = null;
        }else if (index == 0){
            Node n = head;
            ret = n.data;
            head = n.next;
            n.next = null;
            tail.next = head;
        }else if (index == size - 1){
            Node p = head;
            while (p.next != tail){
                p = p.next;
            }
            ret = tail.data;
            p.next = tail.next;
            tail = p;
        }else {
            Node p = head;
            for (int i= 0; i < index - 1;i++ ){
                p = p.next;
            }
            Node n = p.next;
            ret = n.data;
            p.next = n.next;
            n.next = null;
        }
        size--;
        return ret;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("get index 越界");
        }
        if (index == 0){
            return head.data;
        }else if(index == size - 1){
            return tail.data;
        }else {
            Node p = head;
            for (int i = 0; i < index ;i++){
                p = p.next;
            }
            return p.data;
        }
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index out of range");
        }
        E ret = null;
        if (index == 0) {
            ret = head.data;
            head.data = element;
        } else if (index == size - 1) {
            ret = tail.data;
            tail.data = element;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public int indexOf(E element) {
        Node p = head;
        int index = 0;
        while (!p.data.equals(element)){
            p = p.next;
            index++;
            if (p == head){
                return -1;
            }
        }
        return index;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
        return size == 0 && head == null && tail == null;
    }

    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if (c == null) {
            throw new IllegalArgumentException("comparator can not be null");
        }
        if (size == 0 || size == 1) {
            return;
        }
        Node nodeA = head;
        Node nodeB = nodeA.next;
        while (true) {
            while (true) {
                if (c.compare(nodeA.data, nodeB.data) > 0) {
                    swap(nodeA, nodeB);
                }
                if (nodeB == tail) {
                    break;
                }
                nodeB = nodeB.next;
            }
            if (nodeA.next == tail) {
                break;
            }
            nodeA = nodeA.next;
            nodeB = nodeA.next;
        }
    }

    private void swap(Node nodeA, Node nodeB) {
        E temp = nodeA.data;
        nodeA.data = nodeB.data;
        nodeB.data = temp;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex <= size - 1");
        }

        LinkedSinglyList<E> list = new LinkedSinglyList<>();
        Node nodeA = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeA = nodeA.next;
        }
        Node nodeB = head;
        for (int i = 0; i < toIndex; i++) {
            nodeB = nodeB.next;
        }
        Node p = nodeA;
        while (true) {
            list.add(p.data);
            if (p == nodeB) {
                break;
            }
            p = p.next;
        }
        return list;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
        } else {
            Node p = head;
            while (true) {
                sb.append(p.data);
                if (p == tail) {
                    sb.append(']');
                    break;
                }
                sb.append(',');
                sb.append(' ');
                p = p.next;
            }
        }
        return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new LinkedSinglyCircularListIterator();
    }

    class LinkedSinglyCircularListIterator implements Iterator<E> {
        private Node cur = head;
        private boolean flag = true; //是否在第一圈

        @Override
        public boolean hasNext() {
            if (isEmpty()) {
                return false;
            }
            return flag;
        }
        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            if (cur == head) {
                flag = false;
            }
            return ret;
        }
    }

    public void josephusLoop(){
        if (size <= 2){
            return;
        }
        Node p = head;
        while (size != 2){
            p = p.next;
            Node del = p.next;
            if (del == head){
                head = del.next;
            }else if (del == tail){
                tail = p;
            }
            p.next = del.next;
            del.next = null;
            p = p.next;
            size--;
        }
    }
}

约瑟夫问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rNpYqCbS-1642413558569)(C:\Users\qwe123\AppData\Roaming\Typora\typora-user-images\image-20220115150610685.png)]

package p3.链式结构;
//单向循环链表
import p1.接口.List;

import java.util.Comparator;
import java.util.Iterator;

public class LinkedSinglyCircularList<E> implements List<E> {

    //定义结点对象
    private class Node {
        E data;     //数据域
        Node next;  //指针域
        public Node(){
            this(null,null);
        }
        public Node(E data) {
            this(data,null);
        }
        public Node(E data, Node next) {
            this.data = data;
            this.next = next;
        }
        @Override
        public String toString() {
            return data.toString();
        }
    }
    private Node head;  //头指针
    private Node tail;  //尾指针
    private int size;   //元素的个数

    public LinkedSinglyCircularList() {
        head = null;
        tail = null;
        size = 0;
    }

    public LinkedSinglyCircularList(E[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("arr is null");
        }
        for (int i = 0; i < arr.length; i++) {
            add(arr[i]);
        }
    }

    @Override
    public void add(E element) {
        add(size,element);
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size){
            throw new IllegalArgumentException("add index 越界");
        }
        Node n = new Node(element);
        if (size == 0){
            head = n;
            tail = n;
            tail = n;
            tail.next = head;
        }else if (index == 0){
            n.next = head;
            head = n;
            tail.next = head;
        }else if (index == size){
            n.next = tail.next;
            tail.next = n;
            tail = n;
        }else {
            Node p =head;
            for (int i = 0; i < index - 1;i++){
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        size++;
    }

    @Override
    public void remove(E element) {
        int index = indexOf(element);
        if (index != -1){
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("remove index 越界");
        }
        E ret = null;
        if (size == 1){
            ret = head.data;
            head = null;
            tail = null;
        }else if (index == 0){
            Node n = head;
            ret = n.data;
            head = n.next;
            n.next = null;
            tail.next = head;
        }else if (index == size - 1){
            Node p = head;
            while (p.next != tail){
                p = p.next;
            }
            ret = tail.data;
            p.next = tail.next;
            tail = p;
        }else {
            Node p = head;
            for (int i= 0; i < index - 1;i++ ){
                p = p.next;
            }
            Node n = p.next;
            ret = n.data;
            p.next = n.next;
            n.next = null;
        }
        size--;
        return ret;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("get index 越界");
        }
        if (index == 0){
            return head.data;
        }else if(index == size - 1){
            return tail.data;
        }else {
            Node p = head;
            for (int i = 0; i < index ;i++){
                p = p.next;
            }
            return p.data;
        }
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index out of range");
        }
        E ret = null;
        if (index == 0) {
            ret = head.data;
            head.data = element;
        } else if (index == size - 1) {
            ret = tail.data;
            tail.data = element;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public int indexOf(E element) {
        Node p = head;
        int index = 0;
        while (!p.data.equals(element)){
            p = p.next;
            index++;
            if (p == head){
                return -1;
            }
        }
        return index;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
        return size == 0 && head == null && tail == null;
    }

    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if (c == null) {
            throw new IllegalArgumentException("comparator can not be null");
        }
        if (size == 0 || size == 1) {
            return;
        }
        Node nodeA = head;
        Node nodeB = nodeA.next;
        while (true) {
            while (true) {
                if (c.compare(nodeA.data, nodeB.data) > 0) {
                    swap(nodeA, nodeB);
                }
                if (nodeB == tail) {
                    break;
                }
                nodeB = nodeB.next;
            }
            if (nodeA.next == tail) {
                break;
            }
            nodeA = nodeA.next;
            nodeB = nodeA.next;
        }
    }

    private void swap(Node nodeA, Node nodeB) {
        E temp = nodeA.data;
        nodeA.data = nodeB.data;
        nodeB.data = temp;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex <= size - 1");
        }

        LinkedSinglyList<E> list = new LinkedSinglyList<>();
        Node nodeA = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeA = nodeA.next;
        }
        Node nodeB = head;
        for (int i = 0; i < toIndex; i++) {
            nodeB = nodeB.next;
        }
        Node p = nodeA;
        while (true) {
            list.add(p.data);
            if (p == nodeB) {
                break;
            }
            p = p.next;
        }
        return list;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
        } else {
            Node p = head;
            while (true) {
                sb.append(p.data);
                if (p == tail) {
                    sb.append(']');
                    break;
                }
                sb.append(',');
                sb.append(' ');
                p = p.next;
            }
        }
        return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new LinkedSinglyCircularListIterator();
    }

    class LinkedSinglyCircularListIterator implements Iterator<E> {
        private Node cur = head;
        private boolean flag = true; //是否在第一圈

        @Override
        public boolean hasNext() {
            if (isEmpty()) {
                return false;
            }
            return flag;
        }
        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            if (cur == head) {
                flag = false;
            }
            return ret;
        }
    }

    public void josephusLoop(){
        if (size <= 2){
            return;
        }
        Node p = head;
        while (size != 2){
            p = p.next;
            Node del = p.next;
            if (del == head){
                head = del.next;
            }else if (del == tail){
                tail = p;
            }
            p.next = del.next;
            del.next = null;
            p = p.next;
            size--;
        }
    }
}

逢七过

package p3.链式结构;

import java.util.ArrayList;
import java.util.Scanner;

//逢七过游戏
/*
输入玩家的个数
输入从哪个玩家开始
输入该玩家从哪个数字开始
输入一共玩几个数字
打印出每个玩家将要报出的所有数字
*/
public class SevenGame {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print(">>>请输入玩家的个数：");
        int playerCount = input.nextInt();

        System.out.print(">>>请输入从哪个玩家开始：");
        int beginPlayer = input.nextInt();

        System.out.print(">>>请输入从哪个数字开始：");
        int beginNumber = input.nextInt();

        System.out.print(">>>请输入数字的最大值：");
        int maxNumber = input.nextInt();

        //创建玩家的集合
        LinkedSinglyCircularList<ArrayList<String>> list = new LinkedSinglyCircularList<>();
        //分别创建玩家的对象
        for (int i = 0; i < playerCount; i++) {
            list.add(new ArrayList<>());
        }

        //开始的玩家的角标
        int index = beginPlayer - 1;

        //将数字 依次分给每一个玩家
        for (int num = beginNumber; num <= maxNumber; num++) {
            list.get(index++ % playerCount).add(getAnswer(num));
        }

        for (int i = 0; i < list.size(); i++) {
            System.out.println("第" + (i + 1) + "位玩家：" + list.get(i));
        }
    }

    private static String getAnswer(int num) {
        if (num % 7 == 0 || (num + "").contains("7")) {
            return "过";
        }
        return num + "";
    }
}

双向链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ql82RBKf-1642413558570)(C:\Users\qwe123\AppData\Roaming\Typora\typora-user-images\image-20220116093130241.png)]

package p3.链式结构;
//双向循环链表
import p1.接口.Dequeue;
import p1.接口.List;
import p1.接口.Stack;

import java.util.Comparator;
import java.util.Iterator;

public class LinkList<E> implements List<E>, Dequeue<E>,Stack<E> {

    @Override
    public void addFirst(E element) {
        add(0,element);
    }

    @Override
    public void addLast(E element) {
        add(size,element);
    }

    @Override
    public E removeFirst() {
        return remove(0);
    }

    @Override
    public E removeLast() {
        return remove(size - 1);
    }

    @Override
    public E getFirst() {
        return get(0);
    }

    @Override
    public E getLast() {
        return get(size - 1);
    }

    private  class Node{
        E data;
        Node pre;
        Node next;
        public Node(){
            this(null,null,null);
        }
        public Node(E data){
            this(data,null,null);
        }
        public Node(E data,Node pre,Node next){
            this.data = data;
            this.pre = pre;
            this.next = next;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }

    private Node head;
    private Node tail;
    private int size;

    public LinkList(){
        head = null;
        tail = null;
        size = 0;
    }

    public LinkList(E[] arr){
        if (arr == null){
            throw new IllegalArgumentException("arr not null");
        }
        for (E e : arr){
            add(e);
        }
    }


    @Override
    public void add(E element) {
        add(size,element);
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size){
            throw new IllegalArgumentException("add index越界");
        }
        Node n = new Node(element);
        if (size == 0){
            head = n;
            tail = n;
            tail.next = head;
            head.pre = tail;
        }else if (index == 0){
            n.pre = head.pre;
            n.next = head;
            head.pre = n;
            head = n;
            tail.next = head;
        }else if (index == size){
            n.next = tail.next;
            tail.next = n;
            n.pre = tail;
            tail = n;
            head.pre = tail;
        }else {
            Node p , q;
            if (index <= size / 2){
                p = head;
                for (int i = 0; i < index - 1; i++){
                    p = p.next;
                }
                q = p.next;
                p.next = n;
                n.pre = p;
                q.pre = n;
                n.next = q;
            }else {
                p = tail;
                for (int i = size - 1;i > index;i--){
                    p = p.pre;
                }
                q = p.pre;
                q.next = n;
                n.pre = q;
                n.next = p;
                p.pre = n;
            }
        }
        size++;
    }

    @Override
    public void remove(E element) {
        int index = indexOf(element);
        if (index != -1){
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove index out of range");
        }
        E ret = null;
        Node node;
        if (size == 1) {

        } else if (index == 0) {
            ret = head.data;
            node = head.next;
            head.next = null;
            node.pre = head.pre;
            head.pre = null;
            head = node;
            tail.next = head;
        } else if (index == size - 1) {
            ret = tail.data;
            node = tail.pre;
            tail.pre = null;
            node.next = tail.next;
            tail.next = null;
            tail = node;
            head.pre = tail;
        } else {
            Node p,q,r;
            if (index <= size / 2) {
                p = head;
                for (int i = 0; i < index - 1; i++) {
                    p = p.next;
                }
                q = p.next;
                r = q.next;
                ret = q.data;
                p.next = r;
                r.pre = p;
                q.next = null;
                q.pre = null;
            } else {
                p = tail;
                for (int i = size - 1; i > index + 1; i--) {
                    p = p.pre;
                }
                q = p.pre;
                r = q.pre;
                ret = q.data;
                r.next = p;
                p.pre = r;
                q.next = null;
                q.pre = null;
            }
        }
        size--;
        return ret;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("get index 越界");
        }
        if (index == 0){
            return head.data;
        }else if (index == size - 1){
            return tail.data;
        }else {
            Node p = head;
            for (int i = 0; i < index;i++){
                p = p.next;
            }
            return p.data;
        }
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("set index out of range");
        }
        E ret = null;
        if (index == 0) {
            ret = head.data;
            head.data = element;
        } else if (index == size - 1) {
            ret = tail.data;
            tail.data = element;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public int indexOf(E element) {
        Node p = head;
        int index = 0;
        while (!p.data.equals(element)){
            p = p.next;
            index++;
            if (p == head){
                return -1;
            }
        }
        return index;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public void offer(E element) {
        addLast(element);
    }

    @Override
    public E poll() {
        return removeFirst();
    }

    @Override
    public E element() {
        return getFirst();
    }

    @Override
    public boolean isEmpty() {
        return size == 0 && head == null && tail==null;
    }

    @Override
    public void push(E element) {
        addLast(element);
    }

    @Override
    public E pop() {
        return removeLast();
    }

    @Override
    public E peek() {
        return getLast();
    }

    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if (c == null){
            throw new IllegalArgumentException("Comparator null");
        }
        if (size == 0 || size == 1){
            return;
        }
        for (Node nodeA = head.next;nodeA != head;nodeA = nodeA.next){
            E e = nodeA.data;
            Node nodeB;
            Node nodeC;
            for (nodeB = nodeA,nodeC = nodeB.pre;nodeC != tail && c.compare(nodeC.data,e) > 0;nodeB = nodeB.pre,nodeC = nodeC.pre){
                nodeB.data = nodeC.data;
            }
            nodeB.data = e;
        }
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex){
            throw new IllegalArgumentException("0 < = fromIndex <= toIndex < size");
        }
        Node nodeA = head;
        for (int i = 0;i < fromIndex;i++){
            nodeA = nodeA.next;
        }
        Node nodeB = head;
        for (int i = 0;i < toIndex;i++){
            nodeB = nodeB.next;
        }
        Node p = nodeA;
        LinkList<E> list = new LinkList<>();
        while (true){
            list.add(p.data);
            if (p == nodeB){
                break;
            }
            p = p.next;
        }
        return list;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()){
            sb.append(']');
        }else {
            Node p = head;
            while (true){
                sb.append(p.data);
                if (p == tail){
                    sb.append(']');
                    break;
                }
                sb.append(',');
                sb.append(' ');
                p = p.next;
            }
        }
        return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new LinkedListIterator();
    }

    class LinkedListIterator implements Iterator<E> {
        private Node cur = head;
        private boolean flag = true; //是否在第一圈

        @Override
        public boolean hasNext() {
            if (isEmpty()) {
                return false;
            }
            return flag;
        }

        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            if (cur == head) {
                flag = false;
            }
            return ret;
        }
    }
}

MZdzt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构ch03.doc
03-07
本章主要介绍了三种特殊线性表：栈、队列和串，它们在数据结构中占有重要地位，特别是在处理特定问题时。首先我们详细讨论栈，它是一种具有后进先出（LIFO）特性的数据结构。 **3.1 栈** 1. **栈的定义**：栈是一...
【黑马程序员就业班】03.数据结构
03-30
数据结构是计算机科学中的核心概念，它涉及到如何在内存中有效地组织和管理数据，以便进行高效的操作。在“黑马程序员就业班”的03.数据结构课程中，你将深入学习到这一关键领域的各种理论和实践知识。 数据结构是...
数据结构03：单链表逆置
ALAN_CF的博客
01-24 4537
// // Created by 15328 on 2022/1/24. // #include<stdio.h> #include<stdlib.h> typedef int ElementType; typedef struct Node *PtrToNode; struct Node { ElementType Data; PtrToNode Next; }; typedef PtrToNode List; List Read(){ List l.
【算法与数据结构 03】数据处理的基本操作——增删查
不积跬步，无以至千里！
06-02 2645
细致入微，方可游刃代码行间~
数据结构之数组
野心与梦
04-06 1万+
数组
数据结构与算法之美
william_n的博客
08-31 4875
1.介绍 数据结构和算法解决的是如何更省、更快地存储和处理数据的问题. 数据结构和算法是相辅相成的。数据结构是为算法服务的，算法要作用在特定的数据结构之上。 因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构。比如，因为数组具有随机访问的特点，常用的二分查找算法需要用数组来存储数据。但如果我们选择链表这种数据结构，二分查找算法就无法工作了，因为链表并不支持随机访问。数...
数据结构课设——计算器
m0_56144302的博客
07-07 2263
在实验-03、实验-05的作业内容基础上 （1）增加图形交互功能。 （2）增加3个逻辑运算符&&、||、！，并能处理逻辑运算符和算术运算符的混合运算。 （3）增加容错功能，能进行异常处理。
数据结构-结构体
ZBraveHeart的博客
02-24 5046
结构体的定义形式 1、概念 结构体是一种构造类型的数据结构， 是一种或多中基本类型或构造类型的数据的集合。 2、结构体的定义 //先定义类型 在定义变量(推荐) stuct stu { int num; char name[32]; int age; };//定义结构体类型 struct stu xxx;//定义结构体变量 //定义类型的同时 定义变量 stuct stu { int num; char name[32]; int age; }xxx; stuct stu xxxx;//可以
数据结构实验报告五 查找
G_M_R_的博客
12-31 7593
数据结构实验报告：实验五 查找
03 数据结构和算法——线性表
热门推荐
数据知道的博客
07-14 3万+
线性表：是n个数据特性相同的元素的组成有限序列，是最基本且常用的一种线性结构(线性表，栈，队列，串和数组都是线性结构），同时也是其他数据结构的基础。 对于非空的线性表或者线性结构的特点： （1）存在唯一的一个被称作“第一个”的数据元素； （2）存在唯一的一个被称作“最后一个”的数据元素； （3）除第一个外，结构中的每个数据元素均只有一个前驱； （4）除最后一个外，结构中的每个数据元素均只有一个后继...
《数据结构》陈越老师课后题详解
weixin_61122826的博客
03-07 2791
01-复杂度1 最大子列和问题 #include <iostream> using namespace std; int main() { int a, b; long long max, sum; while (cin >> a) { max = 0; sum = 0; for (int i = 0; i < a; i++) { cin >> b; sum += b; if (sum > max) max .
【愚公系列】2023年03月 其他-Web前端基础面试题（数据结构和算法_8道）
时光隧道
03-07 8588
数组是由相同类型的元素（element）的集合所组成的数据结构，分配一块连续内存来存储。特点：相同类型，连续内存，固定长度。一种遵循先进先出 (FIFO / First In First Out) 原则的一组有序的项；队列在尾部添加新元素，并从头部移除元素。最新添加的元素必须排在队列的末尾存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的；每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（指针/链接）组成。数组：连续且固定长度空间，不能动态扩展，查找高效，添加修改元素低效。
数据结构03PPT学习教案.pptx
10-03
数据结构03PPT学习教案.pptx
数据结构03排序PPT学习教案.pptx
10-05
数据结构是计算机科学中至关重要的一个领域，它研究如何有效地组织和存储数据，以便于高效地访问和处理。在数据结构的学习中，排序是一个核心概念，因为它涉及到如何将一组无序的数据按照特定规则（通常是升序或降序...
数据结构PPT文件
04-23
大连东软信息学院的学习平台的数据结构PPT文件，已打包，有需要的的话可以直接下载。压缩包内文件： 01课程介绍和绪论.pptx 02线性表的定义&顺序表表示和实现.pptx 03顺序表实现&链式表的基本概念.pptx 04链式表表示...
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1476
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
《Java初阶数据结构》----5.＜二叉树的概念及使用＞
m0_73456341的博客
07-24 1407
1.树的基本概念、2.二叉树概念及特性、3.二叉树的基本操作、4.二叉树相关编程题
数据结构——单链表OJ题（上）
2301_81888634的博客
07-24 844
一起加油，敬请期待“单链表OJ题（下）”~
数据结构（2）
m0_62881487的博客
07-23 1150
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值