[转]线性表的链式存储

（java版之单向线性）

第一步，定义一个接口

package com.stucture.list;

/**
 * 线性表顺序存储结构的接口
 * 指的是用一段地址连续的存储单元一次存储线性表的数据元素
 * @ClassName: ISqList
 * @author 小学徒
 * @date 2013-2-27
 */
public interface IList<T> {

    /**
     * 获得元素
     * @param loc 需要获得的第loc个元素
     * @return
     */
    public T getElem(int loc);


    /**
     * 插入元素
     * @param loc 元素的插入位置
     * @param t 需要插入的元素
     * @return  是否成功插入
     */
    public boolean insertElem(int loc, T t);

    /**
     * 删除元素
     * @param i 需要删除元素的位置
     * @return
     */
    public T deleteElem(int i);
}

 

第二步，定义我们的节点类：

package com.stucture.list.linkList;

/**
 * 链表中的结点
 * @ClassName: Node
 * @author 小学徒
 * @date 2013-2-27
 */
public class Node<T> {
    private T data;       //需要存储的数据信息
    private Node<T> next; //后继<span style="font-size: 1em; line-height: 1.5;">结</span><span style="font-size: 1em; line-height: 1.5;">点 </span>

    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
    public Node<T> getNext() {
        return next;
    }
    public void setNext(Node<T> next) {
        this.next = next;
    }


}

 

第三步，定义我们的链表及其基本操作，代码如下：

package com.stucture.list.linkList;

import com.stucture.list.IList;

/**
 * 单链表
 * @ClassName: LinkList
 * @author 小学徒
 * @date 2013-2-27
 */
public class LinkList<T> implements IList<T>{
    private Node<T> head; //链表的结点
    private int length; //链表的长度

    public LinkList(Node<T> head) {
        this.head = head;
    }
    //获取元素
    public T getElem(int loc) {
        int j = 1;  //计数器
        Node<T> n = head; //指向第一个结点

        while(n != null) {  //n不为空时，循环继续寻找第loc个结点
            if(j == loc) {  //找到第一个元素时返回
                return n.getData();
            }
            n = n.getNext();
            j++;

        }
        return null;
    }

    //插入元素
    public boolean insertElem(int loc, T t) {
        if(length + 1 < loc) {
            System.out.println("非法插入");
            return false;
        }
        if(head == null && loc == 1) {  //当第一次插入的时候
            head = new Node<T>(); //第一次使用，必须创建对象
            head.setData(t);
            length++;
        } else if(head != null && loc == 1) {   //但不是第一次插入，但是插入的位置是第一个时
            Node<T> tempNode = new Node<T>();   //生成一个新的结点
            tempNode.setData(t);
            tempNode.setNext(head);
            head = tempNode;    //把头换成新插入的结点
            length++;
        } else {    //当不是第一次插入并且插入的不是第一个时
            Node<T> n = this.head;
            int j = 1;  //计数器
            while(n != null && j < loc - 1) {
                n = n.getNext();
                j++;
            }
            Node<T> tempNode = new Node<T>();   //生成一个新的结点
            tempNode.setData(t);
            tempNode.setNext(n.getNext());  //将n的后继结点赋值给新的结点的后继
            n.setNext(tempNode);
            length++;
        }
        return true;
    }

    //删除元素
    public T deleteElem(int loc) {
        if(head == null || loc > length) {
            System.out.println("非法删除");
            return null;
        }
        T old;
        if(head != null && loc == 1) {
            old = head.getData();
            head = head.getNext();

        } else {
            Node<T> n = this.head;
            int j = 1;  //计数器
            while(n != null && j < loc - 1) {
                n = n.getNext();
                j++;
            }
            old = n.getNext().getData();
            n.setNext(n.getNext().getNext());
        }
        length--;
        return old;
    }


    public Node<T> getHead() {
        return head;
    }

    public void setHead(Node<T> head) {
        this.head = head;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

}

 

第四步，代码测试

package com.stucture.list.linkList;

import java.util.Random;

public class LinkListTest {
    final int MAX = 25;
    Random r = new Random();
    LinkList<Integer> linkList;

    public LinkListTest() {
        initSeqList();
    }

    //创建一个线性表顺序存储结构
    public void initSeqList() {
        linkList = new LinkList<Integer>(null);
        int length = Math.abs(r.nextInt(MAX));  //使用Random随机产生一个25左右的值,使用Math.abs()函数来取绝对值
        System.out.println("产生的链表长度为 ：" + length);

        for (int i = 1; i <= length; i++) {  //为生成的链表赋值，同时也测试了插入值的方法
            int j =r.nextInt(MAX);
            System.out.print(j + " ");

            if(!linkList.insertElem(i, j)) {
                System.exit(0);
            }
        }
        System.out.println("\n原始链表是 ：");
        display(linkList);
    }

    //测试删除方法
    public void deleteElem() {
        int i = r.nextInt(MAX);
        System.out.println("\n\n删除的位置是：" + i);
        Integer deleteNumber = linkList.deleteElem(i);

        if( deleteNumber == null) {
            System.exit(0);
        } else {
            System.out.println("删除的元素是 ： " + deleteNumber);
            System.out.println("删除元素后链表是 ：");
            display(linkList);
        }
    }

    //测试随机插入方法
    public void insertByRandom() {
        int i = r.nextInt(MAX);
        System.out.println("\n\n随机插入位置是 ：" + i);
        int elem = r.nextInt(MAX);
        System.out.println("随机插入数据是 ：" + elem);
        linkList.insertElem(i, elem);
        System.out.println("随机插入数据后链表是 ：");
        display(linkList);
    }

    //数据展示
    public  void display(LinkList<Integer> linkList) {
        Node<Integer> node = linkList.getHead();
        while(node != null) {
            System.out.print(node.getData() + " ");
            node = node.getNext();
        }
        System.out.println("链表的长度为 ：" + linkList.getLength());
    }

    //获取元素
    public void getElem() {
        int i = r.nextInt(MAX);
        System.out.println("\n获取位置为 ：" + i);
        System.out.println("获取到的元素为 : " + linkList.getElem(i));


    }

    public static void main(String[] args) {
        LinkListTest s = new LinkListTest();
        s.insertByRandom();
        s.deleteElem();
        s.getElem();
    }
}

 

 运行结果同样我不一一把各种结果列出啦，读者可以自己运行多几遍来进行学习：

产生的链表长度为 ：23
5 19 18 12 6 12 15 19 16 21 13 16 5 4 18 9 9 18 17 13 16 6 17
原始链表是 ：
5 19 18 12 6 12 15 19 16 21 13 16 5 4 18 9 9 18 17 13 16 6 17 链表的长度为 ：23


随机插入位置是 ：24
随机插入数据是 ：0
随机插入数据后链表是 ：
5 19 18 12 6 12 15 19 16 21 13 16 5 4 18 9 9 18 17 13 16 6 17 0 链表的长度为 ：24


删除的位置是：11
删除的元素是 ： 13
删除元素后链表是 ：
5 19 18 12 6 12 15 19 16 21 16 5 4 18 9 9 18 17 13 16 6 17 0 链表的长度为 ：23

获取位置为 ：12
5 19 18 12 6 12 15 19 16 21 16 5 获取到的元素为 : 5
/*
 * 头结点存储数据，即不带头结点的链表
 */
#include <stdio.h>
#include <stdlib.h>

#define OverFlow -1  //定义OverFlow表示内存溢出
#define OK        0  //定义OK表示成功
#define Error    -2  //定义操作失败的返回值
#define OverFlow -1; //定义OverFlow表示内存溢出
#define OK        0; //定义OK表示成功
#define Error    -2; //定义操作失败的返回值
/*
 * 首先定义一个数据类型int的别名ElemType，
 * 增强程序的可移植性，注意typedef和define的区别
 */
typedef int ElemType;
/*
 * 紧接着定义链表的节点，其实就是>=1个包含数据
 * 的元素（类型任意）和一个本结构体类型的Next指
 * 针（其值指向链表的下一个节点的地址）
 */
typedef struct node
{
    ElemType data;
    struct node *next;
} Node, *LinkList;
/*
 * 1.构建头结点不存储数据的空表（相对简单）
 * 注意函数参数传递的原理
 */
void Init_LinkList(LinkList *Head_pointer)
{
    *Head_pointer = NULL;
}
/*
 * 2.插入一个元素（头插）
 * 这时候不需要传入位置的数据，只需要传入头指针和数据
 */
int Insert_First(LinkList *Head_pointer, ElemType x)
{
    Node *p; //这里考虑为什么不用LinkList
    p = (Node *) malloc(sizeof Node);
    if (p == NULL)
        return OverFlow;
    p->data = x;

    p->next = *Head_pointer;
    *Head_pointer = p;

    return OK;
}
/*
 * 3.查找指定元素，注意这里用到了LinkList定义数据
 * 因为不是要定义一个节点，只是定义一个指针
 */
LinkList Location_LinkList(LinkList Head, ElemType x)
{
    LinkList p;
    p = Head;
    while(p != NULL)
    {
        if (p->data == x)
            break;
        p = p->next;
    }
    return p;
}
/*
 * 4.删除指定的元素
 * 有可能改变头结点的值，所以要传入指针
 * 对头结点就是要删除的元素进行单独处理
 */
int Delete_LinkList(LinkList *Head_pointer, ElemType x)
{
    Node *p, *q;
    p = *Head_pointer;
    if (p->data == x)//考虑头结点就是要删除的元素
    {
        *Head_pointer = (*Head_pointer)->next;
        free(p);
        return OK;
    }
    else
    {
        q = p; p = p->next; //q指向前一个节点，p指向下一个节点
        while(p != NULL)
        {
            if (p->data == x)
            {
                q->next = p->next;
                free(p);
                return OK;
            }
            q = p; p = p->next;
        }
    }
    return Error;
}
/*
 * 5.遍历线性表，打印每个数据
 * 只需要传入Head的值即可
 * 头结点为空需要打印空表，在linux的超级终端下注意中文编码问题
 */
void Show_LinkList(LinkList Head)
{
    LinkList p = Head;
    int i = 0;
    printf("----链表打印----\n");
    if (p == NULL) //处理头结点为空的情况
        printf("空表\n");
    while (p != NULL)
    {
        printf("[%d]:%d\t", i++, p->data);
        p = p->next;
    }
}
/*
 * 6.清空链表
 * 清除到头结点为空的状态，也就是一个空表的状态
 */
void SetNull_LinkList(LinkList *Head_pointer)
{
    LinkList p, q;
    p = *Head_pointer;
    while (p != NULL)
    {
        q = p;
        p = p->next;
        free(q);
    }
}
/*
 *8.调用单链表操作的主函数
 */
int main(void)
{
    LinkList Head;
    int i;
    Node *loca;
    ElemType x;

    Init_LinkList(&Head);
    do
    {
        printf("\n");
        printf("1---插入一个元素（Insert）\n");
        printf("2---查询一个元素（Locate）\n");
        printf("3---删除一个元素（Delete）\n");
        printf("4---显示所有元素（Show）\n");
        printf("5---计算表的长度（Length）\n");
        printf("6---退出\n");
        scanf("%d", &i);
        switch (i)
        {
            case 1: printf("请输入要插入的分数：\n");
                    scanf("%d", &x);
                    if (Insert_First(&Head, x) != OK)
                        printf("插入失败\n");
                    break;

            case 2: printf("请输入要查询的分数\n");
                    loca = Location_LinkList(Head, x);
                    if (loca != NULL)
                        printf("查询成功\n");
                    else
                        printf("查询失败\n");
                    break;

            case 3: printf("请输入要删除的分数\n");
                    scanf("%d", &x);
                    if (Delete_LinkList(&Head, x) != OK)
                        printf("删除失败\n");
                    else
                        printf("删除成功\n");
                    break;

            case 4: Show_LinkList(Head);
                    break;

            case 5: printf("表的长度是：%d", Length_LinkList(Head));
                    break;

            case 6: break;

            default:    printf("错误选择！请重选");
                        break;
        }
    } while (i != 6);

    SetNull_LinkList(&Head);
    printf("链表已清空，程序退出...\n");

    return 0;
}